C++ 实现俄罗斯方块游戏

✅作者简介：2022年博客新星第八。热爱国学的Java后端开发者，修心和技术同步精进。

🍎个人主页：Java Fans的博客

🍊个人信条：不迁怒，不贰过。小知识，大智慧。

💞当前专栏：Java案例分享专栏

✨特色专栏：国学周更-心性养成之路

🥭本文内容：C++ 实现俄罗斯方块游戏

文章目录

- 一、引言
- - [1. 俄罗斯方块的魅力](#1. 俄罗斯方块的魅力)
  - [2. 游戏的教育意义](#2. 游戏的教育意义)
  - [3. 项目的目标](#3. 项目的目标)
- 二、游戏设计
- - [1. 游戏界面](#1. 游戏界面)
  - [2. 砖块设计](#2. 砖块设计)
  - [3. 游戏逻辑](#3. 游戏逻辑)
  - [4. 控制方式](#4. 控制方式)
  - [5. 用户体验](#5. 用户体验)
  - [6. 代码结构](#6. 代码结构)
- 三、实现过程
- - [1. 环境设置](#1. 环境设置)
  - [2. 创建项目结构](#2. 创建项目结构)
  - [3. 设计数据结构](#3. 设计数据结构)
  - [4. 实现砖块生成](#4. 实现砖块生成)
  - [5. 实现砖块移动和旋转](#5. 实现砖块移动和旋转)
  - [6. 实现砖块下落和行消除](#6. 实现砖块下落和行消除)
  - [7. 实现行消除逻辑](#7. 实现行消除逻辑)
  - [8. 实现用户输入处理](#8. 实现用户输入处理)
  - [9. 实现游戏主循环](#9. 实现游戏主循环)
  - [10. 绘制游戏界面](#10. 绘制游戏界面)
  - [11. 测试和调试](#11. 测试和调试)
  - [12. 优化和扩展](#12. 优化和扩展)
- 四、完整代码
- 五、结论

一、引言

俄罗斯方块（Tetris）是一款风靡全球的经典益智游戏，自1984年首次发布以来，便吸引了无数玩家。其简单而富有挑战性的玩法使得这款游戏成为了电子游戏历史上的里程碑。玩家通过控制不同形状的砖块（称为"Tetrominoes"），将它们放置在一个由方格组成的游戏区域中，目的是填满水平行。当一行被完全填满时，它会消失，玩家将获得积分。随着游戏的进行，砖块下落的速度逐渐加快，增加了游戏的难度和紧迫感。

在这篇博文中，我们将深入探讨如何用 C++ 编写一个简单的俄罗斯方块游戏。我们将从游戏的基本概念和设计入手，逐步实现游戏的各个功能模块，包括砖块的生成、移动、旋转、行的消除以及分数的计算。通过这个项目，您不仅可以学习到 C++ 编程的基本技巧，还能了解游戏开发的基本原理和逻辑。

1. 俄罗斯方块的魅力

俄罗斯方块的魅力在于其简单易学的规则和深邃的策略性。尽管游戏的操作非常直观，但要在快速下落的砖块中做出正确的决策，仍然需要玩家具备良好的空间想象能力和快速反应能力。随着游戏的进行，玩家需要不断调整自己的策略，以应对不断增加的难度和复杂性。

2. 游戏的教育意义

除了娱乐，俄罗斯方块还具有一定的教育意义。它可以帮助玩家提高逻辑思维能力、手眼协调能力和反应速度。许多研究表明，玩俄罗斯方块可以增强大脑的认知能力，甚至有助于缓解压力和焦虑。因此，开发这样一款游戏不仅是一个有趣的编程项目，也是一个有益于身心健康的活动。

3. 项目的目标

本项目的目标是创建一个基本的俄罗斯方块游戏，具备以下功能：

砖块生成：随机生成不同形状的砖块。
砖块控制：允许玩家通过键盘控制砖块的移动和旋转。
行消除：检测并消除已填满的行，并更新分数。
游戏结束条件：当砖块堆叠到游戏区域顶部时，游戏结束。

通过实现这些功能，您将能够掌握游戏开发的基本概念，并为进一步的学习和探索打下坚实的基础。接下来，我们将详细介绍游戏的设计和实现过程。

二、游戏设计

在设计俄罗斯方块游戏时，我们需要考虑多个方面，包括游戏界面、游戏逻辑、控制方式、以及用户体验等。

1. 游戏界面

游戏界面是玩家与游戏互动的主要场所，设计时需要确保其简洁明了，易于操作。游戏界面通常包括以下几个部分：

游戏区域：这是一个由方格组成的矩形区域，通常为 10 列和 20 行。砖块将在这个区域内下落和堆叠。可以使用字符或图形来表示砖块和空白区域。
分数显示：在游戏区域的上方或旁边，显示当前的分数。分数会随着消除的行数增加而更新。
下一个砖块预览：在游戏区域的一侧，可以显示下一个即将出现的砖块，以帮助玩家提前规划。
游戏状态信息：可以显示游戏的状态信息，例如"游戏进行中"、"游戏结束"等提示。

2. 砖块设计

俄罗斯方块中的砖块（Tetrominoes）有七种基本形状，每种形状由四个方块组成。它们分别是：

I 形：一条直线，适合横向或纵向放置。
O 形：一个正方形，无法旋转。
T 形：一个"T"字形，具有多种放置方式。
L 形：一个"L"字形，具有多种放置方式。
J 形：一个"J"字形，具有多种放置方式。
S 形：一个"S"字形，具有多种放置方式。
Z 形：一个"Z"字形，具有多种放置方式。

每种砖块的生成是随机的，玩家在游戏中需要根据当前砖块的形状和位置，灵活调整放置策略。

3. 游戏逻辑

游戏逻辑是游戏的核心部分，主要包括以下几个方面：

砖块生成：在游戏开始时和每次消除行后，随机生成一个新的砖块，并将其放置在游戏区域的顶部中心位置。
砖块移动：玩家可以通过键盘控制砖块的左右移动和下落。需要检测砖块是否与其他砖块或边界发生碰撞，以确保砖块不会超出游戏区域或重叠。
砖块旋转：玩家可以通过键盘旋转砖块。旋转时需要检查砖块的新位置是否有效，避免与其他砖块或边界发生碰撞。
行消除：每当砖块下落后，需要检查游戏区域的每一行，判断是否被完全填满。如果一行被填满，则将其消除，并将上方的砖块下移。
游戏结束条件：当新的砖块生成时，如果其初始位置与已堆叠的砖块重叠，则游戏结束。

4. 控制方式

为了增强游戏的可玩性，控制方式需要简单直观。通常使用以下键盘控制：

左箭头：向左移动当前砖块。
右箭头：向右移动当前砖块。
下箭头：加速砖块下落。
上箭头：旋转当前砖块。

这些控制方式可以通过捕获键盘事件来实现，确保玩家能够快速反应并做出决策。

5. 用户体验

用户体验是游戏设计中不可忽视的一部分。为了提升玩家的体验，可以考虑以下几点：

音效和音乐：为游戏添加背景音乐和音效，可以增强游戏的氛围。例如，消除行时的音效和游戏结束时的提示音。
视觉效果：使用不同颜色或图案来区分不同形状的砖块，使游戏更加生动有趣。
难度调整：可以设计多个难度级别，随着玩家的进步，逐渐增加砖块下落的速度和复杂性。
暂停和重启功能：允许玩家在游戏中暂停，或在游戏结束后选择重新开始。

6. 代码结构

在实现游戏时，合理的代码结构可以提高可读性和可维护性。可以将代码分为多个模块，例如：

主程序模块：负责游戏的主循环和初始化。
游戏逻辑模块：处理砖块的生成、移动、旋转和行消除等逻辑。
界面模块：负责绘制游戏界面和更新显示。
输入模块：处理键盘输入和用户交互。

通过这样的设计，代码将更加清晰，便于后续的扩展和维护。

三、实现过程

在实现俄罗斯方块游戏的过程中，我们将按照以下步骤进行，确保每个功能模块都能顺利集成。整个过程将涵盖从环境设置到代码实现的各个方面。

1. 环境设置

首先，确保您有一个适合开发 C++ 的环境。推荐使用以下工具：

编译器：如 GCC、Clang 或 Microsoft Visual C++。
IDE：如 Visual Studio、Code::Blocks、CLion 或任何您熟悉的文本编辑器（如 VSCode、Sublime Text）。
控制台：由于我们将使用控制台进行游戏显示，确保您的开发环境支持控制台应用程序。

2. 创建项目结构

在您的开发环境中创建一个新的 C++ 项目，并设置基本的文件结构。可以考虑以下文件：

main.cpp：主程序文件，包含游戏的入口和主循环。
Tetris.h 和 Tetris.cpp：游戏逻辑的头文件和实现文件，包含砖块生成、移动、旋转等功能。
InputHandler.h 和 InputHandler.cpp：处理用户输入的模块。
Renderer.h 和 Renderer.cpp：负责绘制游戏界面的模块。

3. 设计数据结构

在 Tetris.h 中定义必要的数据结构。我们需要一个表示砖块的结构体和一个表示游戏区域的类。

cpp 复制代码

// Point 结构体表示砖块的坐标
struct Point {
    int x, y;
};

// Tetris 类表示游戏逻辑
class Tetris {
public:
    Tetris();
    void run();
    // 其他成员函数...

private:
    vector<vector<char>> board; // 游戏区域
    vector<Point> currentBlock;  // 当前砖块
    int score;                   // 当前分数
    bool gameOver;               // 游戏状态
    // 其他成员变量...
};

4. 实现砖块生成

在 Tetris.cpp 中实现砖块生成逻辑。可以使用随机数生成器来选择砖块的形状，并将其坐标存储在 currentBlock 中。

cpp 复制代码

vector<Point> Tetris::generateBlock() {
    vector<Point> block;
    int shape = rand() % 7; // 生成 0 到 6 之间的随机数

    switch (shape) {
        case 0: // I 形
            block = {{4, 0}, {4, 1}, {4, 2}, {4, 3}};
            break;
        case 1: // O 形
            block = {{4, 0}, {5, 0}, {4, 1}, {5, 1}};
            break;
        // 其他形状...
    }
    return block;
}

5. 实现砖块移动和旋转

在 Tetris.cpp 中实现砖块的移动和旋转逻辑。需要检查砖块的新位置是否有效，避免与其他砖块或边界发生碰撞。

cpp 复制代码

void Tetris::move(int dx) {
    for (const auto& p : currentBlock) {
        if (p.x + dx < 0 || p.x + dx >= WIDTH || board[p.y][p.x + dx] != EMPTY) {
            return; // 碰撞检测
        }
    }
    for (auto& p : currentBlock) {
        p.x += dx; // 移动砖块
    }
}

void Tetris::rotate() {
    // 简单的旋转逻辑
    for (auto& p : currentBlock) {
        int temp = p.x;
        p.x = p.y;
        p.y = -temp + 3; // 调整旋转中心
    }
}

6. 实现砖块下落和行消除

实现砖块的下落逻辑，并在每次下落后检查是否有行被填满。

cpp 复制代码

void Tetris::drop() {
    for (const auto& p : currentBlock) {
        if (p.y + 1 >= HEIGHT || board[p.y + 1][p.x] != EMPTY) {
            placeBlock(); // 放置砖块
            return;
        }
    }
    for (auto& p : currentBlock) {
        p.y++; // 下落砖块
    }
}

void Tetris::placeBlock() {
    for (const auto& p : currentBlock) {
        board[p.y][p.x] = BLOCK; // 更新游戏区域
    }
    clearLines(); // 检查并消除行
    currentBlock = generateBlock(); // 生成新砖块
}

7. 实现行消除逻辑

在 Tetris.cpp 中实现行消除的逻辑，检查每一行是否被填满，并更新分数。

cpp 复制代码

void Tetris::clearLines() {
    for (int y = HEIGHT - 1; y >= 0; y--) {
        bool fullLine = true;
        for (int x = 0; x < WIDTH; x++) {
            if (board[y][x] == EMPTY) {
                fullLine = false;
                break;
            }
        }
        if (fullLine) {
            board.erase(board.begin() + y); // 删除满行
            board.insert(board.begin(), vector<char>(WIDTH, EMPTY)); // 在顶部插入空行
            score += 100; // 增加分数
        }
    }
}

8. 实现用户输入处理

在 InputHandler.cpp 中实现用户输入的处理逻辑，捕获键盘事件并调用相应的控制函数。

cpp 复制代码

void Tetris::input() {
    if (_kbhit()) {
        switch (_getch()) {
            case 'a': move(-1); break; // 左移
            case 'd': move(1); break;  // 右移
            case 's': drop(); break;    // 加速下落
            case 'w': rotate(); break;   // 旋转
        }
    }
}

9. 实现游戏主循环

在 main.cpp 中实现游戏的主循环，负责初始化游戏、调用绘制和逻辑更新函数。

cpp 复制代码

int main() {
    srand(static_cast<unsigned>(time(0))); // 随机数种子
    Tetris game;
    game.run(); // 启动游戏
    return 0;
}

10. 绘制游戏界面

在 Renderer.cpp 中实现绘制游戏界面的逻辑，使用字符在控制台中显示游戏区域和分数。

cpp 复制代码

void Tetris::draw() {
    system("cls"); // 清屏
    for (int y = 0; y < HEIGHT; y++) {
        for (int x = 0; x < WIDTH; x++) {
            if (isBlockAt(x, y)) {
                cout << BLOCK; // 绘制砖块
            } else {
                cout << board[y][x]; // 绘制空白
            }
        }
        cout << endl;
    }
    cout << "Score: " << score << endl; // 显示分数
}

11. 测试和调试

在完成代码实现后，进行全面的测试和调试。确保所有功能正常工作，包括砖块的生成、移动、旋转、行消除和游戏结束条件。可以通过添加调试信息来帮助识别潜在问题。

12. 优化和扩展

在基本功能实现后，可以考虑优化代码和扩展功能。例如：

增加不同难度级别：根据玩家的表现调整砖块下落速度。
添加音效和背景音乐：提升游戏的沉浸感。
实现暂停和重启功能：增强用户体验。
保存高分记录：记录玩家的最高分数。

四、完整代码

以下是一个简单的 C++ 俄罗斯方块游戏的实现代码。你可以将其复制到你的 C++ 开发环境中进行编译和运行。

cpp 复制代码

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <conio.h> // For _kbhit() and _getch()

using namespace std;

const int WIDTH = 10;
const int HEIGHT = 20;
const char EMPTY = ' ';
const char BLOCK = '#';

struct Point {
    int x, y;
};

class Tetris {
public:
    Tetris() {
        board.resize(HEIGHT, vector<char>(WIDTH, EMPTY));
        currentBlock = generateBlock();
        score = 0;
        gameOver = false;
    }

    void run() {
        while (!gameOver) {
            draw();
            input();
            logic();
        }
        cout << "Game Over! Your score: " << score << endl;
    }

private:
    vector<vector<char>> board;
    vector<Point> currentBlock;
    int score;
    bool gameOver;

    vector<Point> generateBlock() {
        // Generate a random block shape
        vector<Point> block;
        int shape = rand() % 7;

        switch (shape) {
            case 0: // I
                block = {{4, 0}, {4, 1}, {4, 2}, {4, 3}};
                break;
            case 1: // O
                block = {{4, 0}, {5, 0}, {4, 1}, {5, 1}};
                break;
            case 2: // T
                block = {{4, 0}, {3, 1}, {4, 1}, {5, 1}};
                break;
            case 3: // L
                block = {{4, 0}, {4, 1}, {4, 2}, {5, 2}};
                break;
            case 4: // J
                block = {{4, 0}, {4, 1}, {4, 2}, {3, 2}};
                break;
            case 5: // S
                block = {{4, 1}, {5, 1}, {3, 0}, {4, 0}};
                break;
            case 6: // Z
                block = {{4, 0}, {5, 0}, {3, 1}, {4, 1}};
                break;
        }
        return block;
    }

    void draw() {
        system("cls"); // Clear the console
        for (int y = 0; y < HEIGHT; y++) {
            for (int x = 0; x < WIDTH; x++) {
                if (isBlockAt(x, y)) {
                    cout << BLOCK;
                } else {
                    cout << board[y][x];
                }
            }
            cout << endl;
        }
        cout << "Score: " << score << endl;
    }

    bool isBlockAt(int x, int y) {
        for (const auto& p : currentBlock) {
            if (p.x == x && p.y == y) {
                return true;
            }
        }
        return false;
    }

    void input() {
        if (_kbhit()) {
            switch (_getch()) {
                case 'a': move(-1); break; // Move left
                case 'd': move(1); break;  // Move right
                case 's': drop(); break;    // Drop block
                case 'w': rotate(); break;   // Rotate block
            }
        }
    }

    void move(int dx) {
        for (auto& p : currentBlock) {
            if (p.x + dx < 0 || p.x + dx >= WIDTH || board[p.y][p.x + dx] != EMPTY) {
                return; // Collision detected
            }
        }
        for (auto& p : currentBlock) {
            p.x += dx;
        }
    }

    void drop() {
        for (auto& p : currentBlock) {
            if (p.y + 1 >= HEIGHT || board[p.y + 1][p.x] != EMPTY) {
                placeBlock();
                return;
            }
        }
        for (auto& p : currentBlock) {
            p.y++;
        }
    }

    void rotate() {
        // Simple rotation logic (not perfect)
        for (auto& p : currentBlock) {
            int temp = p.x;
            p.x = p.y;
            p.y = -temp + 3; // Adjust rotation center
        }
    }

    void placeBlock() {
        for (const auto& p : currentBlock) {
            if (p.y < 0) {
                gameOver = true; // Game over if block is placed above the board
            }
            board[p.y][p.x] = BLOCK;
        }
        clearLines();
        currentBlock = generateBlock();
    }

    void clearLines() {
        for (int y = HEIGHT - 1; y >= 0; y--) {
            bool fullLine = true;
            for (int x = 0; x < WIDTH; x++) {
                if (board[y][x] == EMPTY) {
                    fullLine = false;
                    break;
                }
            }
            if (fullLine) {
                board.erase(board.begin() + y);
                board.insert(board.begin(), vector<char>(WIDTH, EMPTY));
                score += 100; // Increase score
            }
        }
    }
};

int main() {
    srand(static_cast<unsigned>(time(0))); // Seed random number generator
    Tetris game;
    game.run();
    return 0;
}

代码说明:

数据结构 ：使用 Point 结构体表示砖块的坐标，使用二维向量 board 表示游戏区域。
砖块生成 ：generateBlock 函数随机生成砖块的形状。
游戏循环 ：run 函数包含游戏的主循环，负责绘制界面、处理输入和更新逻辑。
输入处理 ：使用 _kbhit() 和 _getch() 函数处理键盘输入。
砖块移动和旋转：实现了砖块的移动、下落和旋转逻辑。
行消除 ：clearLines 函数检查并消除已填满的行。

五、结论

本文展示了如何使用 C++ 实现一个简单的俄罗斯方块游戏。虽然这个实现相对基础，但它提供了一个良好的起点，您可以在此基础上添加更多功能，例如计时器、不同难度级别、音效等。希望您能在这个项目中获得乐趣，并进一步探索游戏开发的世界！

码文不易，本篇文章就介绍到这里，如果想要学习更多Java系列知识，点击关注博主，博主带你零基础学习Java知识。与此同时，对于日常生活有困扰的朋友，欢迎阅读我的第四栏目：《国学周更---心性养成之路》，学习技术的同时，我们也注重了心性的养成。