C++控制台实现双人俄罗斯方块：游戏循环、碰撞检测与架构设计实战

1. 项目概述：为什么选择C++与控制台实现双人俄罗斯方块？

在游戏开发的学习路径上，俄罗斯方块是一个经典的里程碑项目。它规则简单，但背后涉及的游戏循环、碰撞检测、状态管理、用户输入处理等核心概念，是理解游戏开发基础的最佳实践。我选择用C++在控制台环境下实现一个双人版本，这背后有几个核心考量。

首先，C++提供了对内存和计算资源的直接控制。对于俄罗斯方块这种需要实时响应键盘输入、快速刷新屏幕、精确计算方块位置和碰撞的游戏，C++的高性能至关重要。虽然用Python或JavaScript也能实现，但在控制台环境下，要实现流畅的动画和即时响应，C++的效率和确定性是无可替代的。其次，控制台环境是一个“去繁就简”的绝佳沙盒。没有图形库（如SDL、SFML）的依赖，意味着我们必须直面最核心的问题：如何用字符（如[]、##）表示图形？如何管理屏幕刷新以避免闪烁？如何在一个“单线程”的程序中同时处理两个玩家的输入和游戏逻辑？这迫使开发者深入理解游戏的主循环、状态机和事件处理机制。

这个双人俄罗斯方块项目，不仅仅是两个单人游戏的简单并列。它引入了竞争与互动的维度，比如思考如何设计游戏区域布局（是左右并排还是上下分屏？）、如何处理可能同时发生的键盘输入冲突、以及是否要加入“攻击”机制（如一方消行会给另一方增加垃圾行）。这大大提升了项目的复杂度和趣味性，也更能锻炼一个开发者对系统架构和并发（尽管是模拟的）处理的能力。对于学习C++和游戏逻辑的初学者，以及想深入理解实时交互程序本质的中级开发者，这个项目都是一块极好的试金石。

2. 核心游戏架构与设计思路拆解

一个可运行的双人控制台游戏，其架构必须清晰。我们不能把所有代码都堆在main函数里。我的设计核心是基于对象的数据驱动和明确分层的游戏循环。

2.1 整体架构分层

我将整个项目分为四个逻辑层：

1. 数据层（Model）：定义所有游戏状态。包括GameBoard（游戏板）、Tetromino（方块）、PlayerState（玩家状态）等核心类。它们只负责存储数据和提供基本的数据操作方法（如“方块能否左移”），不涉及任何显示或输入逻辑。
2. 逻辑层（Controller/Game Logic）：这是游戏的大脑。它包含GameEngine类，负责驱动整个游戏循环：更新方块下落、检查消行、处理玩家输入（通过输入层传入）、判断游戏结束条件，并协调两个玩家实例之间的交互（如攻击）。
3. 表示层（View/Renderer）：负责将数据层的状态“画”到控制台上。我将其封装为ConsoleRenderer类。它的核心任务是将GameBoard中的数字矩阵（0表示空，1-7表示不同方块）转换为特定的字符组合，并在控制台的正确位置进行输出。这里要解决控制台光标定位、局部刷新以避免全屏闪烁等关键问题。
4. 输入层（Input Handler）：独立线程或非阻塞输入检测模块。由于是双人游戏，必须能够同时监听两套按键（如玩家1用WASD，玩家2用方向键）。在Windows控制台，我们需要使用_kbhit()和_getch()等函数来实现非阻塞的键盘输入检测，并将按键事件转化为逻辑层能理解的命令（如MOVE_LEFT, ROTATE）。

这种分层设计的好处是高内聚、低耦合。例如，如果你想将来把控制台界面换成图形界面，你只需要重写表示层，数据层和逻辑层几乎可以复用。逻辑的单元测试也可以更方便地进行。

2.2 双人模式的关键设计决策

1. 游戏区域布局：我选择了左右并排布局。两个玩家的游戏区域（Board）在控制台屏幕上左右排列，中间用一条清晰的竖线分隔，上方显示各自的分数、等级、下一个方块预览。这种布局最符合直觉，也便于玩家观察对手的情况。在代码中，这体现为两个独立的PlayerState对象，每个对象包含自己的GameBoard、当前方块、分数等。
2. 输入处理策略：这是控制台双人游戏的难点。在单线程程序中，我采用**“输入采样”**策略。在主游戏循环的每一帧，输入层都会快速检查所有关心的按键是否被按下。由于循环速度很快（例如每秒30帧），给人的感觉就是输入是实时响应的。我会为两个玩家定义不同的键位映射表，在采样时一并检查。
3. 交互机制：为了增加趣味性，我实现了基础的攻击系统。规则是：当一名玩家一次性消除2行、3行或4行（Tetris）时，他不仅自己得分，还会向对手的游戏区域底部发送相应数量的“垃圾行”（底部随机出现几个空洞的行）。这直接增加了对手的游戏难度。这个机制需要在逻辑层的消行处理函数中，不仅更新自己的分数和棋盘，还要向对手的GameBoard对象插入垃圾行。

3. 核心模块的C++实现细节

3.1 数据定义：方块与棋盘

一切始于数据结构的定义。俄罗斯方块有7种基本形状（I, J, L, O, S, T, Z），每种形状有1到4种旋转状态。

// 方块类型枚举 enum class TetrominoType { I, J, L, O, S, T, Z, NONE }; // 用一个4x4的布尔矩阵来定义一种旋转状态下的方块形状 struct RotationState { bool shape[4][4]; // true表示有方块，false表示空 int topLeftX; // 该形状在4x4网格中的相对偏移（用于绘制和碰撞计算） int topLeftY; }; class Tetromino { public: TetrominoType type; int rotationIndex; // 当前旋转状态的索引 int posX, posY; // 方块左上角在游戏棋盘（Board）中的坐标 std::vector<RotationState> rotations; // 该类型方块的所有旋转状态 Tetromino(TetrominoType t); void rotate(); // 切换到下一个旋转状态 const RotationState& getCurrentRotation() const; // ... 其他方法，如获取方块所有格子的绝对坐标 };

GameBoard类则代表一个玩家的游戏区域，通常为10列宽，20行高（可见区域）。

class GameBoard { private: static const int WIDTH = 10; static const int HEIGHT = 20; int grid[HEIGHT][WIDTH] = {0}; // 0为空，1-7为已固定的方块类型 public: bool isCollision(const Tetromino& t) const; // 碰撞检测核心函数 void mergeTetromino(const Tetromino& t); // 将当前方块固定到棋盘 int clearLines(); // 清除满行，返回清除的行数，并处理上方方块下落 void addGarbageLine(int holes); // 在底部添加一行垃圾（用于攻击） // ... 其他辅助方法 };

注意：grid使用int而非bool，是为了方便后续用不同数字代表不同颜色（在控制台中可以用不同颜色输出），也为可能的图形化扩展留有余地。isCollision函数需要检查方块的每一个“实心”格子，其转换到棋盘坐标后，是否超出边界或与grid中已固定的格子重叠。

3.2 游戏主循环：心跳与节奏

游戏主循环是驱动一切的引擎。一个稳定、帧率可控的循环至关重要。

void GameEngine::run() { initGame(); // 初始化两个玩家状态、棋盘等 auto lastTime = std::chrono::steady_clock::now(); const std::chrono::milliseconds frameDuration(33); // 目标帧时间 ~30 FPS while (!gameOver) { auto currentTime = std::chrono::steady_clock::now(); auto elapsed = currentTime - lastTime; // 处理输入（非阻塞） handleInput(); // 如果距离上一帧过去了足够的时间，则更新游戏逻辑 if (elapsed >= frameDuration) { updateGame(elapsed); // 更新方块下落、检查状态等 renderGame(); // 渲染到控制台 lastTime = currentTime; } else { // 时间未到，可以短暂休眠，降低CPU占用 std::this_thread::sleep_for(std::chrono::milliseconds(1)); } } showGameOver(); }

在updateGame函数中，我们需要为每个玩家独立更新他们的游戏状态。核心是下落计时器。每个玩家有一个独立的计时器，当计时器到期，其当前方块就下落一格。玩家的等级越高，这个计时器的间隔就越短，游戏速度越快。

void GameEngine::updateGame(const std::chrono::duration<double>& deltaTime) { for (auto& player : players) { player.fallTimer += deltaTime; if (player.fallTimer >= player.getCurrentFallInterval()) { if (!moveTetromino(player, 0, 1)) { // 尝试下落一格，如果失败则固定方块 lockTetromino(player); int linesCleared = player.board.clearLines(); if (linesCleared > 0) { updateScore(player, linesCleared); // 如果开启了攻击模式，根据消行数攻击对手 if (attackModeEnabled) { attackOpponent(player, linesCleared); } } spawnNewTetromino(player); if (isCollision(player.currentTetromino)) { // 新方块出生即碰撞，游戏结束 player.isAlive = false; } } player.fallTimer = std::chrono::duration<double>::zero(); } } gameOver = std::all_of(players.begin(), players.end(), [](const PlayerState& p) { return !p.isAlive; }); }

实操心得：使用std::chrono进行高精度计时，比传统的clock()或Sleep()更可靠、更现代。将帧时间（frameDuration）与逻辑更新时间（fallTimer）解耦，使得即使渲染因故变慢，游戏逻辑的推进速度依然是均匀的，这能防止游戏在慢机器上变得“卡顿但飞快”。

3.3 控制台渲染的艺术

在控制台中绘制游戏界面，目标是清晰、无闪烁。核心是双缓冲和局部更新。

1. 屏幕缓冲区：我们不在控制台上直接擦写。而是先在内存中构建一个完整的“帧缓冲区”（比如一个二维字符数组），代表这一帧整个游戏窗口应该显示的样子。
2. 局部更新：将当前帧缓冲区与上一帧缓冲区进行比较。只将那些内容发生了变化的屏幕位置，通过控制台API进行更新。这可以极大减少光标移动和字符输出次数，从根本上消除闪烁。

class ConsoleRenderer { private: CHAR_INFO* frontBuffer; // 当前帧缓冲区 CHAR_INFO* backBuffer; // 下一帧缓冲区 int screenWidth, screenHeight; HANDLE consoleHandle; COORD bufferSize, characterPos; SMALL_RECT writeRegion; void drawBoardToBuffer(const GameBoard& board, int offsetX, int offsetY); void drawTetrominoToBuffer(const Tetromino& t, int offsetX, int offsetY); void drawUI(const PlayerState& player, int offsetX, int offsetY); public: void render(const GameState& state); };

在render函数中：

• 首先，将backBuffer清空或填充为背景。
• 然后，依次调用drawBoardToBuffer、drawTetrominoToBuffer、drawUI，将两个玩家的所有游戏元素绘制到backBuffer的相应位置。
• 绘制完成后，将backBuffer与frontBuffer进行逐字符比较，计算出需要更新的最小矩形区域。
• 最后，使用WriteConsoleOutput函数，一次性将backBuffer中变化区域的内容输出到控制台。
• 交换frontBuffer和backBuffer的指针。

踩坑记录：Windows控制台默认的行缓冲模式会导致输出延迟和闪烁。必须使用SetConsoleMode关闭行缓冲(ENABLE_LINE_INPUT)和快速编辑模式(ENABLE_QUICK_EDIT_MODE)，并启用虚拟终端序列（如果使用颜色）或直接使用WriteConsoleOutput以获得最佳性能。WriteConsoleOutput能直接操作控制台屏幕缓冲区，是效率最高的方法，但坐标计算需要格外小心。

3.4 非阻塞双人输入处理

在Windows控制台，_kbhit()检查是否有按键，_getch()获取按键。我们需要为两个玩家分别维护一个按键状态映射。

class InputHandler { private: // 定义玩家的按键映射 std::map<int, PlayerAction> player1KeyMap = { {'a', PlayerAction::MOVE_LEFT}, {'d', PlayerAction::MOVE_RIGHT}, {'s', PlayerAction::MOVE_DOWN}, {'w', PlayerAction::ROTATE}, {' ', PlayerAction::HARD_DROP} }; std::map<int, PlayerAction> player2KeyMap = { {VK_LEFT, PlayerAction::MOVE_LEFT}, {VK_RIGHT, PlayerAction::MOVE_RIGHT}, {VK_DOWN, PlayerAction::MOVE_DOWN}, {VK_UP, PlayerAction::ROTATE}, {VK_RETURN, PlayerAction::HARD_DROP} // 用回车键实现硬降 }; std::array<bool, static_cast<size_t>(PlayerAction::COUNT)> player1Actions{false}; std::array<bool, static_cast<size_t>(PlayerAction::COUNT)> player2Actions{false}; public: void pollEvents() { // 清空上一帧的动作状态（取决于你想实现“按下持续生效”还是“单次触发”） // 这里以“按下持续生效”为例，不清空，而是在按键释放时再重置为false。 // 为了简化，我们每帧采样，实现“按下即生效一次”的逻辑。 std::fill(player1Actions.begin(), player1Actions.end(), false); std::fill(player2Actions.begin(), player2Actions.end(), false); while (_kbhit()) { int ch = _getch(); // 处理扩展键码（如方向键是两个字节，第一个是0或224） if (ch == 0 || ch == 224) { ch = _getch(); // 获取真正的键码 auto it = player2KeyMap.find(ch); if (it != player2KeyMap.end()) { player2Actions[static_cast<size_t>(it->second)] = true; } } else { // 处理玩家1的按键（小写字母） auto it1 = player1KeyMap.find(ch); if (it1 != player1KeyMap.end()) { player1Actions[static_cast<size_t>(it1->second)] = true; } // 也可以处理玩家2的非扩展键（如回车） auto it2 = player2KeyMap.find(ch); if (it2 != player2KeyMap.end()) { player2Actions[static_cast<size_t>(it2->second)] = true; } } } } bool isActionPressed(int playerId, PlayerAction action) const { if (playerId == 1) return player1Actions[static_cast<size_t>(action)]; else return player2Actions[static_cast<size_t>(action)]; } };

在游戏主循环的handleInput()中，调用inputHandler.pollEvents()，然后根据isActionPressed的返回值来移动或旋转对应玩家的方块。

重要提示：_getch()在读取方向键等扩展键时，会先返回一个0或224，需要再次调用_getch()才能得到实际的键码。这是一个经典的坑点，必须正确处理，否则玩家2的按键会失灵或产生乱码。

4. 高级功能实现与优化

4.1 攻击系统的实现

攻击系统是双人游戏的灵魂。当玩家A消行时，根据消行数生成垃圾行，插入玩家B的棋盘底部。

void GameEngine::attackOpponent(PlayerState& attacker, int linesCleared) { int targetPlayerId = (attacker.id == 1) ? 2 : 1; PlayerState& target = getPlayer(targetPlayerId); int garbageLines = 0; switch(linesCleared) { case 1: garbageLines = 0; break; // 单行不攻击，或攻击1行，取决于规则 case 2: garbageLines = 1; break; case 3: garbageLines = 2; break; case 4: garbageLines = 4; break; // Tetris奖励更多 default: break; } if (garbageLines > 0) { for (int i = 0; i < garbageLines; ++i) { // 在底部添加一行垃圾，随机生成一个空洞 target.board.addGarbageLine(1); // 参数1表示一个空洞 } // 可能需要立即检查目标玩家的当前方块是否与新插入的垃圾行碰撞 // 如果碰撞，可能需要强制锁定当前方块，这取决于规则设计。 } }

GameBoard::addGarbageLine的实现需要将棋盘所有现有行向上移动一行，最顶行被丢弃，然后在最底部新生成一行垃圾。垃圾行通常是满的，但随机有1-3个空洞，这给对手留下了生存空间。

void GameBoard::addGarbageLine(int holeCount) { // 1. 所有行上移一行，丢弃第0行 for (int y = 0; y < HEIGHT - 1; ++y) { for (int x = 0; x < WIDTH; ++x) { grid[y][x] = grid[y + 1][x]; } } // 2. 生成最底部新行（第HEIGHT-1行） // 先全部填满一种“垃圾”方块类型（比如8） for (int x = 0; x < WIDTH; ++x) { grid[HEIGHT - 1][x] = 8; } // 3. 随机挖洞 std::vector<int> holePositions(WIDTH); std::iota(holePositions.begin(), holePositions.end(), 0); // 生成0到WIDTH-1的序列 std::shuffle(holePositions.begin(), holePositions.end(), std::mt19937(std::random_device()())); for (int i = 0; i < holeCount && i < WIDTH; ++i) { grid[HEIGHT - 1][holePositions[i]] = 0; // 挖洞 } }

4.2 游戏节奏与难度曲线

一个好的俄罗斯方块游戏，难度应该随时间或分数平滑增加。这通过调整方块的下落间隔来实现。

class PlayerState { public: int score; int level; int linesClearedTotal; std::chrono::duration<double> fallTimer; std::chrono::duration<double> getCurrentFallInterval() const { // 经典公式：初始间隔为1秒，每升10级速度加倍（间隔减半） // 或者使用一个预定义的间隔表 static const std::array<double, 20> intervals = { 1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.35, 0.3, 0.25, 0.2, 0.18, 0.16, 0.14, 0.12, 0.10, 0.08, 0.07, 0.06, 0.05 }; int index = std::min(level, static_cast<int>(intervals.size()) - 1); return std::chrono::duration<double>(intervals[index]); } void updateLevel() { // 例如，每消除10行升一级 level = (linesClearedTotal / 10) + 1; } };

在玩家消行后，更新其总消行数和等级。下一次getCurrentFallInterval被调用时，就会返回更短的时间间隔，方块下落更快。

4.3 方块预览与暂存（Hold）

现代俄罗斯方块的标准功能。我将其作为PlayerState的一部分。

class PlayerState { public: Tetromino currentTetromino; Tetromino nextTetromino; std::optional<TetrominoType> heldTetrominoType; // 暂存的方块类型 bool canHold; // 本次下落周期内是否已经使用过Hold功能 bool holdCurrent() { if (!canHold) return false; if (heldTetrominoType.has_value()) { // 如果已经有暂存的方块，则交换 TetrominoType temp = currentTetromino.type; currentTetromino = Tetromino(heldTetrominoType.value()); heldTetrominoType = temp; } else { // 如果没有，则暂存当前方块，并生成新的当前方块 heldTetrominoType = currentTetromino.type; currentTetromino = nextTetromino; spawnNextTetromino(); // 从随机序列中获取下一个 } canHold = false; // 本次下落周期内不能再Hold resetTetrominoPosition(currentTetromino); // 将新方块放到出生点 return true; } void onTetrominoLocked() { canHold = true; // 方块固定后，重置Hold能力 } };

在渲染时，将nextTetromino和heldTetrominoType绘制在棋盘旁边的预览区域即可。

5. 编译、运行与调试实战

5.1 项目结构与编译环境

一个清晰的项目结构有助于管理。我的项目目录如下：

DoubleTetris/ ├── src/ │ ├── main.cpp // 程序入口，初始化游戏引擎并运行 │ ├── GameEngine.cpp/h // 游戏主循环和逻辑协调 │ ├── GameBoard.cpp/h // 棋盘数据与操作 │ ├── Tetromino.cpp/h // 方块数据与操作 │ ├── PlayerState.cpp/h // 玩家状态（分数、等级、方块等） │ ├── ConsoleRenderer.cpp/h // 控制台渲染器 │ ├── InputHandler.cpp/h // 输入处理器 │ └── Utils.cpp/h // 工具函数（如随机数生成） ├── include/ // 公共头文件（如果使用） └── CMakeLists.txt // CMake构建脚本

我强烈推荐使用CMake作为构建工具。它跨平台，并且与现代IDE（如VS Code、CLion）集成良好。

cmake_minimum_required(VERSION 3.10) project(DoubleTetris) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 如果是Windows，需要链接Console库 if (WIN32) add_executable(DoubleTetris src/main.cpp ... 所有.cpp文件) target_link_libraries(DoubleTetris) else() # Linux/macOS可能需要链接其他库，如pthread add_executable(DoubleTetris src/main.cpp ...) endif()

在VS Code中，配置tasks.json和launch.json可以实现一键编译调试。关键在于launch.json中的externalConsole设置，对于控制台游戏，通常需要设为true以弹出原生控制台窗口，获得更好的输入输出体验。

5.2 常见编译与运行时问题排查

1. “error: ‘_kbhit’ was not declared in this scope” / “_getch”错误：

   • 原因：_kbhit和_getch是Windows特有的函数，定义在<conio.h>头文件中。
   • 解决：确保代码包含了#include <conio.h>，并且你的编译目标是Windows。如果你希望跨平台，需要编写抽象的输入处理层，在Windows下使用_kbhit，在Linux/macOS下使用<termios.h>和<fcntl.h>实现非阻塞输入。

2. 控制台窗口一闪而过：

   • 原因：程序正常结束后控制台立即关闭。
   • 解决：在main函数末尾，游戏循环结束后，添加system("pause");（仅Windows）或使用std::cin.get()等待一个输入。在调试时，IDE通常会自动暂停。

3. 游戏运行卡顿、输入延迟：

   • 原因：可能是渲染过于频繁（每帧全屏刷新），或者游戏逻辑更新与渲染没有分离，又或者Sleep函数精度不足导致循环不稳定。
   • 排查：
     • 检查是否实现了双缓冲渲染和局部更新。使用性能分析工具或简单的帧计时，看看每帧耗时是否稳定。
     • 确保游戏逻辑更新（updateGame）是**基于时间增量（deltaTime）**的，而不是每帧固定推进。这样即使帧率波动，游戏速度也恒定。
     • 将std::this_thread::sleep_for替换为更精确的等待，或者采用忙等待+精确计时的方式（对于这种小游戏，忙等待的CPU占用也可以接受）。

4. 双人按键互相干扰或失灵：

   • 原因：输入处理逻辑有bug，特别是处理扩展键码时。
   • 排查：
     • 打印出每次_getch()读取到的键值，确认玩家2的按键（如方向键）是否被正确识别为两个字节序列。
     • 检查键位映射表是否正确，没有重复或冲突的键值。
     • 确保输入采样pollEvents在游戏主循环的每一帧都被调用。

5. 方块旋转时穿墙或卡住：

   • 原因：旋转的碰撞检测算法（Wall Kick）不完善。俄罗斯方块官方有标准的“墙踢”表，定义了当旋转后发生碰撞时，方块应该尝试向哪些方向微调。
   • 解决：实现一个tryRotate函数。当玩家尝试旋转时，先计算旋转后的形状，然后检查是否碰撞。如果碰撞，则按照预定义的偏移表（例如，对于I和J/L/S/T/Z方块，偏移表不同）依次尝试将方块向左、右、上或下微调一格，直到找到一个不碰撞的位置。如果所有偏移都失败，则旋转被阻止。

5.3 性能优化小技巧

• 避免在热路径中动态内存分配：在游戏主循环（尤其是每帧执行的函数）中，避免使用new/delete或std::vector的push_back等可能引发堆分配的操作。对于固定大小的数据结构（如4x4的方块形状），使用std::array。
• 使用查找表（LUT）：例如，方块旋转后的形状、墙踢偏移数据、分数计算表（消1行100分，2行300分等），都可以定义为编译期的常量数组，避免运行时计算。
• 减少函数调用开销：将一些简单的、频繁调用的函数（如获取某个格子的值）声明为inline。
• 明智地使用循环：在碰撞检测、消行检查等需要遍历棋盘的代码中，注意循环的顺序和边界条件，避免不必要的检查。

6. 项目扩展思路与个人心得

完成基础的双人对战版本后，这个项目还有巨大的扩展空间，可以持续深化你的C++和游戏开发技能。

可扩展的方向：

1. 网络对战：将双人逻辑从本地拆分，一个程序作为主机（服务器），另一个作为客户端。使用Socket编程（如Berkeley套接字或asio库）同步两个游戏状态。这会引入网络延迟、预测、状态同步等全新的挑战。
2. AI对手：实现一个简单的AI，使用经典的BFS搜索算法，评估所有可能的方块放置位置和旋转状态，选择一个能消除最多行、创造最平滑棋盘表面的位置。你可以让AI作为一个玩家加入游戏。
3. 更丰富的游戏模式：例如“竞速模式”（看谁先消40行）、“生存模式”（随着时间自动增加垃圾行）、“道具模式”（随机出现增加行、清除行等道具）。
4. 图形化界面：用简单的图形库（如EasyX for Windows, Raylib, SFML）替换控制台渲染层，实现真正的图形化游戏。你的核心游戏逻辑（Model和Controller）几乎可以无缝迁移。

个人实操心得： 这个项目让我对“状态”和“时间”在游戏中的管理有了刻骨的理解。最初我的方块下落速度不稳定，时快时慢，就是因为简单用了Sleep(100)然后让方块下落，没有考虑一帧内可能处理输入、渲染耗时不同。切换到基于std::chrono的增量时间后，游戏立刻变得丝滑。

另一个深刻的教训是关于代码组织。最早我把所有东西都写在main.cpp里，当要加第二个玩家时，代码立刻变得混乱不堪。强迫自己进行分层设计，虽然前期多花了时间画类图、思考接口，但后期添加攻击系统、Hold功能时，修改起来非常清晰和轻松，基本只在一个类里做加法。

最后，测试驱动的思想很有帮助。我为GameBoard的isCollision和clearLines方法编写了简单的单元测试，用预设好的棋盘状态去验证函数的输出。这在我调整消行算法和攻击系统的垃圾行插入逻辑时，帮我快速定位了多个隐蔽的bug。

控制台编程看似古老，但它剥离了华丽的图形外壳，让你直面程序逻辑、算法效率和架构设计的核心。这个用C++打造的双人俄罗斯方块，就像一把精心打磨的瑞士军刀，小巧但功能完备，其背后蕴含的设计思想，足以让你在迈向更复杂游戏项目的路上，走得更稳、更自信。