企业官网建设流程全解析

1. 项目概述：为什么选择用C++重写一款非洲棋？

如果你对桌面游戏、AI算法或者跨平台开发感兴趣，那么“Igisoro”这个名字可能已经引起了你的注意。Igisoro，也被称为“Mancala”或“播棋”，是流行于卢旺达、布隆迪等东非地区的一种古老策略棋类游戏。它规则简单，但策略深度惊人，常被称为“非洲的国际象棋”。几年前，我在研究传统游戏AI时接触到了它，立刻被其简洁棋盘下蕴含的复杂计算所吸引。市面上虽然有一些在线版本或简单的脚本实现，但大多功能单一，且缺乏一个集成了现代AI、拥有良好跨平台体验的开源项目。于是，我萌生了一个想法：用C++从头构建一个高质量的Igisoro游戏引擎，并集成一个可配置的AI对手，最终将其开源。

选择C++作为核心语言，是经过深思熟虑的。首先，C++在性能上的优势是无可比拟的，这对于需要大量状态空间搜索的棋类AI至关重要。一个高效的位棋盘表示和快速的走法生成器，能让我们在有限时间内探索更深的博弈树。其次，C++的跨平台能力非常成熟，通过CMake和现代C++标准库，我们可以相对轻松地让同一套代码运行在Windows、macOS、Linux甚至WebAssembly上。最后，C++庞大的开源生态（如用于图形界面的Qt/SDL，用于AI的TensorFlow C++ API或libtorch）为项目扩展提供了无限可能。这个项目不仅仅是一个游戏，更是一个展示如何将现代C++、游戏逻辑、AI算法和跨平台GUI技术融合在一起的实战案例。

2. 核心架构设计与技术选型

2.1 游戏逻辑层的抽象与建模

游戏的核心是规则。Igisoro的棋盘通常由两排各6个（共12个）棋洞（pit）和两端的计分洞（store）组成。每个玩家控制自己一侧的6个棋洞。我们的首要任务是将这些规则无歧义地转化为代码。

我采用了典型的“模型-视图-控制器”（MVC）架构进行解耦，但根据游戏特点做了调整。核心是GameState类，它纯粹负责游戏状态和规则。这个类不包含任何渲染或输入处理代码，只关注数据和行为。

class GameState { public: using Board = std::array<int, 14>; // 12个棋洞 + 2个计分洞 enum class Player { SOUTH, NORTH }; GameState(); // 初始化棋盘 bool makeMove(int pitIndex, Player player); // 执行走子，返回是否合法 Player getCurrentPlayer() const; bool isGameOver() const; Player getWinner() const; // 可能平局 const Board& getBoard() const; // 关键：生成当前玩家所有合法走法，用于AI搜索 std::vector<int> generateLegalMoves(Player player) const; private: Board board_; Player currentPlayer_; // ... 其他状态如连续捕获规则等 };

这里的关键设计点在于Board的数据结构。我最初尝试了std::vector，但为了极致性能，最终选择了std::array<int, 14>。固定大小的数组在内存中是连续的，访问速度极快，并且非常适合用于位操作或哈希计算，这对于后续实现置换表（Transposition Table）等AI优化技术至关重要。

makeMove函数是游戏规则的核心。它需要处理播撒（sowing）棋子、捕获（capturing）规则以及额外的回合（extra turn）规则。播撒的逆时针循环逻辑需要仔细处理数组索引的环绕。捕获规则是Igisoro的精髓：当播撒的最后一颗棋子落在己方空棋洞，且对面棋洞有棋子时，可以捕获这两洞的所有棋子。这部分逻辑必须严谨，我为此编写了详尽的单元测试（使用Google Test），确保边界情况（如棋盘边缘）也能正确处理。

注意：在实现捕获规则时，最容易出现的bug是错误地判断“对面”棋洞的索引。记住，棋盘是对称的，对面索引 = 12 - 当前索引（假设0-5是南侧棋洞，6-11是北侧棋洞）。务必在纸上画图验证你的索引计算逻辑。

2.2 跨平台GUI框架的选择：Qt vs. SDL2

游戏逻辑是大脑，我们需要为它创造一个交互界面。跨平台是核心需求之一，我主要评估了Qt和SDL2。

• Qt：功能极其强大，不仅仅是图形，还提供了完整的GUI控件、网络、数据库等功能。如果你想要一个带有菜单、对话框、设置界面的“桌面应用”式游戏，Qt是首选。它的信号与槽机制能很好地解耦UI和逻辑。但Qt框架本身比较庞大，可能会增加最终二进制文件的大小。
• SDL2：更专注于多媒体和游戏开发。它提供了简单的窗口管理、2D渲染、输入事件和音频接口，非常轻量级，给予开发者更多的控制权。如果你想要一个更像“游戏”的体验，或者计划未来移植到更小众的平台，SDL2更灵活。

考虑到Igisoro的UI相对简单（主要是一个棋盘和棋子绘制），且我希望保持核心的轻量化和对渲染流程的完全控制，我最终选择了SDL2。SDL2的跨平台支持一流，而且与OpenGL/Vulkan的集成也很方便，为未来可能的3D化或特效升级留有余地。

我的视图层（GameRenderer类）职责明确：持有SDL_Window*和SDL_Renderer*，根据GameState的当前状态，绘制棋盘背景、棋洞和棋子。棋子数量用不同大小的同心圆或数字表示，关键是要清晰可读。

2.3 AI模块的架构：从规则到智能

集成AI是本项目的亮点。一个简单的“随机走子”AI很容易实现，但我们的目标是构建一个具有挑战性的对手。我采用了经典的“博弈树搜索”框架，并计划支持多种算法。

AI模块被设计为一个抽象的AIStrategy接口和多个具体实现：

class AIStrategy { public: virtual ~AIStrategy() = default; // 根据给定的游戏状态，为指定玩家选择一步走法 virtual int chooseMove(const GameState& state, GameState::Player aiPlayer) = 0; }; class RandomAI : public AIStrategy { ... }; // 随机AI，用于测试和简单模式 class MinimaxAI : public AIStrategy { ... }; // 最小最大算法AI class MCTSAI : public AIStrategy { ... }; // 蒙特卡洛树搜索AI

最小最大算法（Minimax）与Alpha-Beta剪枝是棋类AI的入门标配。它的思想是模拟未来几步，假设对手总是做出对你最不利的走法（最小化你的收益），而你则选择对自己最有利的走法（最大化你的收益）。纯Minimax的搜索深度受限于指数级增长的状态空间。因此，Alpha-Beta剪枝是必须实现的优化，它能剪掉大量不必要的分支搜索，有时能将搜索效率提升一个数量级。

实现时，评估函数（Evaluation Function）的设计是关键。对于Igisoro，一个简单的评估函数可以是：己方计分洞棋子数 - 对方计分洞棋子数。更复杂的可以加上己方棋洞棋子总数、潜在捕获机会的权重等。我在MinimaxAI类中预留了评估函数的接口，方便后续调整策略。

int MinimaxAI::evaluate(const GameState& state, GameState::Player player) { int score = state.getScore(player) - state.getScore(getOpponent(player)); // 可以添加更多启发式评估，例如： // score += (countStonesOnPlayerSide(state, player) * 0.1); return score; }

蒙特卡洛树搜索（MCTS）是另一种强大的算法，特别适用于像Igisoro这样分支因子较大、难以设计完美评估函数的游戏。MCTS通过随机模拟（rollout）来评估走法的优劣，而不是依赖静态评估。我计划将其作为进阶AI选项。

为了让AI决策不“阻塞”主线程（导致界面卡顿），我将AI搜索放在一个单独的线程中。主线程（UI线程）向AI线程发送一个包含当前游戏状态的请求，AI线程计算完成后通过消息队列或回调函数返回结果。这涉及到线程间数据传递的安全性，需要小心处理。

3. 开发环境搭建与核心实现细节

3.1 现代C++开发环境配置

工欲善其事，必先利其器。我选择使用CMake作为构建系统，这是管理跨平台C++项目的行业标准。我的CMakeLists.txt文件清晰地定义了目标、依赖和编译选项。

cmake_minimum_required(VERSION 3.16) project(Igisoro LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 查找SDL2库 find_package(SDL2 REQUIRED) find_package(SDL2_image REQUIRED) # 用于加载图片，如果只用图形绘制则不需要 # 定义可执行文件 add_executable(Igisoro src/main.cpp src/GameState.cpp src/GameRenderer.cpp src/AIStrategy.cpp # ... 其他源文件 ) # 链接库 target_link_libraries(Igisoro PRIVATE SDL2::SDL2 SDL2_image::SDL2_image ) # 跨平台处理：在Windows上链接Windows子系统 if(WIN32) target_link_options(Igisoro PRIVATE -mwindows) endif()

对于IDE，Visual Studio Code配合CMake Tools和**C/C++**扩展是绝佳的组合。它提供了代码补全、调试、CMake构建配置等全套功能，且跨平台体验一致。当然，你也可以使用Visual Studio、CLion或简单的终端+编辑器。

实操心得：在CMakeLists.txt中，使用target_include_directories和target_link_libraries的现代CMake命令（指定PRIVATE、PUBLIC、INTERFACE）而非旧的全局命令（如include_directories），可以更好地管理依赖关系，避免库污染和难以排查的链接错误。这是现代C++项目的一个好习惯。

3.2 游戏状态与规则引擎的实现

让我们深入GameState::makeMove函数的一个关键部分——播撒逻辑。假设南侧玩家（SOUTH）从索引为pit的棋洞取子。

bool GameState::makeMove(int pitIndex, Player player) { if (!isValidMove(pitIndex, player)) return false; int stones = board_[pitIndex]; board_[pitIndex] = 0; int currentIndex = pitIndex; // 播撒阶段 while (stones > 0) { currentIndex = (currentIndex + 1) % TOTAL_PITS; // 跳到下一个洞 // 注意：通常规则中，不向对方的计分洞播撒（除非特定变体） if (shouldSkipStore(currentIndex, player)) { continue; } board_[currentIndex]++; stones--; } // 检查捕获规则：最后一颗棋子落在己方空棋洞，且对面有子 if (shouldCapture(currentIndex, player)) { int oppositeIndex = getOppositePit(currentIndex); int capturedStones = board_[currentIndex] + board_[oppositeIndex]; board_[currentIndex] = 0; board_[oppositeIndex] = 0; addToStore(capturedStones, player); } // 检查是否获得额外回合：最后一子落在己方计分洞 if (!isExtraTurn(currentIndex, player)) { switchPlayer(); } checkGameOver(); return true; }

这里有几个易错点：

1. 索引循环：(currentIndex + 1) % TOTAL_PITS确保了播撒在棋盘上循环。TOTAL_PITS是14（12棋洞+2计分洞）。
2. 跳过对方计分洞：shouldSkipStore函数需要根据具体Igisoro规则实现。有些变体允许向对方计分洞播撒，但标准规则通常不允许。
3. 捕获条件判断：shouldCapture需要判断currentIndex是否在己方棋洞区域（0-5或6-11），且该洞播撒前是空的（播撒后变为1），且对面洞非空。这个逻辑必须精确。
4. 游戏结束判断：checkGameOver通常检查一方所有棋洞是否为空。游戏结束时，另一方将所有剩余棋子放入自己的计分洞。

我为所有这些边界情况编写了单元测试，这是保证核心逻辑正确的生命线。

3.3 基于SDL2的图形界面绘制

SDL2的渲染流程是直接的。在GameRenderer的初始化函数中，我们创建窗口和渲染器。

bool GameRenderer::init(const char* title, int width, int height) { if (SDL_Init(SDL_INIT_VIDEO) < 0) { SDL_Log("SDL could not initialize! SDL_Error: %s\n", SDL_GetError()); return false; } window_ = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_SHOWN); if (!window_) { /* 错误处理 */ } renderer_ = SDL_CreateRenderer(window_, -1, SDL_RENDERER_ACCELERATED); if (!renderer_) { /* 错误处理 */ } SDL_SetRenderDrawColor(renderer_, 0xF0, 0xF0, 0xF0, 0xFF); // 浅灰色背景 return true; }

渲染一帧的过程在主循环中：

void GameRenderer::render(const GameState& state) { SDL_RenderClear(renderer_); // 用背景色清屏 // 1. 绘制棋盘背景（例如一个矩形） SDL_SetRenderDrawColor(renderer_, 0x8B, 0x45, 0x13, 0xFF); // 棕色 SDL_Rect boardRect = {x, y, boardWidth, boardHeight}; SDL_RenderFillRect(renderer_, &boardRect); // 2. 绘制12个棋洞（圆形） for (int i = 0; i < 12; ++i) { drawPit(i, state.getBoard()[i]); } // 3. 绘制2个计分洞（通常更大，在棋盘两端） drawStore(SOUTH_STORE_INDEX, state.getBoard()[SOUTH_STORE_INDEX]); drawStore(NORTH_STORE_INDEX, state.getBoard()[NORTH_STORE_INDEX]); // 4. 绘制当前玩家提示、获胜信息等文本（需要SDL_ttf库） drawUI(state); SDL_RenderPresent(renderer_); // 更新屏幕 }

drawPit函数会根据棋洞索引计算屏幕坐标，并根据棋子数量绘制不同大小的圆点或数字。为了美观，我使用了SDL2_gfx库（或自己实现）来画抗锯齿的圆。

输入处理在另一个循环中，通过SDL_PollEvent监听鼠标点击，将屏幕坐标转换为棋盘索引，然后调用GameState::makeMove。

踩坑记录：SDL的坐标系原点在窗口左上角，而我们的棋盘逻辑布局可能更习惯从左下角开始。在坐标转换时，要特别注意Y轴的翻转（screenY = windowHeight - logicY）。此外，SDL的鼠标点击事件（SDL_MOUSEBUTTONDOWN）在鼠标按住时会持续触发，通常我们只在按钮抬起（SDL_MOUSEBUTTONUP）时处理一次走子，以避免重复操作。

4. AI引擎的深度集成与优化

4.1 Minimax算法与Alpha-Beta剪枝的实现

这是AI部分的核心。MinimaxAI::chooseMove是入口，它启动一个递归搜索。

int MinimaxAI::chooseMove(const GameState& state, GameState::Player aiPlayer) { int bestMove = -1; int bestValue = std::numeric_limits<int>::min(); int alpha = std::numeric_limits<int>::min(); int beta = std::numeric_limits<int>::max(); auto legalMoves = state.generateLegalMoves(aiPlayer); for (int move : legalMoves) { GameState newState = state; // 拷贝状态（注意性能） newState.makeMove(move, aiPlayer); // 递归搜索，aiPlayer是最大玩家，对手是最小玩家 int value = minimax(newState, searchDepth_ - 1, false, alpha, beta, aiPlayer); if (value > bestValue) { bestValue = value; bestMove = move; } alpha = std::max(alpha, bestValue); if (beta <= alpha) { break; // Alpha-Beta 剪枝 } } return bestMove; // 注意处理没有合法走法的情况 } int MinimaxAI::minimax(GameState& state, int depth, bool isMaximizingPlayer, int alpha, int beta, GameState::Player maxPlayer) { if (depth == 0 || state.isGameOver()) { return evaluate(state, maxPlayer); } auto player = isMaximizingPlayer ? maxPlayer : getOpponent(maxPlayer); auto legalMoves = state.generateLegalMoves(player); if (isMaximizingPlayer) { int maxEval = std::numeric_limits<int>::min(); for (int move : legalMoves) { GameState childState = state; childState.makeMove(move, player); int eval = minimax(childState, depth - 1, false, alpha, beta, maxPlayer); maxEval = std::max(maxEval, eval); alpha = std::max(alpha, eval); if (beta <= alpha) break; // 剪枝 } return maxEval; } else { int minEval = std::numeric_limits<int>::max(); for (int move : legalMoves) { GameState childState = state; childState.makeMove(move, player); int eval = minimax(childState, depth - 1, true, alpha, beta, maxPlayer); minEval = std::min(minEval, eval); beta = std::min(beta, eval); if (beta <= alpha) break; // 剪枝 } return minEval; } }

关键优化点：

1. 状态拷贝开销：每次递归都拷贝整个GameState（特别是Board数组）开销很大。一种优化是使用“走子-撤销”（Make-Unmake）模式，即在原状态上直接应用走子，递归返回后再撤销。这要求GameState支持撤销操作，能显著提升性能。
2. 走法排序：Alpha-Beta剪枝的效率极度依赖于走法顺序。优先搜索看起来最好的走法（如能直接得分的走法），能触发更多剪枝。我实现了一个sortMoves函数，在递归前对legalMoves进行初步排序。
3. 置换表：这是更高级的优化。将搜索过的游戏状态及其评估值缓存起来（使用Zobrist哈希为状态生成唯一键），当再次遇到相同状态时直接返回缓存值，避免重复搜索。这需要处理哈希冲突和深度问题，但对性能提升巨大。

4.2 多线程AI与UI响应性保障

为了让AI思考时不冻结界面，我将AI搜索放入独立线程。我使用了C++11的std::thread和std::atomic标志。

class AIController { std::unique_ptr<AIStrategy> ai_; std::thread aiThread_; std::atomic<bool> aiThinking_{false}; std::function<void(int)> onMoveChosenCallback_; public: void requestMove(const GameState& state, GameState::Player aiPlayer) { if (aiThinking_) return; // 如果AI正在思考，忽略新请求 aiThinking_ = true; // 在后台线程中启动AI计算 aiThread_ = std::thread([this, state, aiPlayer]() { int chosenMove = ai_->chooseMove(state, aiPlayer); aiThinking_ = false; // 通过回调或消息队列将结果传回主线程 if (onMoveChosenCallback_) { // 注意：需要在主线程中安全地调用回调，例如使用SDL的事件队列 SDL_Event event; event.type = SDL_USEREVENT; event.user.code = AI_MOVE_EVENT; event.user.data1 = new int(chosenMove); // 动态分配，主线程需负责释放 SDL_PushEvent(&event); } }); aiThread_.detach(); // 或使用joinable管理 } };

在主线程的事件循环中，我们需要监听自定义的SDL_USEREVENT，从中提取AI计算出的走法，并安全地应用到游戏状态中。

重要警告：多线程编程必须小心数据竞争。GameState在传递给AI线程时必须是只读的，或者传递一个深拷贝。AI线程计算时，主线程的游戏状态可能已经改变（例如玩家手动走了一步），因此使用拷贝是更安全的选择。此外，任何对共享资源（如用于停止AI计算的标志）的访问都必须同步。

4.3 评估函数的调优与测试

评估函数是AI的“价值观”。一个差的评估函数会让强大的搜索算法做出愚蠢的决策。我最初只用了计分差，但AI显得过于短视。我通过自我对弈和与固定搜索深度的AI对弈来调优。

我引入了几个启发式特征：

1. 棋子数量优势：己方一侧棋洞的总棋子数。
2. 移动性优势：当前玩家的合法走法数量（走法多通常意味着主动权）。
3. 潜在捕获威胁：评估如果下一步落在某个空棋洞，可能引发捕获的棋子价值。

最终的评估函数是一个加权和：Eval = w1 * 计分差 + w2 * 己方棋子数 + w3 * 移动性差 + w4 * 威胁值

通过遗传算法或简单的网格搜索，我调整权重w1, w2, w3, w4，让AI在固定时间/深度下能战胜旧版本的AI。这个过程需要大量的自动化对局和结果分析。

5. 项目构建、测试与开源准备

5.1 跨平台编译与打包

CMake使得跨平台编译变得简单。在Linux/macOS上，通常使用命令行：

mkdir build && cd build cmake .. -DCMAKE_BUILD_TYPE=Release make -j4

在Windows上，可以使用Visual Studio的开发者命令行，或者使用CMake生成Visual Studio解决方案文件（cmake -G "Visual Studio 16 2019" ..）。

为了分发，我们需要考虑依赖库。SDL2是动态链接库（DLL或.so文件）。在Windows上，最简单的打包方式是将编译好的Igisoro.exe与必要的SDL2 DLL（SDL2.dll,SDL2_image.dll等）放在同一个文件夹下。可以使用windeployqt类似的工具（如果是Qt）或手动复制。在macOS上，可以创建.appbundle，将库嵌入其中。Linux下可以打包成AppImage或提供详细的依赖安装说明。

5.2 单元测试与集成测试策略

测试是保证项目质量，尤其是开源项目可信度的关键。我使用Google Test框架为核心逻辑编写单元测试。

TEST(GameStateTest, MakeMove_Capture) { GameState state; // 设置一个特定棋盘状态，使得一步走子后能触发捕获 state.setBoard({/* ... 特定的棋子分布 ... */}); EXPECT_TRUE(state.makeMove(2, GameState::Player::SOUTH)); // 验证捕获后计分洞的棋子数是否正确 EXPECT_EQ(state.getScore(GameState::Player::SOUTH), expectedScore); // 验证被捕获的棋洞是否清空 EXPECT_EQ(state.getBoard()[2], 0); EXPECT_EQ(state.getBoard()[oppositeIndex], 0); } TEST(AIMinimaxTest, ChoosesWinningMove) { GameState state; // 设置一个必胜局面 state.setBoard({/* ... */}); MinimaxAI ai(3); // 搜索深度3 int move = ai.chooseMove(state, GameState::Player::SOUTH); // 验证AI选择的走法确实是致胜的一步 EXPECT_EQ(move, expectedWinningMoveIndex); }

除了单元测试，我还编写了集成测试，模拟完整的人机对局，确保AI不会做出非法走子，游戏流程正常。自动化测试可以在每次代码提交（CI/CD，如GitHub Actions）时运行，确保新功能不会破坏旧逻辑。

5.3 开源工程化：文档、许可证与社区

准备将项目开源，不仅仅是把代码扔到GitHub上。良好的工程实践能吸引贡献者。

1. README.md：这是项目的门面。我撰写了详细的README，包括：项目简介、功能特性、截图/动图、构建指南（各平台）、运行说明、AI难度设置、如何贡献、许可证信息。
2. 代码注释与文档：使用Doxygen风格的注释，为所有公开的类和方法撰写文档。清晰的文档能极大降低他人理解代码的成本。
3. 贡献指南：创建CONTRIBUTING.md，说明代码风格（如使用clang-format）、提交流程（Pull Request）、测试要求等。
4. 问题模板与Pull Request模板：在GitHub仓库设置中启用，可以规范化提交的bug报告和功能请求。
5. 选择合适的许可证：我选择了MIT许可证。它非常宽松，允许任何人使用、修改、分发代码，包括用于商业项目，只需保留原许可证声明即可。这对于希望广泛传播和使用的开源项目很友好。
6. 持续集成：配置GitHub Actions，在每次推送时自动运行CMake构建、单元测试，并生成代码覆盖率报告。这能即时反馈代码的健康状况。

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

在开发过程中，我遇到了不少典型问题，这里记录下排查思路和解决方法。

6.1 图形渲染问题

• 问题：窗口闪烁，或者棋子绘制位置错乱。
• 排查：
  1. 检查SDL_RenderClear是否在每一帧开始时被调用。
  2. 验证屏幕坐标到棋盘索引的转换函数。添加调试绘制，比如在鼠标位置画一个红点，确认转换逻辑正确。
  3. 确保所有SDL_Rect或绘制坐标的计算都基于正确的基准点（通常是棋盘左上角）。
• 解决：使用SDL的SDL_RenderDrawPoint或SDL_RenderDrawLine在调试时可视化关键坐标和区域。

6.2 AI搜索速度慢或决策愚蠢

• 问题：搜索深度设为4时，AI思考时间过长，或者走的棋明显很差。
• 排查：
  1. 性能分析：使用性能分析工具（如perf、Valgrind的Callgrind、Visual Studio Profiler）找到热点函数。通常是GameState拷贝或generateLegalMoves被频繁调用。
  2. 检查剪枝：在minimax函数中添加计数器，统计被剪枝的分支数量。如果剪枝很少，说明走法排序没起作用。
  3. 评估函数：手动摆几个测试局面，打印出AI对每个合法走法的评估值，看是否符合人类直觉。
• 解决：
  1. 实现“走子-撤销”来避免状态拷贝。
  2. 优化generateLegalMoves，避免不必要的容器分配（例如使用静态数组或传递引用）。
  3. 改进走法排序，优先搜索能立即得分或造成捕获的走法。

6.3 多线程下的崩溃或数据竞争

• 问题：程序运行时随机崩溃，或AI走子后游戏状态异常。
• 排查：
  1. 使用线程检查工具，如Clang的ThreadSanitizer (-fsanitize=thread) 或Valgrind的Helgrind，来检测数据竞争。
  2. 检查所有跨线程共享的数据：GameState副本、AI停止标志、回调函数指针等。
• 解决：
  1. 绝对禁止在线程间共享非const的GameState。始终传递深拷贝。
  2. 对共享的标志变量使用std::atomic。
  3. 确保在主线程中处理SDL渲染和事件，SDL的大部分API不是线程安全的。

6.4 跨平台编译错误

• 问题：在Linux上编译正常，在Windows上链接失败，提示找不到SDL2函数。
• 排查：
  1. 检查CMake的find_package(SDL2)是否在所有平台都成功。
  2. 对比不同平台上的编译命令和链接库列表。
• 解决：
  1. 在Windows上，可能需要手动指定SDL2的路径，例如：cmake -DSDL2_DIR=/path/to/sdl2/cmake ..。
  2. 确保target_link_libraries正确包含了所有必需的库，如SDL2::SDL2和SDL2::SDL2main（在Windows上，SDL2需要链接这个库以提供main的入口）。
  3. 在CI配置中为每个平台（Windows/macOS/Linux）单独设置构建任务，及早发现平台相关问题。

开发这样一个项目，从零开始构建一个完整的、带有智能AI的跨平台游戏，是一次对C++工程能力、算法设计和软件架构的全面锻炼。每一个环节，从精确的规则实现，到高效的AI搜索，再到流畅的跨平台交互，都充满了挑战和学习的乐趣。当你最终看到程序运行，AI走出一步精妙的棋时，那种成就感是无可替代的。开源它，不仅是分享代码，更是分享这套解决问题的方法和思考过程。希望这个项目能成为其他开发者学习或二次开发的坚实基础。