C++控制台贪吃蛇：从游戏循环到数据结构实战

1. 项目概述与核心价值

最近在整理一些老项目，翻到了当年学C++时写的第一个像样点的程序——一个控制台下的贪吃蛇。现在看代码可能有点稚嫩，但实现过程中的那些坑和思考，对理解C++基础、游戏循环逻辑和状态管理特别有帮助。很多新手朋友觉得C++入门后不知道做什么，或者觉得做图形界面太复杂，其实从这种纯控制台的小游戏入手，既能巩固语法，又能接触到“游戏循环”、“状态更新”、“用户输入处理”这些核心概念，性价比极高。

这个项目本质上是一个实时交互的控制台应用程序。它不依赖任何图形库（如SDL、SFML），纯粹利用Windows的Console API或者跨平台的ncurses库（这里我们主要讨论Windows环境）来操纵光标位置、设置颜色和监听键盘事件。核心要解决的问题是：如何在一个固定的“棋盘”上，让一条由多个节点组成的“蛇”根据玩家指令移动，并处理“吃食物”和“撞墙/撞自身”的逻辑。对于初学者而言，难点往往不在于C++语法本身，而在于如何将脑海中的游戏规则，转化为清晰的数据结构和严谨的状态迁移逻辑。

适合谁来参考这篇内容呢？如果你已经学完了C++的基础语法（类、函数、数组、指针），想找一个综合性的小项目练手；或者你对“游戏循环”这个概念感到抽象，想通过具体代码看看while循环里到底该写什么；亦或是你被控制台的光标跳转、颜色设置这些“黑魔法”搞得一头雾水，那么跟着这个思路走一遍，应该会有豁然开朗的感觉。接下来，我会从设计思路开始，一步步拆解如何用C++搭建这个经典游戏。

2. 整体设计与核心思路拆解

在动手写代码之前，我们先得把游戏拆解成几个核心模块，并决定它们之间如何协作。这是避免代码写到一半逻辑混乱的关键。

2.1 核心数据结构定义

贪吃蛇游戏的状态可以用几个核心部分来描述：

1. 游戏地图（Board）：一个二维的网格，比如20行x40列。每个格子可以是空地、蛇身、食物或者墙（如果设计有墙的话）。
2. 蛇（Snake）：本质上是一个动态的节点序列。每个节点有坐标（x, y）。蛇头是序列的第一个节点，蛇尾是最后一个。移动时，蛇头向新方向增加一个节点，如果没吃到食物，则删除蛇尾节点，实现移动效果。
3. 食物（Food）：一个随机出现在空地格子上的坐标点。
4. 游戏状态（Game State）：包括当前分数、蛇的移动方向、游戏是否结束等。

在C++中，我们如何表示这些？对于地图，一个二维数组（如char map[HEIGHT][WIDTH]）最直观，但更新效率一般。更高效的做法是只存储蛇和食物的坐标，绘制时再动态计算。这里我推荐后者，因为它更贴近“数据驱动”的思想。蛇的身体可以用std::vector<std::pair<int, int>>或者std::deque来存储，deque（双端队列）在头部插入和尾部删除的操作都是O(1)，非常契合贪吃蛇“头进尾出”的特性。

// 示例：核心数据结构定义 #include <deque> #include <utility> // for std::pair const int WIDTH = 40; const int HEIGHT = 20; enum class Direction { UP, DOWN, LEFT, RIGHT, NONE }; class Game { private: std::deque<std::pair<int, int>> snake; // 蛇身，队首是头，队尾是尾 std::pair<int, int> food; Direction dir; int score; bool isGameOver; // ... 其他成员，如游戏速度等 };

2.2 游戏主循环（Game Loop）架构

这是游戏的心脏，一个不断重复执行的循环。每一次循环称为一“帧”（Frame）。控制台游戏没有固定的帧率，我们需要用延时来控制游戏速度。经典的游戏循环包含四个步骤：

1. 处理输入（Process Input）：非阻塞地检测键盘按键，更新蛇的移动方向。这里的关键是“非阻塞”，你不能让cin或getch卡住程序的运行。
2. 更新游戏状态（Update）：根据当前方向，计算蛇头的新位置。然后判断：是否吃到食物？是否撞墙或撞到自己？根据结果更新蛇身队列、分数和游戏状态。
3. 渲染输出（Render）：清空控制台屏幕，根据最新的游戏状态，重新绘制地图、蛇、食物和分数信息。
4. 延时控制（Delay）：让程序休眠一小段时间（如100毫秒），以控制游戏速度。

这个循环会一直运行，直到isGameOver变为true。

// 游戏主循环伪代码 void Game::Run() { Initialize(); // 初始化游戏（生成蛇、食物等） while (!isGameOver) { auto startTime = std::chrono::steady_clock::now(); ProcessInput(); Update(); Render(); auto endTime = std::chrono::steady_clock::now(); auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime); int delayTime = frameIntervalMs - elapsedTime.count(); if (delayTime > 0) { std::this_thread::sleep_for(std::chrono::milliseconds(delayTime)); } } GameOver(); // 显示结束信息 }

注意：这里使用了<chrono>和<thread>库来实现精确延时。避免使用Sleep()函数，因为它不够精确且可能阻塞整个线程。通过计算一帧实际耗时并补足剩余时间，可以使得游戏速度在不同性能的电脑上更稳定。

2.3 输入处理方案选型

在Windows控制台处理键盘输入，常见的有几种方法：

• _kbhit()+_getch()：这是最经典的方法。_kbhit()非阻塞地检查是否有按键，_getch()获取按键。需要包含<conio.h>，但这不是标准C++库，且通常只在Windows可用。
• Windows API：使用GetAsyncKeyState()函数，可以检测某个键在当前时刻是否被按下。这种方式更灵活，能同时处理多个按键。
• 第三方库（如ncurses）：跨平台解决方案，功能强大。

对于这个简单的贪吃蛇，我推荐使用_kbhit()和_getch()的组合，因为它简单直接，足以满足“按方向键控制”的需求。但我们需要处理一个关键问题：如何防止玩家在极短时间内输入多个方向导致蛇“掉头”自杀？例如，蛇向右移动时，快速按左键再按下键，如果处理不当，蛇头可能瞬间向左，撞上自己的身体。解决方案是：在更新方向时，判断新方向是否与当前方向直接相反，如果是，则忽略此次输入。

3. 核心模块实现详解

有了清晰的架构，我们就可以逐个实现模块了。这里我会给出关键代码并解释其背后的逻辑。

3.1 游戏初始化与地图绘制

初始化工作包括：生成初始的蛇（比如在屏幕中央水平放置3节），随机生成第一颗食物，将方向设为右，分数归零。

void Game::Initialize() { // 清空蛇身 snake.clear(); // 在屏幕中央初始化蛇，假设(HEIGHT/2, WIDTH/2)是中心 int startX = WIDTH / 2; int startY = HEIGHT / 2; snake.push_front({startY, startX}); // 蛇头 snake.push_front({startY, startX - 1}); // 第二节 snake.push_front({startY, startX - 2}); // 第三节 // 注意：这里push_front是为了让蛇头在deque的头部，方便后续操作。 // 初始蛇的视觉方向是向右，所以身体在头的左边。 dir = Direction::RIGHT; score = 0; isGameOver = false; GenerateFood(); }

绘制函数Render()是控制台编程的一个小难点。我们需要将光标移动到控制台的特定位置来输出字符。在Windows下，可以使用SetConsoleCursorPosition函数。为了获得更好的视觉效果，我们可以用不同的字符代表不同元素：比如'@'代表蛇头，'*'代表蛇身，'$'代表食物，'#'代表墙（如果有）。

void Game::Render() { // 清屏：一种跨平台性较好的方法是输出多个换行符，但更专业的是使用系统命令 system("cls"); // Windows命令。注意：频繁调用system有性能和安全风险，但对于小游戏可以接受。 // 更好的做法是使用API，这里为简洁使用system。 // 绘制上边框 for (int x = 0; x < WIDTH + 2; ++x) std::cout << '#'; std::cout << '\n'; for (int y = 0; y < HEIGHT; ++y) { std::cout << '#'; // 左边框 for (int x = 0; x < WIDTH; ++x) { bool isSnakePart = false; bool isHead = false; // 检查当前坐标(y,x)是否是蛇的一部分 int index = 0; for (const auto& part : snake) { if (part.first == y && part.second == x) { isSnakePart = true; isHead = (index == 0); // 第一个元素是蛇头 break; } index++; } if (isHead) { std::cout << '@'; } else if (isSnakePart) { std::cout << '*'; } else if (food.first == y && food.second == x) { std::cout << '$'; } else { std::cout << ' '; } } std::cout << "#\n"; // 右边框 } // 绘制下边框 for (int x = 0; x < WIDTH + 2; ++x) std::cout << '#'; std::cout << '\n'; // 显示分数和提示 std::cout << "Score: " << score << "\n"; std::cout << "Use WASD or Arrow Keys to move. Press 'Q' to quit.\n"; }

实操心得：上面这种逐行逐列检查的绘制方法在蛇身很长时效率会变低（O(n*m)复杂度）。一个优化策略是使用一个二维的“画布”数组（char canvas[HEIGHT][WIDTH]），先全部填充为空格，然后把蛇和食物的坐标标记上去，最后一次性输出整个数组。这样绘制逻辑的复杂度是O(n+m)，效率更高。但为了代码清晰易懂，初版用简单方法无妨。

3.2 蛇的移动与增长逻辑

这是游戏逻辑的核心。每一帧，我们根据当前方向dir计算蛇头的新位置newHead。

1. 计算新蛇头：根据方向对蛇头坐标进行加减。
2. 碰撞检测：
   • 撞墙：检查newHead是否超出地图边界（y<0 || y>=HEIGHT || x<0 || x>=WIDTH）。
   • 撞自身：遍历蛇身（可以从第二节点开始，因为新头不可能撞上当前的尾巴节点，除非蛇长度大于4且走回头路），检查newHead是否与任何蛇身节点坐标重合。
3. 食物检测：检查newHead是否与食物坐标重合。
4. 更新蛇身：
   • 如果吃到食物：将newHead插入蛇身队列的头部（snake.push_front(newHead)）。不要删除蛇尾，这样蛇就增长了一节。然后调用GenerateFood()生成新的食物，并增加分数。
   • 如果没吃到食物：将newHead插入头部，同时删除尾部的节点（snake.pop_back()）。这就是正常的移动。

void Game::Update() { if (dir == Direction::NONE) return; // 游戏刚开始时可能没有输入 // 1. 计算新蛇头位置 auto head = snake.front(); std::pair<int, int> newHead = head; switch (dir) { case Direction::UP: newHead.first--; break; case Direction::DOWN: newHead.first++; break; case Direction::LEFT: newHead.second--; break; case Direction::RIGHT: newHead.second++; break; } // 2. 碰撞检测：撞墙 if (newHead.first < 0 || newHead.first >= HEIGHT || newHead.second < 0 || newHead.second >= WIDTH) { isGameOver = true; return; } // 碰撞检测：撞自身（从第二个节点开始检查） for (auto it = snake.begin() + 1; it != snake.end(); ++it) { if (it->first == newHead.first && it->second == newHead.second) { isGameOver = true; return; } } // 3. 食物检测与蛇身更新 bool ateFood = (newHead.first == food.first && newHead.second == food.second); snake.push_front(newHead); // 新头加入 if (!ateFood) { snake.pop_back(); // 没吃到食物，移除旧尾巴 } else { // 吃到食物 score += 10; GenerateFood(); // 生成新食物 // 注意：这里需要检查新生成的食物是否和蛇身重叠，需要一个循环直到生成有效位置 } }

3.3 随机食物生成算法

生成食物的逻辑需要保证食物出现在一个空的格子上。一个简单的实现是循环随机生成坐标，直到该坐标不在蛇身上为止。但是，如果蛇很长，地图几乎被占满，这个循环可能会运行很久甚至死循环。因此，一个更健壮的做法是：先收集所有空闲格子的坐标，然后从中随机选取一个。

void Game::GenerateFood() { // 方法一：简单循环（在蛇不长时可用） // while (true) { // food.first = rand() % HEIGHT; // food.second = rand() % WIDTH; // bool onSnake = false; // for (const auto& segment : snake) { // if (segment.first == food.first && segment.second == food.second) { // onSnake = true; // break; // } // } // if (!onSnake) break; // } // 方法二：收集空闲格子（更可靠） std::vector<std::pair<int, int>> freeCells; for (int y = 0; y < HEIGHT; ++y) { for (int x = 0; x < WIDTH; ++x) { bool occupied = false; for (const auto& segment : snake) { if (segment.first == y && segment.second == x) { occupied = true; break; } } if (!occupied) { freeCells.push_back({y, x}); } } } if (freeCells.empty()) { // 没有空闲格子了，游戏胜利？或者直接结束 isGameOver = true; // 可以设计为胜利条件 return; } int randomIndex = rand() % freeCells.size(); food = freeCells[randomIndex]; }

注意事项：别忘了在使用随机数之前用srand(time(nullptr))初始化随机种子，否则每次运行游戏生成的食物位置序列都是一样的。

3.4 非阻塞键盘输入处理

如前所述，我们使用_kbhit()和_getch()。为了处理方向键（它们会产生两个字节的扫描码，第一个是0xE0或0），我们需要多读一个字节。

void Game::ProcessInput() { if (_kbhit()) { // 有按键按下 int key = _getch(); // 处理方向键（扩展键码） if (key == 0xE0 || key == 0) { key = _getch(); // 获取真正的方向键码 switch (key) { case 72: // 上箭头 if (dir != Direction::DOWN) dir = Direction::UP; break; case 80: // 下箭头 if (dir != Direction::UP) dir = Direction::DOWN; break; case 75: // 左箭头 if (dir != Direction::RIGHT) dir = Direction::LEFT; break; case 77: // 右箭头 if (dir != Direction::LEFT) dir = Direction::RIGHT; break; } } else { // 处理普通按键 switch (key) { case 'w': case 'W': if (dir != Direction::DOWN) dir = Direction::UP; break; case 's': case 'S': if (dir != Direction::UP) dir = Direction::DOWN; break; case 'a': case 'A': if (dir != Direction::RIGHT) dir = Direction::LEFT; break; case 'd': case 'D': if (dir != Direction::LEFT) dir = Direction::RIGHT; break; case 'q': case 'Q': isGameOver = true; break; } } } }

关键点：if (dir != OppositeDirection)这个判断至关重要，它防止了“反向自杀”的无效操作，是贪吃蛇游戏手感良好的基础。

4. 进阶优化与功能扩展

一个基础版本完成后，我们可以考虑添加更多功能，让游戏更完善、更有趣，同时也能练习更复杂的C++特性。

4.1 游戏难度与速度调节

最简单的难度调节就是改变每帧之间的延时。可以设计一个随着分数增加而减少延时的机制，让游戏越来越快。

// 在Game类中添加 int initialDelayMs = 200; int minDelayMs = 50; int speedUpThreshold = 50; // 每得50分加速一次 int Game::CalculateDelay() { int speedLevel = score / speedUpThreshold; int currentDelay = initialDelayMs - speedLevel * 20; // 每次加速减少20ms return std::max(currentDelay, minDelayMs); // 确保不低于最小延时 } // 然后在主循环中使用这个动态延时

更高级的难度设计可以包括：

• 障碍物：在地图上随机生成固定的墙，蛇需要绕行。
• 移动食物：食物每隔几秒会随机移动到相邻的空格。
• 多种食物：不同食物有不同分数和效果（如加速、减速、使蛇变短等）。

4.2 游戏状态持久化（存档/读档）

这是一个很好的练习文件I/O（<fstream>）的机会。我们可以将当前游戏的关键状态（蛇身坐标、食物坐标、方向、分数）保存到一个文本或二进制文件中。

void Game::SaveGame(const std::string& filename) { std::ofstream file(filename, std::ios::binary); if (!file) { /* 处理错误 */ } // 保存分数、方向等基本数据 file.write(reinterpret_cast<const char*>(&score), sizeof(score)); int dirInt = static_cast<int>(dir); file.write(reinterpret_cast<const char*>(&dirInt), sizeof(dirInt)); // 保存蛇身长度和坐标 size_t snakeSize = snake.size(); file.write(reinterpret_cast<const char*>(&snakeSize), sizeof(snakeSize)); for (const auto& segment : snake) { file.write(reinterpret_cast<const char*>(&segment.first), sizeof(segment.first)); file.write(reinterpret_cast<const char*>(&segment.second), sizeof(segment.second)); } // 保存食物坐标 file.write(reinterpret_cast<const char*>(&food.first), sizeof(food.first)); file.write(reinterpret_cast<const char*>(&food.second), sizeof(food.second)); } bool Game::LoadGame(const std::string& filename) { std::ifstream file(filename, std::ios::binary); if (!file) return false; // 按保存的顺序读取数据 file.read(reinterpret_cast<char*>(&score), sizeof(score)); int dirInt; file.read(reinterpret_cast<char*>(&dirInt), sizeof(dirInt)); dir = static_cast<Direction>(dirInt); size_t snakeSize; file.read(reinterpret_cast<char*>(&snakeSize), sizeof(snakeSize)); snake.clear(); for (size_t i = 0; i < snakeSize; ++i) { std::pair<int, int> segment; file.read(reinterpret_cast<char*>(&segment.first), sizeof(segment.first)); file.read(reinterpret_cast<char*>(&segment.second), sizeof(segment.second)); snake.push_back(segment); } file.read(reinterpret_cast<char*>(&food.first), sizeof(food.first)); file.read(reinterpret_cast<char*>(&food.second), sizeof(food.second)); isGameOver = false; return true; }

4.3 面向对象重构与设计模式初探

最初的代码可能把所有逻辑都塞在main函数或一个庞大的Game类里。随着功能增加，我们可以进行重构：

• 分离关注点：创建独立的Snake类、Food类、Renderer类（负责绘制）、InputHandler类（负责输入）。Game类主要作为协调者。
• 使用智能指针：如果动态创建对象，使用std::unique_ptr或std::shared_ptr来管理资源，避免内存泄漏。
• 应用简单设计模式：例如，可以用**状态模式（State Pattern）**来管理游戏的不同状态（开始菜单、游戏中、暂停、结束）。每个状态是一个独立的类，知道自己在当前状态下该如何响应输入、如何渲染。

// 状态模式示例 class GameState { public: virtual ~GameState() = default; virtual void HandleInput(Game* game) = 0; virtual void Update(Game* game) = 0; virtual void Render(Game* game) = 0; }; class PlayingState : public GameState { /* 实现游戏中的逻辑 */ }; class PausedState : public GameState { /* 实现暂停菜单逻辑 */ }; class Game { private: std::unique_ptr<GameState> currentState; public: void ChangeState(std::unique_ptr<GameState> newState) { currentState = std::move(newState); } void RunLoop() { while (!isGameOver) { currentState->HandleInput(this); currentState->Update(this); currentState->Render(this); // ... 延时 } } };

这样做虽然增加了初期的复杂度，但代码会变得非常清晰，易于维护和扩展。比如要加一个“开始菜单”，只需要新增一个MenuState类即可。

5. 常见问题与调试技巧实录

在实现过程中，你几乎一定会遇到下面这些问题。这里是我踩过坑后的经验总结。

5.1 屏幕闪烁问题

如果你在Render()函数里直接使用system("cls")清屏，然后重绘整个画面，在速度较快时会出现明显的闪烁。这是因为清屏和绘制不是原子操作，中间有短暂的黑屏时间。

解决方案：

1. 双缓冲（Double Buffering）：这是图形编程的常见技术。我们不在控制台上直接绘制，而是先在一个内存中的“缓冲区”（比如一个二维字符数组）里绘制完整的一帧，然后将整个缓冲区的内容一次性输出到控制台。这需要用到能移动光标到屏幕左上角的API（如SetConsoleCursorPosition到(0,0)），然后逐行输出缓冲区内容，避免全屏清空。
2. 使用更底层的控制台API：Windows提供了WriteConsoleOutput函数，可以直接将一块字符缓冲区写入控制台屏幕缓冲区的指定区域，效率最高，也最平滑。

// 双缓冲简化示例 std::vector<std::vector<char>> buffer(HEIGHT + 2, std::vector<char>(WIDTH + 2, ' ')); // 在buffer中绘制所有元素... // 然后一次性输出 void RenderBuffer(const std::vector<std::vector<char>>& buf) { HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = {0, 0}; SetConsoleCursorPosition(hConsole, coord); for (const auto& row : buf) { // 注意：需要将vector<char>转换为C风格字符串或逐个字符输出 std::cout.write(row.data(), row.size()); std::cout << '\n'; } }

5.2 输入响应延迟或不跟手

你可能发现按下键后，蛇要过一会儿才转向，或者连续快速按键会丢失输入。这通常是因为输入检测放在游戏循环的特定位置，而循环的每一帧耗时较长。

解决方案：

• 提高帧率：减少每帧的延时。但要注意，控制台渲染本身有性能瓶颈，帧率太高会导致CPU占用率飙升。
• 分离输入线程：将输入检测放到一个独立的线程中，实时更新一个“下一方向”的变量。主更新逻辑直接读取这个变量。这是更专业的做法，但会引入多线程同步的问题（需要用std::mutex保护共享变量）。
• 优化输入处理逻辑：确保ProcessInput()函数本身非常高效，并且在整个帧时间内有足够的机会被调用。避免在Update或Render中有耗时很长的操作。

5.3 随机食物生成在蛇很长时卡顿

如前所述，当蛇身体占据地图大部分时，简单的“循环随机尝试”算法效率极低。

解决方案：采用上面提到的“收集所有空闲格子”的方法。虽然每次生成食物都需要遍历整个地图（O(n*m)），但相比可能无限循环的随机尝试，这是确定性的、可接受的开销。如果地图很大，可以考虑更高级的空间划分数据结构来优化，但对于20x40的地图，直接遍历完全没问题。

5.4 跨平台兼容性问题

如果你在Windows上用<conio.h>和system("cls")，代码在Linux或macOS上无法编译。要实现跨平台，有两条路：

1. 使用跨平台库：如ncurses（Linux/macOS原生支持，Windows需要安装如PDCurses的移植版）。ncurses提供了完整的终端控制、输入输出和颜色管理功能，是编写跨平台控制台应用的事实标准。
2. 条件编译：在代码中使用预处理器指令#ifdef _WIN32、#ifdef __linux__等，为不同平台编写不同的实现。这比较繁琐，但可以让你深入了解不同系统的API。

// 条件编译示例：清屏函数 void ClearScreen() { #ifdef _WIN32 system("cls"); #else // Assume POSIX system (Linux, macOS) system("clear"); #endif }

5.5 游戏逻辑Bug排查清单

当游戏行为异常时，可以按以下顺序检查：

调试时，最朴素的std::cout输出关键变量（如蛇头坐标、方向、食物坐标）的值，依然是快速定位问题的有效手段。也可以考虑在Render函数中，临时将地图信息输出到文件，方便分析某一帧的完整状态。

6. 从控制台到图形界面的思考

完成控制台版本后，你可能会想：“能不能给它加上真正的图形界面？” 这自然是一个绝佳的进阶方向。这时，你需要引入图形库。对于C++，有几个流行的选择：

1. SFML (Simple and Fast Multimedia Library)：非常推荐初学者。它模块化设计（图形、窗口、音频、网络等），API清晰易懂，文档优秀。用SFML重写贪吃蛇，你只需要把原本用cout打印字符的地方，换成绘制矩形（sf::RectangleShape）或精灵（sf::Sprite），把_kbhit()换成SFML的事件循环（sf::Event）即可。概念是相通的，但视觉效果会有质的飞跃。
2. SDL (Simple DirectMedia Layer)：更底层，功能更强大，被许多商业游戏使用。它给了你更多的控制权，但上手难度比SFML稍高。
3. Raylib：一个非常现代、易学的游戏编程库，API设计极其友好，并且是纯C语言（但C++调用毫无问题）。它的理念是“让每个人都能学习游戏编程”，文档和例子都非常丰富。

迁移到图形界面，核心的游戏循环逻辑、状态管理、碰撞检测几乎可以完全复用。你需要学习的是新库的窗口管理、图形绘制和输入处理系统。这相当于给你的游戏项目“换了一层皮”，同时内部引擎得到了验证和巩固，是性价比极高的学习路径。

我个人在带新手朋友时，通常会建议他们先按本文的思路，彻底吃透控制台版本的所有细节。当你能流畅地玩自己写的贪吃蛇，并且能轻松地修改规则（比如让墙可以穿越、增加特殊食物）时，说明你对程序的核心逻辑已经掌握了。这时再打开SFML的教程，你会发现自己学得飞快，因为你的注意力可以完全集中在“如何用这个新工具表达我已经懂的逻辑”上，而不是同时被游戏逻辑和新工具两者困扰。