C++实现简易俄罗斯方块小游戏

已于 2024-08-29 06:51:42 修改
阅读量463 收藏 9
点赞数 4
文章标签： c++ 游戏
于 2024-08-29 06:50:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laochao2020/article/details/141654854
版权

实现一个简易的俄罗斯方块（Tetris）游戏涉及多个方面，包括图形显示、游戏逻辑、用户输入等。下面是一个简化版本的俄罗斯方块游戏的实现步骤和代码示例。这个实现会使用 C++ 和一个简单的图形库——如 SFML（Simple and Fast Multimedia Library），这是一个非常适合游戏开发的跨平台图形库。

1. 环境准备

-安装 SFML:
你可以从 SFML 官网 下载适合你操作系统的版本。
按照安装说明配置 SFML 库到你的开发环境。

2. 游戏设计

游戏区域: 游戏区域是一个网格，每个网格单元格可以容纳一个方块（积木块）。
方块: 每个方块由不同的形状组成，通常由 4 个小方块构成。
控制: 允许玩家通过键盘控制方块的移动和旋转。

3. 完整实现的代码

1. 主要文件和目录结构
tetris/
├── main.cpp
├── Tetris.h
├── Tetris.cpp
├── Piece.h
├── Piece.cpp
├── Grid.h
├── Grid.cpp
├── resources/
│   └── (SFML资源文件)
└── CMakeLists.txt
2. main.cpp
#include <SFML/Graphics.hpp>
#include "Tetris.h"

int main() {
    sf::RenderWindow window(sf::VideoMode(300, 600), "Tetris");
    Tetris game;

    sf::Clock clock;
    while (window.isOpen()) {
        sf::Time deltaTime = clock.restart();
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }

        game.update(deltaTime.asSeconds());
        window.clear();
        game.draw(window);
        window.display();
    }

    return 0;
}
3. Tetris.h
#ifndef TETRIS_H
#define TETRIS_H

#include <SFML/Graphics.hpp>
#include "Piece.h"
#include "Grid.h"

class Tetris {
public:
    Tetris();
    void update(float deltaTime);
    void draw(sf::RenderWindow &window);

private:
    sf::RectangleShape blockShape;
    Piece currentPiece;
    Grid grid;
    sf::Clock moveClock;
    sf::Time moveInterval;

    void checkCollisions();
    void rotatePiece();
    void movePiece(int dx);
    void dropPiece();
    void mergePiece();
    void removeFullLines();
    bool isPositionValid(const Piece& piece, int dx, int dy);
};

#endif // TETRIS_H
4. Tetris.cpp
#include "Tetris.h"

Tetris::Tetris() : moveInterval(sf::seconds(0.5f)) {
    blockShape.setSize(sf::Vector2f(30, 30));
    blockShape.setFillColor(sf::Color::Cyan);
    currentPiece = Piece();
    grid = Grid();
}

void Tetris::update(float deltaTime) {
    if (moveClock.getElapsedTime() >= moveInterval) {
        moveClock.restart();
        dropPiece();
    }
    // Handle user input
    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
        movePiece(-1);
    } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
        movePiece(1);
    } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
        rotatePiece();
    }
}

void Tetris::draw(sf::RenderWindow &window) {
    // Draw the grid
    grid.draw(window);

    // Draw the current piece
    for (auto &block : currentPiece.getBlocks()) {
        blockShape.setPosition(block);
        window.draw(blockShape);
    }
}

void Tetris::checkCollisions() {
    // Check if the piece collides with the grid or other pieces
    if (!isPositionValid(currentPiece, 0, 0)) {
        mergePiece();
        removeFullLines();
        currentPiece = Piece(); // Create a new piece
    }
}

void Tetris::rotatePiece() {
    currentPiece.rotate();
    if (!isPositionValid(currentPiece, 0, 0)) {
        currentPiece.undoRotation();
    }
}

void Tetris::movePiece(int dx) {
    currentPiece.move(dx * 30, 0);
    if (!isPositionValid(currentPiece, dx * 30, 0)) {
        currentPiece.move(-dx * 30, 0);
    }
}

void Tetris::dropPiece() {
    currentPiece.move(0, 30);
    if (!isPositionValid(currentPiece, 0, 30)) {
        currentPiece.move(0, -30);
        mergePiece();
        removeFullLines();
        currentPiece = Piece(); // Create a new piece
    }
}

void Tetris::mergePiece() {
    grid.mergePiece(currentPiece);
}

void Tetris::removeFullLines() {
    grid.removeFullLines();
}

bool Tetris::isPositionValid(const Piece& piece, int dx, int dy) {
    for (auto &block : piece.getBlocks()) {
        sf::Vector2i pos((int)block.x + dx, (int)block.y + dy);
        if (pos.x < 0 || pos.x >= Grid::WIDTH || pos.y >= Grid::HEIGHT || grid.isOccupied(pos.x, pos.y)) {
            return false;
        }
    }
    return true;
}
5. Piece.h
#ifndef PIECE_H
#define PIECE_H

#include <vector>
#include <SFML/Graphics.hpp>

class Piece {
public:
    Piece();
    std::vector<sf::Vector2f> getBlocks() const;
    void rotate();
    void undoRotation();
    void move(float dx, float dy);

private:
    std::vector<sf::Vector2f> blocks;
    std::vector<sf::Vector2f> originalBlocks;
    void initializePiece();
    void rotateClockwise();
    void rotateCounterClockwise();
};

#endif // PIECE_H
6. Piece.cpp
#include "Piece.h"
#include <algorithm>

Piece::Piece() {
    initializePiece();
}

void Piece::initializePiece() {
    // Initialize with a default shape (e.g., a straight line)
    blocks = {
        {120, 0},
        {150, 0},
        {180, 0},
        {210, 0}
    };
    originalBlocks = blocks;
}

std::vector<sf::Vector2f> Piece::getBlocks() const {
    return blocks;
}

void Piece::rotate() {
    rotateClockwise();
}

void Piece::undoRotation() {
    blocks = originalBlocks;
}

void Piece::move(float dx, float dy) {
    for (auto &block : blocks) {
        block.x += dx;
        block.y += dy;
    }
}

void Piece::rotateClockwise() {
    // Implement rotation logic
}

void Piece::rotateCounterClockwise() {
    // Implement rotation logic
}
7. Grid.h
#ifndef GRID_H
#define GRID_H

#include <vector>
#include <SFML/Graphics.hpp>

class Grid {
public:
    static const int WIDTH = 10;
    static const int HEIGHT = 20;
    Grid();
    void draw(sf::RenderWindow &window);
    bool isOccupied(int x, int y) const;
    void mergePiece(const Piece &piece);
    void removeFullLines();

private:
    std::vector<std::vector<bool>> cells;
    void drawCell(sf::RenderWindow &window, int x, int y);
};

#endif // GRID_H
8. Grid.cpp
#include "Grid.h"

Grid::Grid() {
    cells.resize(HEIGHT, std::vector<bool>(WIDTH, false));
}

void Grid::draw(sf::RenderWindow &window) {
    for (int y = 0; y < HEIGHT; ++y) {
        for (int x = 0; x < WIDTH; ++x) {
            if (cells[y][x]) {
                drawCell(window, x, y);
            }
        }
    }
}

bool Grid::isOccupied(int x, int y) const {
    return cells[y][x];
}

void Grid::mergePiece(const Piece &piece) {
    for (const auto &block : piece.getBlocks()) {
        int x = block.x / 30;
        int y = block.y / 30;
        if (x >= 0 && x < WIDTH && y >= 0 && y < HEIGHT) {
            cells[y][x] = true;
        }
    }
}

void Grid::removeFullLines() {
    for (int y = 0; y < HEIGHT; ++y) {
        bool isFull = true;
        for (int x = 0; x < WIDTH; ++x) {
            if (!cells[y][x]) {
                isFull = false;
                break;
            }
        }
        if (isFull) {
            // Remove the full line
            cells.erase(cells.begin() + y);
            cells.insert(cells.begin(), std::vector<bool>(WIDTH, false));
        }
    }
}

void Grid::drawCell(sf::RenderWindow &window, int x, int y) {
    sf::RectangleShape cell(sf::Vector2f(30, 30));
    cell.setFillColor(sf::Color::Green);
    cell.setPosition(x * 30, y * 30);
    window.draw(cell);
}
9. CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(Tetris)

find_package(SFML 2.5 COMPONENTS graphics window system REQUIRED)

add_executable(Tetris main.cpp Tetris.cpp Piece.cpp Grid.cpp)
target_link_libraries(Tetris sfml-graphics sfml-window sfml-system)

4. 运行和测试

  1. 创建构建目录:

    mkdir build
cd build

  2. 生成构建文件:

    cmake ..

  3. 编译项目:

    make

  4. 运行游戏:

    ./Tetris

5. 游戏功能

  • 控制: 使用键盘的箭头键移动和旋转方块。
  • 方块生成: 初始生成一个方块，并在每次掉落后生成新的方块。
  • 碰撞检测: 检测方块是否与边界或其他方块碰撞。
  • 行消除: 检测并删除已填满的行。

以上是一个基础的俄罗斯方块游戏实现，其中还可以进一步扩展功能，如得分系统、游戏结束检测、不同形状的方块等。这些改进将进一步提升游戏的复杂性和可玩性。

LQS2020
关注
C++俄罗斯方块小游戏
WTC20120518的博客
02-11 294
C++免费1000多行俄罗斯方块小游戏。
Linux c 基础实现简易俄罗斯方块
m0_74341824的博客
11-15 554
简易版，还有点小ｂｕｇ．
c/c++ 实现俄罗斯方块小游戏（附全部源码）
热门推荐
q841447739的博客
08-11 2万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
c++写俄罗斯方块游戏
weixin_45590487的博客
09-20 1634
c++写俄罗斯方块游戏，主要用于复习，欢迎指正。
C++简易俄罗斯方块游戏3
m0_62037584的博客
03-23 140
能出背景图片，基本架构搭建。
多人联机的俄罗斯方块游戏（C++），游戏规则模仿任天堂Tetris99，基于qt，kcp，protobuf，qslog。
ZGD
12-09 6388
Tetris 多人联机的俄罗斯方块游戏，游戏规则模仿任天堂Tetris99，基于qt，kcp，protobuf，qslog
用C++编写的简易版的俄罗斯方块小游戏
03-21
《C++实现的简易版俄罗斯方块小游戏》 在编程世界中，开发一款小游戏是学习新语言或巩固已有技能的良好实践。本项目是用C++编程语言实现的一个简易版俄罗斯方块小游戏，它展示了C++的基本语法、面向对象编程概念...
俄罗斯方块小游戏 C++编程
07-04
这是一款简易的运用简单的C++编程的小游戏。
俄罗斯方块源代码_C-C++_game_
10-04
本项目是使用C/C++编程语言实现的一个简易版俄罗斯方块小游戏，旨在帮助初学者理解游戏开发的基本原理和C/C++编程技巧。 一、C/C++编程基础 在构建俄罗斯方块游戏时，首先需要掌握C/C++的基础语法，包括变量声明、...
一个简易的俄罗斯方块
06-29
《构建简易俄罗斯方块：基于VC++的编程实践》 在计算机编程的世界里，经典游戏“俄罗斯方块”因其简洁的规则和极高的娱乐性，一直是初学者学习编程的热门选择。本项目采用Visual Studio 2015（简称VS2015）作为开发...
C++版俄罗斯方块（不是C语言哦）
程序员Rock的博客
06-24 1万+
C++手写俄罗斯方块。
C++零基础项目：俄罗斯方块！详细思路+源码分享
C语言实战大全
12-20 8689
这是使用 C++ 和 EasyX 写的一个俄罗斯方块小游戏，里面用到的 C++ 特性并不多。游戏主要分成了两个类来实现：Game 和 Block 类，分别用来实现游戏逻辑和单独的俄罗斯方块，里面顶多就用到了静态成员函数和变量的特性，但主要的游戏逻辑还是放到了 main 函数中实现。这样，每个类分工明确，就实现了俄罗斯方块游戏。代码非常简单，里面的每个游戏逻辑都值得初学者分析和学习。
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 123
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 477
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 1065
💫往期文章👇：
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 885
set、map仿STL模拟实现
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 447
继续学习头文件的数学函数。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 739
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【C++ && Qt day11】
wzj46的博客
09-11 259
2、头文件窗口文件。
C++实现的俄罗斯方块游戏源代码
"c++编写的俄罗斯方块小游戏源代码，包含详细注释，用于学习游戏编程基础和C++实践。" 这篇摘要介绍了一个使用C++语言编写的俄罗斯方块小游戏的完整代码，适合初学者或者希望了解游戏编程基础知识的人进行学习。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值