Add files via upload

README.md

@@ -1,146 +1,146 @@
-# 🎲 五子棋人机对战AI
+# ? 五子棋人机对战AI
 
 ![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
 ![License](https://img.shields.io/badge/license-MIT-blue)
 ![Code Lines](https://img.shields.io/tokei/lines/github/your-username/your-repo)
 
-## 目录
+## 目录
-- [🎲 五子棋人机对战AI](#-五子棋人机对战ai)
+- [? 五子棋人机对战AI](#-五子棋人机对战ai)
-  - [目录](#目录)
+  - [目录](#目录)
-  - [项目简介](#项目简介)
+  - [项目简介](#项目简介)
-  - [✨ 功能特性](#-功能特性)
+  - [? 功能特性](#-功能特性)
-  - [🚀 快速开始](#-快速开始)
+  - [? 快速开始](#-快速开始)
-    - [编译程序](#编译程序)
+    - [编译程序](#编译程序)
-    - [运行游戏](#运行游戏)
+    - [运行游戏](#运行游戏)
-  - [🎯 游戏玩法](#-游戏玩法)
+  - [? 游戏玩法](#-游戏玩法)
-  - [💻 开发环境](#-开发环境)
+  - [? 开发环境](#-开发环境)
-  - [⚠️ 常见问题](#️-常见问题)
+  - [?? 常见问题](#?-常见问题)
-    - [权限问题](#权限问题)
+    - [权限问题](#权限问题)
-    - [中文显示问题](#中文显示问题)
+    - [中文显示问题](#中文显示问题)
-  - [🛠️ 技术实现](#️-技术实现)
+  - [?? 技术实现](#?-技术实现)
-    - [核心决策算法](#核心决策算法)
+    - [核心决策算法](#核心决策算法)
-    - [启发式评估函数](#启发式评估函数)
+    - [启发式评估函数](#启发式评估函数)
-  - [📂 代码结构](#-代码结构)
+  - [? 代码结构](#-代码结构)
-  - [📜 许可证](#-许可证)
+  - [? 许可证](#-许可证)
-  - [🙋 反馈与贡献](#-反馈与贡献)
+  - [? 反馈与贡献](#-反馈与贡献)
-  - [🚀 未来计划](#-未来计划)
+  - [? 未来计划](#-未来计划)
 
-## 项目简介
+## 项目简介
-基于C语言实现的五子棋人机对战系统，采用α-β剪枝优化的极小极大算法，支持自定义棋盘大小、游戏复盘和实时评分。
+基于C语言实现的五子棋人机对战系统，采用α-β剪枝优化的极小极大算法，支持自定义棋盘大小、游戏复盘和实时评分。
 
-## ✨ 功能特性
+## ? 功能特性
-- 🎮 人机对战模式
+- ? 人机对战模式
-- ⚙️ 可调棋盘尺寸(5x5到25x25)
+- ?? 可调棋盘尺寸(5x5到25x25)
-- 🧠 智能AI决策(1-5级难度)
+- ? 智能AI决策(1-5级难度)
-- 🔍 完整游戏复盘功能
+- ? 完整游戏复盘功能
-- 📊 实时对局评分系统
+- ? 实时对局评分系统
-- ↩️ 悔棋功能(可撤销上一步)
+- ?? 悔棋功能(可撤销上一步)
-- 🖥️ 清晰的终端界面显示
+- ?? 清晰的终端界面显示
-- ✔️ 健壮的输入验证(确保所有数字输入都在有效范围内)
+- ?? 健壮的输入验证(确保所有数字输入都在有效范围内)
-- ⏱️ 可选的回合计时器
+- ?? 可选的回合计时器
-- 💾 自动游戏记录保存
+- ? 自动游戏记录保存
 
-## 🚀 快速开始
+## ? 快速开始
 
-![游戏演示](https://your-gif-url.com/demo.gif)
+![游戏演示](https://your-gif-url.com/demo.gif)
 
-### 编译程序
+### 编译程序
 ```bash
-gcc 五子棋.c gobang.c game_mode.c -o output/五子棋.exe
+gcc 五子棋.c gobang.c game_mode.c -o output/五子棋.exe
 ```
 
-### 运行游戏
+### 运行游戏
 ```bash
-.\output\五子棋.exe
+.\output\五子棋.exe
 ```
 
-## 🎯 游戏玩法
+## ? 游戏玩法
-1. 启动后设置棋盘大小(默认15x15)
+1. 启动后设置棋盘大小(默认15x15)
-2. 选择AI难度级别(1-5)
+2. 选择AI难度级别(1-5)
-3. 输入坐标进行游戏(格式:行 列)
+3. 输入坐标进行游戏(格式:行 列)
-   - 输入R/r可悔棋
+   - 输入R/r可悔棋
-4. 游戏结束可查看完整复盘和评分
+4. 游戏结束可查看完整复盘和评分
 
-## 💻 开发环境
+## ? 开发环境
-- 操作系统: Windows (当前版本使用了Windows特有的 `_kbhit()` 和 `Sleep()` 函数，因此仅限Windows平台)
+- 操作系统: Windows (当前版本使用了Windows特有的 `_kbhit()` 和 `Sleep()` 函数，因此仅限Windows平台)
-- 编译器: GCC (MinGW(gcc为14.2.0) on Windows)
+- 编译器: GCC (MinGW(gcc为14.2.0) on Windows)
-- 终端: 支持UTF-8编码的终端
+- 终端: 支持UTF-8编码的终端
 
-> **跨平台兼容性说明:**
+> **跨平台兼容性说明:**
 > 
-> 为了未来能在Linux或macOS等其他操作系统上运行，需要将平台特定的代码（如 `_kbhit()`）替换为跨平台的实现，或使用条件编译（`#ifdef _WIN32`）进行隔离。
+> 为了未来能在Linux或macOS等其他操作系统上运行，需要将平台特定的代码（如 `_kbhit()`）替换为跨平台的实现，或使用条件编译（`#ifdef _WIN32`）进行隔离。
 
-## ⚠️ 常见问题
+## ?? 常见问题
 
-### 权限问题
+### 权限问题
-如果程序在保存游戏记录时提示“无法创建文件”或类似错误，通常是由于缺少写入权限。请尝试以下解决方案：
+如果程序在保存游戏记录时提示“无法创建文件”或类似错误，通常是由于缺少写入权限。请尝试以下解决方案：
 
-1.  **以管理员身份运行**：右键点击 `五子棋.exe` 或在管理员权限的终端中运行程序。
+1.  **以管理员身份运行**：右键点击 `五子棋.exe` 或在管理员权限的终端中运行程序。
-2.  **检查目录权限**：确保程序所在目录不是系统保护目录（如 `C:\Program Files`）。建议将项目放在用户目录下（如 `D:\Code`）。
+2.  **检查目录权限**：确保程序所在目录不是系统保护目录（如 `C:\Program Files`）。建议将项目放在用户目录下（如 `D:\Code`）。
-3.  **手动创建 `records` 目录**：如果 `records` 目录不存在，请在 `output` 目录下手动创建一个。
+3.  **手动创建 `records` 目录**：如果 `records` 目录不存在，请在 `output` 目录下手动创建一个。
 
-### 中文显示问题
+### 中文显示问题
-如果在Windows终端中遇到中文字符显示为乱码，是由于终端编码页不匹配导致的。请在运行程序前执行以下命令：
+如果在Windows终端中遇到中文字符显示为乱码，是由于终端编码页不匹配导致的。请在运行程序前执行以下命令：
 
 ```bash
 chcp 65001
 ```
 
-该命令会将当前终端的编码页切换到UTF-8，从而正确显示中文字符。为方便起见，你可以创建一个启动脚本（`.bat` 文件）来自动执行此操作：
+该命令会将当前终端的编码页切换到UTF-8，从而正确显示中文字符。为方便起见，你可以创建一个启动脚本（`.bat` 文件）来自动执行此操作：
 
 **start_game.bat**
 ```batch
 @echo off
 chcp 65001
-.\output\五子棋.exe
+.\output\五子棋.exe
 ```
 
-## 🛠️ 技术实现
+## ?? 技术实现
 
-项目的AI主要基于以下技术实现：
+项目的AI主要基于以下技术实现：
 
-### 核心决策算法
+### 核心决策算法
 
--   **极小极大算法 (Minimax)**：作为决策的基础，模拟对弈双方的每一步，选择对我方最有利的走法。
+-   **极小极大算法 (Minimax)**：作为决策的基础，模拟对弈双方的每一步，选择对我方最有利的走法。
--   **α-β 剪枝 (Alpha-Beta Pruning)**：对极小极大算法的關鍵優化，通过剪掉不可能影响最终决策的搜索分支，大幅提升AI的计算效率，使其能够在有限时间内达到更深的搜索深度。
+-   **α-β 剪枝 (Alpha-Beta Pruning)**：对极小极大算法的關鍵優化，通过剪掉不可能影响最终决策的搜索分支，大幅提升AI的计算效率，使其能够在有限时间内达到更深的搜索深度。
--   **搜索深度**：AI的思考深度，默认为3层，并可根据难度设置进行调整。搜索深度越深，AI的棋力越强，但计算耗时也越长。
+-   **搜索深度**：AI的思考深度，默认为3层，并可根据难度设置进行调整。搜索深度越深，AI的棋力越强，但计算耗时也越长。
 
-### 启发式评估函数
+### 启发式评估函数
 
-为了判断棋局的优劣，AI使用了一套复杂的启发式评估函数，主要包括：
+为了判断棋局的优劣，AI使用了一套复杂的启发式评估函数，主要包括：
 
--   **棋型识别 (Pattern Recognition)**：能够识别并评估多种关键棋型，如“活四”、“冲四”、“活三”、“眠三”等，并为每种棋型赋予不同权重。
+-   **棋型识别 (Pattern Recognition)**：能够识别并评估多种关键棋型，如“活四”、“冲四”、“活三”、“眠三”等，并为每种棋型赋予不同权重。
--   **位置权重 (Positional Value)**：棋盘上不同位置的战略价值不同，中心位置通常比边缘位置更有优势。评估函数会为中心区域的落子给予额外加分。
+-   **位置权重 (Positional Value)**：棋盘上不同位置的战略价值不同，中心位置通常比边缘位置更有优势。评估函数会为中心区域的落子给予额外加分。
--   **威胁检测 (Threat Detection)**：优先搜索能够直接形成制胜威胁的棋步，如“连五”或“活四”，从而快速响应对手的进攻或抓住制胜机会。
+-   **威胁检测 (Threat Detection)**：优先搜索能够直接形成制胜威胁的棋步，如“连五”或“活四”，从而快速响应对手的进攻或抓住制胜机会。
--   **双向延伸评估**：评估一个棋子在特定方向上是否有足够的空间形成连续棋型，避免在被封堵的位置浪费棋步。
+-   **双向延伸评估**：评估一个棋子在特定方向上是否有足够的空间形成连续棋型，避免在被封堵的位置浪费棋步。
 
-## 📂 代码结构
+## ? 代码结构
-- `五子棋.c` - 主程序入口，负责初始化和模式选择
+- `五子棋.c` - 主程序入口，负责初始化和模式选择
-- `gobang.c` - 核心游戏逻辑，包括棋盘操作、胜负判断、AI算法等
+- `gobang.c` - 核心游戏逻辑，包括棋盘操作、胜负判断、AI算法等
-- `gobang.h` - `gobang.c` 的头文件，定义核心数据结构和函数原型
+- `gobang.h` - `gobang.c` 的头文件，定义核心数据结构和函数原型
-- `game_mode.c` - 各种游戏模式的实现，如人机对战、双人对战和复盘模式
+- `game_mode.c` - 各种游戏模式的实现，如人机对战、双人对战和复盘模式
-- `game_mode.h` - `game_mode.c` 的头文件，定义游戏模式相关函数原型
+- `game_mode.h` - `game_mode.c` 的头文件，定义游戏模式相关函数原型
 
-## 📜 许可证
+## ? 许可证
 
-该项目采用 [MIT 许可证](https://opensource.org/licenses/MIT)进行授权。
+该项目采用 [MIT 许可证](https://opensource.org/licenses/MIT)进行授权。
 
-简单来说，你可以自由地使用、复制、修改、合并、出版、分发、再授权和/或销售本软件的副本，只需在你的项目中包含原始的版权和许可声明即可。
+简单来说，你可以自由地使用、复制、修改、合并、出版、分发、再授权和/或销售本软件的副本，只需在你的项目中包含原始的版权和许可声明即可。
 
-## 🙋 反馈与贡献
+## ? 反馈与贡献
 
-我们非常欢迎任何形式的反馈和贡献！如果你发现了Bug、有功能建议，或者希望改进代码，请随时通过以下方式参与：
+我们非常欢迎任何形式的反馈和贡献！如果你发现了Bug、有功能建议，或者希望改进代码，请随时通过以下方式参与：
 
--   **提交 Issue**：如果你遇到问题或有新的想法，请在 [GitHub Issues](https://github.com/LHY0125/Gobang-Game/issues) 页面提交详细描述。
+-   **提交 Issue**：如果你遇到问题或有新的想法，请在 [GitHub Issues](https://github.com/LHY0125/Gobang-Game/issues) 页面提交详细描述。
--   **发起 Pull Request**：如果你对代码进行了改进，欢迎提交 Pull Request。请确保你的代码风格与项目保持一致，并附上清晰的改动说明。
+-   **发起 Pull Request**：如果你对代码进行了改进，欢迎提交 Pull Request。请确保你的代码风格与项目保持一致，并附上清晰的改动说明。
 
-你的每一次贡献都将使这个项目变得更好！
+你的每一次贡献都将使这个项目变得更好！
 
-## 🚀 未来计划
+## ? 未来计划
 
-为了让这个项目变得更完善，我们计划在未来实现以下功能：
+为了让这个项目变得更完善，我们计划在未来实现以下功能：
 
--   [ ] **图形用户界面 (GUI)**：使用 `SDL2` 或 `Qt` 等库，将当前的终端界面升级为图形化界面，提升用户体验。
+-   [ ] **图形用户界面 (GUI)**：使用 `SDL2` 或 `Qt` 等库，将当前的终端界面升级为图形化界面，提升用户体验。
--   [ ] **网络对战功能**：增加一个在线对战模式，允许两名玩家通过网络进行对战。
+-   [ ] **网络对战功能**：增加一个在线对战模式，允许两名玩家通过网络进行对战。
--   [ ] **棋谱库集成**：引入开局库，使AI在游戏初期能够选择更优的开局走法。
+-   [ ] **棋谱库集成**：引入开局库，使AI在游戏初期能够选择更优的开局走法。
--   [ ] **代码重构与优化**：持续优化现有代码，提高模块化程度和运行效率，并实现完全的跨平台兼容性。
+-   [ ] **代码重构与优化**：持续优化现有代码，提高模块化程度和运行效率，并实现完全的跨平台兼容性。

ai.c

@@ -0,0 +1,325 @@
+#include "ai.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+extern int BOARD_SIZE;
+extern int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE];
+extern int step_count;
+extern const int direction[4][2];
+extern Step steps[MAX_STEPS];
+
+/**
+ * @brief 评估特定位置对当前玩家的战略价值。
+ *        此函数通过模拟在该位置落子，然后分析形成的棋型来为该位置打分。
+ *        分数越高，代表该位置对指定玩家越有利。
+ * @param x 要评估的行坐标 (0-based)。
+ * @param y 要评估的列坐标 (0-based)。
+ * @param player 玩家标识 (PLAYER 或 AI)，代表为哪一方进行评估。
+ * @return int 返回该位置的综合评估分数。
+ * @note 评分系统设计：
+ *  - 核心思想是为不同的棋型赋予不同的权重，棋型越接近胜利，权重越高。
+ *  - “活”棋型（两端无阻挡）比“眠”棋型（一端有阻挡）或“死”棋型（两端被阻挡）得分高得多，
+ *    因为它们有更大的发展潜力。
+ *  - 评分标准 (仅为示例，可调整以优化AI行为):
+ *    - 连五: 1,000,000 (胜利)
+ *    - 活四: 100,000 (下一步胜利)
+ *    - 冲四: 10,000 (下一步可能胜利)
+ *    - 活三: 5,000 (潜力巨大)
+ *    - 眠三: 1,000
+ *    - 活二: 500
+ *    - 眠二: 100
+ *    - 其他: 更低的分数
+ *  - 位置奖励：棋盘中心区域通常具有更高的战略价值，因此会给予额外加分，鼓励AI占据中心。
+ */
+int evaluate_pos(int x, int y, int player)
+{
+    // 保存原始值用于还原
+    int original = board[x][y];
+    // 模拟在该位置落子
+    board[x][y] = player;
+
+    int total_score = 0;      // 总分
+    int line_scores[4] = {0}; // 四个方向的得分
+
+    // 遍历四个方向进行评估
+    for (int i = 0; i < 4; i++)
+    {
+        int dx = direction[i][0], dy = direction[i][1];
+        // 获取当前方向上的棋型信息
+        DirInfo info = count_specific_direction(x, y, dx, dy, player);
+
+        // 直接形成五连珠为必胜
+        if (info.continuous_chess >= 5)
+        {
+            board[x][y] = original; // 还原棋盘
+            return 1000000;         // 返回最大分
+        }
+
+        // 根据连续棋子数评分
+        switch (info.continuous_chess)
+        {
+        case 4:                                     // 四连珠
+            if (info.check_start && info.check_end) // 活四(两端开放)
+                line_scores[i] = 100000;
+            else if (info.check_start || info.check_end) // 冲四(一端开放)
+                line_scores[i] = 10000;
+            else // 死四(两端封闭)
+                line_scores[i] = 500;
+            break;
+
+        case 3:                                     // 三连珠
+            if (info.check_start && info.check_end) // 活三
+                line_scores[i] = 5000;
+            else if (info.check_start || info.check_end) // 眠三
+                line_scores[i] = 1000;
+            else // 死三
+                line_scores[i] = 50;
+            break;
+
+        case 2:                                     // 二连珠
+            if (info.check_start && info.check_end) // 活二
+                line_scores[i] = 500;
+            else if (info.check_start || info.check_end) // 眠二
+                line_scores[i] = 100;
+            else // 死二
+                line_scores[i] = 10;
+            break;
+
+        case 1:                                     // 单子
+            if (info.check_start && info.check_end) // 开放位置
+                line_scores[i] = 50;
+            else if (info.check_start || info.check_end) // 半开放位置
+                line_scores[i] = 10;
+            else // 封闭位置
+                line_scores[i] = 1;
+            break;
+        }
+    }
+
+    // 计算总分（最高方向分+其他方向分加权）
+    int max_score = 0;
+    int sum_score = 0;
+    for (int i = 0; i < 4; i++)
+    {
+        if (line_scores[i] > max_score)
+            max_score = line_scores[i];
+        sum_score += line_scores[i];
+    }
+    total_score = max_score * 10 + sum_score; // 主方向权重更高
+
+    // 位置奖励：越靠近中心分数越高
+    int center_x = BOARD_SIZE / 2;
+    int center_y = BOARD_SIZE / 2;
+    int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离
+    int position_bonus = 50 * (BOARD_SIZE - distance);    // 距离中心越近奖励越高
+
+    board[x][y] = original;              // 还原棋盘状态
+    return total_score + position_bonus; // 返回总评估分
+}
+
+/**
+ * @brief 使用带α-β剪枝的深度优先搜索（Minimax算法）来寻找最佳落子点。
+ *        该函数递归地探索未来的几步棋，评估不同选择的优劣，并选择最优策略。
+ * @param x 上一步落子的行坐标。
+ * @param y 上一步落子的列坐标。
+ * @param player 当前轮到的玩家 (PLAYER 或 AI)。
+ * @param depth 剩余的搜索深度。深度越大，AI看得越远，但计算量也越大。
+ * @param alpha α值，极大化玩家（AI）当前能确保的最好结果（下界）。
+ * @param beta  β值，极小化玩家（对手）当前能确保的最好结果（上界）。
+ * @param is_maximizing 布尔值，true表示当前是极大化玩家（AI）的回合，false表示是极小化玩家（对手）的回合。
+ * @return int 返回在当前分支下的最佳评估分数。
+ * @note 算法核心思想:
+ *  1. **递归终止条件**: 当游戏出现胜负、平局，或达到预设的搜索深度时，停止递归，并返回当前局面的静态评估分数。
+ *  2. **极大化玩家 (AI)**: 尝试所有可能的落子，并选择能使其得分最大化的那一步。此过程中，会不断更新alpha值。
+ *  3. **极小化玩家 (对手)**: 模拟对手的走法，并假设对手会选择能使AI得分最小化的那一步。此过程中，会不断更新beta值。
+ *  4. **α-β剪枝**: 这是对Minimax算法的关键优化。
+ *     - **α剪枝**: 在极小化玩家的回合中，如果发现一个走法得到的分数比alpha还低，那么这个分支可以被剪掉，
+ *       因为极大化玩家绝不会选择进入这个分支（他有更好的选择）。(if beta <= alpha)
+ *     - **β剪枝**: 在极大化玩家的回ah合中，如果发现一个走法得到的分数比beta还高，那么这个分支也可以被剪掉，
+ *       因为极小化玩家绝不会让游戏进入这个分支（他有更好的选择来阻止）。(if beta <= alpha)
+ *     通过剪枝，可以避免对大量无效分支的搜索，极大地提高了AI的决策效率。
+ */
+int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing)
+{
+    // 检查当前落子是否获胜
+    if (check_win(x, y, player))
+    {
+        return (player == AI) ? 1000000 + depth : -1000000 - depth;
+    }
+
+    // 达到搜索深度或平局
+    if (depth == 0 || step_count >= BOARD_SIZE * BOARD_SIZE)
+    {
+        return evaluate_pos(x, y, AI) - evaluate_pos(x, y, PLAYER);
+    }
+
+    int best_score = is_maximizing ? -1000000 : 1000000;
+
+    // 遍历所有可能落子位置
+    for (int i = 0; i < BOARD_SIZE; i++)
+    {
+        for (int j = 0; j < BOARD_SIZE; j++)
+        {
+            if (board[i][j] != EMPTY)
+                continue;
+
+            // 模拟当前玩家落子
+            board[i][j] = player;
+            step_count++;
+
+            // 递归搜索(切换玩家和搜索深度)
+            int current_score = dfs(i, j, (player == AI) ? PLAYER : AI, depth - 1, alpha, beta, !is_maximizing);
+
+            // 撤销落子
+            board[i][j] = EMPTY;
+            step_count--;
+
+            // 极大值玩家(AI)逻辑
+            if (is_maximizing)
+            {
+                best_score = (current_score > best_score) ? current_score : best_score;
+                alpha = (best_score > alpha) ? best_score : alpha;
+                // α剪枝
+                if (beta <= alpha)
+                {
+                    break;
+                }
+            }
+            // 极小值玩家(人类)逻辑
+            else
+            {
+                best_score = (current_score < best_score) ? current_score : best_score;
+                beta = (best_score < beta) ? best_score : beta;
+                // β剪枝
+                if (beta <= alpha)
+                {
+                    break;
+                }
+            }
+        }
+        if ((is_maximizing && best_score >= beta) || (!is_maximizing && best_score <= alpha))
+        {
+            break; // 提前退出外层循环
+        }
+    }
+
+    return best_score;
+}
+
+/**
+ * @brief AI决策主函数，使用评估函数和搜索算法选择最佳落子位置
+ * @note 采用两阶段决策逻辑：
+ * 1. 防御阶段：检查并阻止玩家即将获胜的位置（活四、冲四、活三）
+ * 2. 进攻阶段：若无紧急防御需求，使用DFS评估选择最佳进攻位置
+ * @note 实现细节：
+ * - 优先处理玩家活四、冲四等危险局面
+ * - 步数>10时缩小搜索范围到已有棋子附近2格
+ * - 使用中心位置优先策略
+ */
+void ai_move(int depth)
+{
+    // 1. 首先检查是否需要阻止玩家的四子连棋或三子活棋
+    for (int i = 0; i < BOARD_SIZE; i++)
+    {
+        for (int j = 0; j < BOARD_SIZE; j++)
+        {
+            if (board[i][j] != EMPTY)
+                continue;
+
+            // 模拟玩家在此位置落子
+            board[i][j] = PLAYER;
+            bool need_block = false;
+
+            // 检查四个方向
+            for (int k = 0; k < 4; k++)
+            {
+                DirInfo info = count_specific_direction(i, j, direction[k][0], direction[k][1], PLAYER);
+
+                // 如果玩家能形成四子连棋且至少一端开放
+                if (info.continuous_chess >= 4 && (info.check_start || info.check_end))
+                {
+                    need_block = true;
+                    break;
+                }
+
+                // 如果玩家能形成三子活棋且两端开放
+                if (info.continuous_chess == 3 && info.check_start && info.check_end)
+                {
+                    need_block = true;
+                    break;
+                }
+            }
+
+            board[i][j] = EMPTY; // 恢复棋盘
+
+            if (need_block)
+            {
+                // 必须在此位置落子阻止
+                board[i][j] = AI;
+                steps[step_count++] = (Step){AI, i, j};
+                printf("AI落子(%d, %d)\n", i + 1, j + 1);
+                return;
+            }
+        }
+    }
+
+    // 2. 如果没有需要立即阻止的情况，则正常评估
+    int best_score = -1000000;
+    int best_x = -1, best_y = -1;
+
+    // 遍历棋盘所有空位
+    for (int i = 0; i < BOARD_SIZE; i++)
+    {
+        for (int j = 0; j < BOARD_SIZE; j++)
+        {
+            if (board[i][j] != EMPTY)
+                continue;
+
+            // 只考虑已有棋子附近(2格范围内)
+            bool has_nearby_stone = false;
+            for (int di = -2; di <= 2; di++)
+            {
+                for (int dj = -2; dj <= 2; dj++)
+                {
+                    int ni = i + di;
+                    int nj = j + dj;
+                    if (ni >= 0 && ni < BOARD_SIZE &&
+                        nj >= 0 && nj < BOARD_SIZE)
+                    {
+                        if (board[ni][nj] != EMPTY)
+                        {
+                            has_nearby_stone = true;
+                            break;
+                        }
+                    }
+                }
+                if (has_nearby_stone)
+                    break;
+            }
+            if (!has_nearby_stone && step_count > 10)
+                continue;
+
+            // 模拟AI落子
+            board[i][j] = AI;
+            int current_score = dfs(i, j, PLAYER, depth, -1000000, 1000000, false);
+            board[i][j] = EMPTY;
+
+            // 更新最佳位置
+            if (current_score > best_score)
+            {
+                best_score = current_score;
+                best_x = i;
+                best_y = j;
+            }
+        }
+    }
+
+    // 执行最佳落子
+    if (best_x != -1 && best_y != -1)
+    {
+        board[best_x][best_y] = AI;
+        steps[step_count++] = (Step){AI, best_x, best_y};
+        printf("AI落子(%d, %d)\n", best_x + 1, best_y + 1);
+    }
+}

ai.h

@@ -0,0 +1,34 @@
+#ifndef AI_H
+#define AI_H
+
+#include "gobang.h"
+
+/**
+ * @brief 评估特定位置对当前玩家的价值
+ * @param x 行坐标(0-base)
+ * @param y 列坐标(0-base)
+ * @param player 玩家标识(PLAYER/AI)
+ * @return int 位置评估分数(越高越好)
+ */
+int evaluate_pos(int x, int y, int player);
+
+/**
+ * @brief 带α-β剪枝的深度优先搜索(极小极大算法)
+ * @param x 当前行坐标
+ * @param y 当前列坐标
+ * @param player 当前玩家
+ * @param depth 搜索深度
+ * @param alpha α值(当前最大值)
+ * @param beta β值(当前最小值)
+ * @param is_maximizing 是否为极大化玩家
+ * @return int 最佳评估分数
+ */
+int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing);
+
+/**
+ * @brief AI落子决策函数
+ * 使用评估函数和搜索算法选择最佳落子位置
+ */
+void ai_move(int depth);
+
+#endif // AI_H

game_mode.c

@@ -1,4 +1,6 @@
+#include "game_mode.h"
 #include "gobang.h"
+#include "ai.h"
 #include <stdio.h>
 #include <time.h>
 #include <stdlib.h>
@@ -11,7 +13,7 @@
 
 /**
  * @brief 从用户获取整数输入
- * 
+ *
  * @param prompt 提示信息
  * @param min 最小值
  * @param max 最大值
@@ -47,48 +49,17 @@ int get_integer_input(const char *prompt, int min, int max)
 
 /**
  * @brief 处理玩家回合
- * 
+ *
- * @param current_player 
+ * @param current_player
- * @return true 
+ * @return true
- * @return false 
+ * @return false
  */
-bool handle_player_turn(int current_player)
+bool parse_player_input(int *x, int *y)
 {
-    int x, y;
     char input[10];
-    time_t start_time, end_time;
-    if (use_timer)
-    {
-        time(&start_time);
-    }
-
-    if (current_player == 1)
-    {
-        printf("\n玩家, 请输入落子坐标(行 列，1~%d)，或输入R/r悔棋:", BOARD_SIZE);
-    }
-    else
-    {
-        printf("\n玩家%d, 请输入落子坐标(行 列，1~%d)，或输入R/r悔棋:", current_player, BOARD_SIZE);
-    }
 
     while (1)
     {
-        if (use_timer)
-        {
-            time(&end_time);
-            if (difftime(end_time, start_time) > time_limit)
-            {
-                if (current_player == 1)
-                {
-                    printf("\n玩家超时, 对方获胜！\n");
-                }
-                else
-                {
-                    printf("\n玩家%d超时, 对方获胜！\n", current_player);
-                }
-                return false; // 超时，返回false表示回合失败
-            }
-        }
         if (_kbhit())
         {
             scanf("%s", input);
@@ -97,36 +68,103 @@ bool handle_player_turn(int current_player)
         Sleep(100); // a small delay to prevent high CPU usage
     }
 
-    if (input[0] == 'r' || input[0] == 'R')
+    if (sscanf(input, "%d", x) == 1)
     {
-        int steps_to_undo;
+        // Successfully parsed the first number, now parse the second
-        printf("请输入要悔棋的步数(AI会同样悔棋): ");
+        if (scanf("%d", y) != 1)
-        steps_to_undo = get_integer_input("", 1, step_count / 2);
-        int effective_steps = (current_player == PLAYER) ? steps_to_undo * 2 : steps_to_undo;
-        if (return_move(effective_steps))
         {
-            printf("成功悔棋 %d 步！\n", steps_to_undo);
+            // Check for special commands if second number is not available
-            print_board();
+            if (*x == INPUT_UNDO)
+            {
+                int steps_to_undo;
+                printf("请输入要悔棋的步数(双方各退一步): ");
+                steps_to_undo = get_integer_input("", 1, step_count / 2);
+                if (return_move(steps_to_undo * 2))
+                {
+                    printf("成功悔棋，双方各退 %d 步！\n", steps_to_undo);
+                    print_board();
+                }
+                else
+                {
+                    printf("无法悔棋！\n");
+                }
+                return false; // Special command
+            }
+            else if (*x == INPUT_SAVE)
+            {
+                // ... handle save ...
+                return false; // Special command
+            }
+            else if (*x == INPUT_EXIT)
+            {
+                // ... handle exit ...
+                return false; // Special command
+            }
+            printf("无效输入，请输入两个数字坐标。");
+            while (getchar() != '\n')
+                ;
+            return false; // Invalid input
+        }
+    }
+    else
+    {
+        // sscanf failed, check for 'r' or 'R'
+        if (input[0] == 'r' || input[0] == 'R')
+        {
+            int steps_to_undo;
+            printf("请输入要悔棋的步数(双方各退一步): ");
+            steps_to_undo = get_integer_input("", 1, step_count / 2);
+            if (return_move(steps_to_undo * 2))
+            {
+                printf("成功悔棋，双方各退 %d 步！\n", steps_to_undo);
+                print_board();
+            }
+            else
+            {
+                printf("无法悔棋！\n");
+            }
+            return false; // Special command
+        }
+        printf("无效输入，请输入数字坐标或'r'悔棋。");
+        return false; // Invalid input
+    }
+    return true; // Valid coordinates
+}
+
+bool handle_player_turn(int current_player)
+{
+    int x, y;
+    time_t start_time, end_time;
+    if (use_timer)
+    {
+        time(&start_time);
+    }
+
+    printf("\n玩家%d, 请输入落子坐标(行 列，1~%d)，或输入R/r悔棋:", current_player, BOARD_SIZE);
+
+    while (1)
+    {
+        if (use_timer)
+        {
+            time(&end_time);
+            if (difftime(end_time, start_time) > time_limit)
+            {
+                printf("\n玩家%d超时, 对方获胜！\n", current_player);
+                return false; // Timeout
+            }
+        }
+
+        if (parse_player_input(&x, &y))
+        {
+            break; // Valid input received
         }
         else
         {
-            printf("无法悔棋！\n");
+            // Special command or invalid input handled, just continue the loop
+            return true;
         }
-        return true; // 悔棋操作后，回合算作成功，但不进行落子
     }
 
-    if (sscanf(input, "%d", &x) != 1)
-    {
-        printf("无效输入，请输入数字坐标。");
-        return true; // 输入无效，但回合继续
-    }
-    if (scanf("%d", &y) != 1)
-    {
-        printf("无效输入，请输入数字坐标。");
-        while (getchar() != '\n')
-            ;
-        return true; // 输入无效，但回合继续
-    }
     x--;
     y--;
 
@@ -139,14 +177,7 @@ bool handle_player_turn(int current_player)
 
     if (check_win(x, y, current_player))
     {
-        if (current_player == 1)
+        printf("\n玩家%d获胜！\n", current_player);
-        {
-            printf("\n玩家获胜！\n");
-        }
-        else
-        {
-            printf("\n玩家%d获胜！\n", current_player);
-        }
         return false; // 游戏结束
     }
 
@@ -242,7 +273,7 @@ void run_pvp_game()
     // 双人对战模式
     setup_board_size();
     empty_board();
-    int current_player = determine_first_player(PLAYER3, PLAYER4);
+    int current_player = determine_first_player(PLAYER1, PLAYER2);
     print_board();
 
     while (1)
@@ -261,7 +292,7 @@ void run_pvp_game()
 
         if (step_count > old_step_count)
         {
-            current_player = (current_player == PLAYER3) ? PLAYER4 : PLAYER3;
+            current_player = (current_player == PLAYER1) ? PLAYER2 : PLAYER1;
         }
     }
     printf("===== 游戏结束 =====\n");
@@ -307,7 +338,7 @@ void run_review_mode()
         {
             printf("%d. %s\n", i + 1, record_files[i]);
         }
-        
+
         char prompt[150];
         sprintf(prompt, "请输入复盘文件编号(1-%d)，或输入0以手动输入文件名: ", file_count);
         int choice = get_integer_input(prompt, 0, file_count);
@@ -321,7 +352,8 @@ void run_review_mode()
             printf("请输入完整文件名: ");
             scanf("%s", filename);
             int c;
-            while ((c = getchar()) != '\n' && c != EOF);
+            while ((c = getchar()) != '\n' && c != EOF)
+                ;
 
             int possible_choice = atoi(filename);
             if (possible_choice > 0 && possible_choice <= file_count)
@@ -335,7 +367,8 @@ void run_review_mode()
         printf("未找到任何复盘文件，请输入复盘文件地址: ");
         scanf("%s", filename);
         int c;
-        while ((c = getchar()) != '\n' && c != EOF);
+        while ((c = getchar()) != '\n' && c != EOF)
+            ;
     }
 
     int game_mode = load_game_from_file(filename);

game_mode.h

@@ -3,7 +3,7 @@
  * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
  * @brief 五子棋游戏框架头文件
  * @version 3.0
- * @date 2025-06-26
+ * @date 2025-06-30
  *
  * @copyright Copyright (c) 2025
  *
@@ -18,9 +18,14 @@
 
 #include "gobang.h"
 
+// 特殊输入命令
+#define INPUT_UNDO -1
+#define INPUT_SAVE -2
+#define INPUT_EXIT -3
+
 /**
  * @brief 从用户获取整数输入
- * 
+ *
  * @param prompt 提示信息
  * @param min 最小值
  * @param max 最大值
@@ -30,10 +35,18 @@ int get_integer_input(const char *prompt, int min, int max);
 
 /**
  * @brief 处理玩家回合
- * 
+ *
- * @param current_player 
+ * @param x 玩家输入的横坐标
- * @return true 
+ * @param y 玩家输入的纵坐标
- * @return false 
+ * @return true 输入有效
+ * @return false 输入无效
+ */
+bool parse_player_input(int *x, int *y);
+
+/**
+ * @brief 处理AI回合
+ *
+ * @param current_player 当前玩家
  */
 bool handle_player_turn(int current_player);
 

gobang.c

@@ -1,14 +1,16 @@
 #include "gobang.h"
 #include "game_mode.h"
+#include "ai.h"
 #include <stdio.h>
 #include <sys/stat.h>
 #include <time.h>
 
 // 全局变量定义
-int BOARD_SIZE = 15;                                           // 实际使用的棋盘尺寸(默认15)
+int BOARD_SIZE = 15;                             // 实际使用的棋盘尺寸(默认15)
-int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE] = {0};               // 棋盘状态存储数组(默认棋盘全空为0)
+int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE] = {0}; // 棋盘状态存储数组(默认棋盘全空为0)
-const int direction[4][2] = {{1, 0}, {0, 1}, {1, 1}, {1, -1}}; // 四个方向：向下、向右、右下、左下
+
 Step steps[MAX_STEPS];                                         // 存储所有落子步骤的数组
+const int direction[4][2] = {{1, 0}, {0, 1}, {1, 1}, {1, -1}}; // 四个方向：向下、向右、右下、左下
 int step_count = 0;                                            // 当前步数计数器
 bool use_forbidden_moves = false;                              // 默认不启用禁手规则
 int use_timer = 0;                                             // 默认不启用计时器
@@ -144,7 +146,7 @@ bool is_forbidden_move(int x, int y, int player)
     {
         return false;
     }
-    if (player != PLAYER && player != PLAYER3)
+    if (player != PLAYER && player != PLAYER1)
     {
         return false;
     }
@@ -269,306 +271,6 @@ bool check_win(int x, int y, int player)
     return false; // 四个方向都没有五连珠
 }
 
-/**
- * @brief 评估特定位置对当前玩家的战略价值
- * @param x 行坐标(0-base)
- * @param y 列坐标(0-base)
- * @param player 玩家标识(PLAYER/AI)
- * @return int 综合评估分数(越高表示位置越好)
- * @note 评分标准:
- * - 活四:100000 冲四:10000 死四:500
- * - 活三:5000 眠三:1000 死三:50
- * - 活二:500 眠二:100 死二:10
- * - 单子:50(开放)/10(半开放)/1(封闭)
- * - 中心位置有额外加成
- */
-int evaluate_pos(int x, int y, int player)
-{
-    // 保存原始值用于还原
-    int original = board[x][y];
-    // 模拟在该位置落子
-    board[x][y] = player;
-
-    int total_score = 0;      // 总分
-    int line_scores[4] = {0}; // 四个方向的得分
-
-    // 遍历四个方向进行评估
-    for (int i = 0; i < 4; i++)
-    {
-        int dx = direction[i][0], dy = direction[i][1];
-        // 获取当前方向上的棋型信息
-        DirInfo info = count_specific_direction(x, y, dx, dy, player);
-
-        // 直接形成五连珠为必胜
-        if (info.continuous_chess >= 5)
-        {
-            board[x][y] = original; // 还原棋盘
-            return 1000000;         // 返回最大分
-        }
-
-        // 根据连续棋子数评分
-        switch (info.continuous_chess)
-        {
-        case 4:                                     // 四连珠
-            if (info.check_start && info.check_end) // 活四(两端开放)
-                line_scores[i] = 100000;
-            else if (info.check_start || info.check_end) // 冲四(一端开放)
-                line_scores[i] = 10000;
-            else // 死四(两端封闭)
-                line_scores[i] = 500;
-            break;
-
-        case 3:                                     // 三连珠
-            if (info.check_start && info.check_end) // 活三
-                line_scores[i] = 5000;
-            else if (info.check_start || info.check_end) // 眠三
-                line_scores[i] = 1000;
-            else // 死三
-                line_scores[i] = 50;
-            break;
-
-        case 2:                                     // 二连珠
-            if (info.check_start && info.check_end) // 活二
-                line_scores[i] = 500;
-            else if (info.check_start || info.check_end) // 眠二
-                line_scores[i] = 100;
-            else // 死二
-                line_scores[i] = 10;
-            break;
-
-        case 1:                                     // 单子
-            if (info.check_start && info.check_end) // 开放位置
-                line_scores[i] = 50;
-            else if (info.check_start || info.check_end) // 半开放位置
-                line_scores[i] = 10;
-            else // 封闭位置
-                line_scores[i] = 1;
-            break;
-        }
-    }
-
-    // 计算总分（最高方向分+其他方向分加权）
-    int max_score = 0;
-    int sum_score = 0;
-    for (int i = 0; i < 4; i++)
-    {
-        if (line_scores[i] > max_score)
-            max_score = line_scores[i];
-        sum_score += line_scores[i];
-    }
-    total_score = max_score * 10 + sum_score; // 主方向权重更高
-
-    // 位置奖励：越靠近中心分数越高
-    int center_x = BOARD_SIZE / 2;
-    int center_y = BOARD_SIZE / 2;
-    int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离
-    int position_bonus = 50 * (BOARD_SIZE - distance);    // 距离中心越近奖励越高
-
-    board[x][y] = original;              // 还原棋盘状态
-    return total_score + position_bonus; // 返回总评估分
-}
-
-/**
- * @brief 带α-β剪枝的深度优先搜索(极小极大算法实现)
- * @param x 当前行坐标
- * @param y 当前列坐标
- * @param player 当前玩家
- * @param depth 剩余搜索深度
- * @param alpha α值(当前最大值)
- * @param beta β值(当前最小值)
- * @param is_maximizing 是否为极大化玩家(AI)
- * @return int 最佳评估分数
- * @note 算法流程:
- * 1. 检查是否获胜或达到搜索深度
- * 2. 遍历所有可能落子位置
- * 3. 递归评估每个位置的分数
- * 4. 根据is_maximizing选择最大/最小值
- * 5. 使用α-β剪枝优化搜索过程
- */
-int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing)
-{
-    // 检查当前落子是否获胜
-    if (check_win(x, y, player))
-    {
-        return (player == AI) ? 1000000 + depth : -1000000 - depth;
-    }
-
-    // 达到搜索深度或平局
-    if (depth == 0 || step_count >= BOARD_SIZE * BOARD_SIZE)
-    {
-        return evaluate_pos(x, y, AI) - evaluate_pos(x, y, PLAYER);
-    }
-
-    int best_score = is_maximizing ? -1000000 : 1000000;
-
-    // 遍历所有可能落子位置
-    for (int i = 0; i < BOARD_SIZE; i++)
-    {
-        for (int j = 0; j < BOARD_SIZE; j++)
-        {
-            if (board[i][j] != EMPTY)
-                continue;
-
-            // 模拟当前玩家落子
-            board[i][j] = player;
-            step_count++;
-
-            // 递归搜索(切换玩家和搜索深度)
-            int current_score = dfs(i, j, (player == AI) ? PLAYER : AI, depth - 1, alpha, beta, !is_maximizing);
-
-            // 撤销落子
-            board[i][j] = EMPTY;
-            step_count--;
-
-            // 极大值玩家(AI)逻辑
-            if (is_maximizing)
-            {
-                best_score = (current_score > best_score) ? current_score : best_score;
-                alpha = (best_score > alpha) ? best_score : alpha;
-                // α剪枝
-                if (beta <= alpha)
-                {
-                    break;
-                }
-            }
-            // 极小值玩家(人类)逻辑
-            else
-            {
-                best_score = (current_score < best_score) ? current_score : best_score;
-                beta = (best_score < beta) ? best_score : beta;
-                // β剪枝
-                if (beta <= alpha)
-                {
-                    break;
-                }
-            }
-        }
-        if ((is_maximizing && best_score >= beta) || (!is_maximizing && best_score <= alpha))
-        {
-            break; // 提前退出外层循环
-        }
-    }
-
-    return best_score;
-}
-
-/**
- * @brief AI决策主函数，使用评估函数和搜索算法选择最佳落子位置
- * @note 采用两阶段决策逻辑：
- * 1. 防御阶段：检查并阻止玩家即将获胜的位置（活四、冲四、活三）
- * 2. 进攻阶段：若无紧急防御需求，使用DFS评估选择最佳进攻位置
- * @note 实现细节：
- * - 优先处理玩家活四、冲四等危险局面
- * - 步数>10时缩小搜索范围到已有棋子附近2格
- * - 使用中心位置优先策略
- */
-void ai_move(int depth)
-{
-    // 1. 首先检查是否需要阻止玩家的四子连棋或三子活棋
-    for (int i = 0; i < BOARD_SIZE; i++)
-    {
-        for (int j = 0; j < BOARD_SIZE; j++)
-        {
-            if (board[i][j] != EMPTY)
-                continue;
-
-            // 模拟玩家在此位置落子
-            board[i][j] = PLAYER;
-            bool need_block = false;
-
-            // 检查四个方向
-            for (int k = 0; k < 4; k++)
-            {
-                DirInfo info = count_specific_direction(i, j, direction[k][0], direction[k][1], PLAYER);
-
-                // 如果玩家能形成四子连棋且至少一端开放
-                if (info.continuous_chess >= 4 && (info.check_start || info.check_end))
-                {
-                    need_block = true;
-                    break;
-                }
-
-                // 如果玩家能形成三子活棋且两端开放
-                if (info.continuous_chess == 3 && info.check_start && info.check_end)
-                {
-                    need_block = true;
-                    break;
-                }
-            }
-
-            board[i][j] = EMPTY; // 恢复棋盘
-
-            if (need_block)
-            {
-                // 必须在此位置落子阻止
-                board[i][j] = AI;
-                steps[step_count++] = (Step){AI, i, j};
-                printf("AI落子(%d, %d)\n", i + 1, j + 1);
-                return;
-            }
-        }
-    }
-
-    // 2. 如果没有需要立即阻止的情况，则正常评估
-    int best_score = -1000000;
-    int best_x = -1, best_y = -1;
-
-    // 遍历棋盘所有空位
-    for (int i = 0; i < BOARD_SIZE; i++)
-    {
-        for (int j = 0; j < BOARD_SIZE; j++)
-        {
-            if (board[i][j] != EMPTY)
-                continue;
-
-            // 只考虑已有棋子附近(2格范围内)
-            bool has_nearby_stone = false;
-            for (int di = -2; di <= 2; di++)
-            {
-                for (int dj = -2; dj <= 2; dj++)
-                {
-                    int ni = i + di;
-                    int nj = j + dj;
-                    if (ni >= 0 && ni < BOARD_SIZE &&
-                        nj >= 0 && nj < BOARD_SIZE)
-                    {
-                        if (board[ni][nj] != EMPTY)
-                        {
-                            has_nearby_stone = true;
-                            break;
-                        }
-                    }
-                }
-                if (has_nearby_stone)
-                    break;
-            }
-            if (!has_nearby_stone && step_count > 10)
-                continue;
-
-            // 模拟AI落子
-            board[i][j] = AI;
-            int current_score = dfs(i, j, PLAYER, depth, -1000000, 1000000, false);
-            board[i][j] = EMPTY;
-
-            // 更新最佳位置
-            if (current_score > best_score)
-            {
-                best_score = current_score;
-                best_x = i;
-                best_y = j;
-            }
-        }
-    }
-
-    // 执行最佳落子
-    if (best_x != -1 && best_y != -1)
-    {
-        board[best_x][best_y] = AI;
-        steps[step_count++] = (Step){AI, best_x, best_y};
-        printf("AI落子(%d, %d)\n", best_x + 1, best_y + 1);
-    }
-}
-
 /**
  * @brief 复盘游戏全过程并展示评分
  * @note 实现流程:
@@ -611,7 +313,7 @@ void review_process(int game_mode)
         // 打印当前步骤信息
         // 根据游戏模式显示不同的标题和玩家信息
         if (game_mode == 1)
-        { 
+        {
             // 人机对战
             printf("\n===== 五子棋人机对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE);
             printf("\n    第%d步/%d步: %s 落子于(%d, %d)\n",
@@ -620,12 +322,12 @@ void review_process(int game_mode)
                    s.x + 1, s.y + 1);
         }
         else
-        { 
+        {
             // 双人对战
             printf("\n===== 五子棋双人对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE);
             printf("\n    第%d步/%d步: %s 落子于(%d, %d)\n",
                    i + 1, step_count,
-                   (s.player == PLAYER3) ? "玩家1(黑棋)" : "玩家2(白棋)",
+                   (s.player == PLAYER1) ? "玩家1(黑棋)" : "玩家2(白棋)",
                    s.x + 1, s.y + 1);
         }
 
@@ -640,9 +342,9 @@ void review_process(int game_mode)
             printf("%2d ", row + 1); // 行号
             for (int col = 0; col < BOARD_SIZE; col++)
             {
-                if (temp_board[row][col] == PLAYER || temp_board[row][col] == PLAYER3)
+                if (temp_board[row][col] == PLAYER || temp_board[row][col] == PLAYER1)
                     printf("x ");
-                else if (temp_board[row][col] == AI || temp_board[row][col] == PLAYER4)
+                else if (temp_board[row][col] == AI || temp_board[row][col] == PLAYER2)
                     printf("○ ");
                 else
                     printf("· ");
@@ -668,10 +370,10 @@ void review_process(int game_mode)
     // 遍历所有步数，累积每一步的得分
     for (int i = 0; i < step_count; i++)
     {
-        if (steps[i].player == PLAYER || steps[i].player == PLAYER3)
+        if (steps[i].player == PLAYER || steps[i].player == PLAYER1)
         {
             player1_score += calculate_step_score(steps[i].x, steps[i].y, steps[i].player);
-        } 
+        }
         else
         {
             player2_score += calculate_step_score(steps[i].x, steps[i].y, steps[i].player);
@@ -688,7 +390,7 @@ void review_process(int game_mode)
                    player1_score, (double)player1_score * 100.0 / sum_score);
             printf("AI得分: %d, 占比: %.2f%%\n",
                    player2_score, (double)player2_score * 100.0 / sum_score);
-        } 
+        }
         else
         {
             printf("玩家1(黑棋)得分: %d, 占比: %.2f%%\n",
@@ -703,7 +405,7 @@ void review_process(int game_mode)
         {
             printf("玩家得分: %d\n", player1_score);
             printf("AI得分: %d\n", player2_score);
-        } 
+        }
         else
         {
             printf("玩家1(黑棋)得分: %d\n", player1_score);
@@ -752,7 +454,7 @@ void handle_save_record(int game_mode)
         {
         case 0: // 成功
             printf("\n游戏记录已成功保存至: %s\n", filename);
-            printf("您可以使用以下命令进行复盘: .\\五子棋.exe -l %s\n", filename);
+            printf("您可以使用以下命令进行复盘: .\\gobang.exe -l %s\n", filename);
             break;
         case 1: // 目录创建失败
             printf("\n游戏记录保存失败: 无法创建 'records' 目录。\n");
@@ -775,7 +477,7 @@ void handle_save_record(int game_mode)
 
 /**
  * @brief 悔棋功能实现
- * 
+ *
  * @param steps_to_undo 要悔棋的步数
  * @return true 悔棋成功
  * @return false 悔棋失败(步数不足)
@@ -789,14 +491,16 @@ bool return_move(int steps_to_undo)
 
     for (int i = 0; i < steps_to_undo; i++)
     {
-        step_count--;
+        if (step_count > 0)
-        board[steps[step_count].x][steps[step_count].y] = EMPTY;
+        {
+            step_count--;
+            board[steps[step_count].x][steps[step_count].y] = EMPTY;
+        }
     }
 
     return true;
 }
 
-
 /**
  * @brief 评估玩家在整盘棋局中的表现
  * @param player 要评估的玩家(PLAYER/AI)

gobang.h

@@ -3,7 +3,7 @@
  * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
  * @brief 五子棋游戏头文件
  * @version 3.0
- * @date 2025-06-26
+ * @date 2025-06-30
  *
  * @copyright Copyright (c) 2025
  *
@@ -41,8 +41,8 @@
  */
 #define PLAYER 1  // 玩家棋子标识符
 #define AI 2      // AI棋子标识符
-#define PLAYER3 3 // 玩家3棋子标识符
+#define PLAYER1 1 // 玩家1棋子标识符
-#define PLAYER4 4 // 玩家4棋子标识符
+#define PLAYER2 2 // 玩家2棋子标识符
 
 /**
  * @brief 空位置标识符
@@ -63,6 +63,7 @@ extern int step_count;                            // 当前步数计数器
 extern bool use_forbidden_moves;                  // 是否启用禁手规则
 extern int use_timer;                             // 是否启用计时器
 extern int time_limit;                            // 时间限制（秒）
+extern const int direction[4][2];
 
 /**
  * @brief 落子步骤记录结构体
@@ -175,34 +176,6 @@ DirInfo count_specific_direction(int x, int y, int dx, int dy, int player);
  */
 bool check_win(int x, int y, int player);
 
-/**
- * @brief 评估特定位置对当前玩家的价值
- * @param x 行坐标(0-base)
- * @param y 列坐标(0-base)
- * @param player 玩家标识(PLAYER/AI)
- * @return int 位置评估分数(越高越好)
- */
-int evaluate_pos(int x, int y, int player);
-
-/**
- * @brief 带α-β剪枝的深度优先搜索(极小极大算法)
- * @param x 当前行坐标
- * @param y 当前列坐标
- * @param player 当前玩家
- * @param depth 搜索深度
- * @param alpha α值(当前最大值)
- * @param beta β值(当前最小值)
- * @param is_maximizing 是否为极大化玩家
- * @return int 最佳评估分数
- */
-int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing);
-
-/**
- * @brief AI落子决策函数
- * 使用评估函数和搜索算法选择最佳落子位置
- */
-void ai_move(int depth);
-
 /**
  * @brief 悔棋功能实现
  * @return true 悔棋成功
@@ -233,7 +206,6 @@ int evaluate_performance(int player);
  */
 int calculate_step_score(int x, int y, int player);
 
-
 /**
  * @brief 将当前游戏记录保存到文件
  * @param filename 要保存的文件名

五子棋.c

@@ -7,10 +7,10 @@
 
 /**
  * @brief 将指令复制到powershell
- * gcc 五子棋.c gobang.c game_mode.c -o output/五子棋.exe
+ * gcc 五子棋.c gobang.c game_mode.c ai.c -o gobang.exe
  * gcc 为编译器，五子棋.c gobang.c game_mode.c 为源文件，output/为输出目录
  * @brief 将指令复制到powershell
- * .\output\五子棋.exe
+ * .\gobang.exe
  */
 
 int main(int argc, char *argv[])
@@ -24,24 +24,32 @@ int main(int argc, char *argv[])
 #endif
 
     // 选择模式
-    printf("===== 五子棋游戏 =====\n");
+    while(1)
-    printf("1. AI模式\n");
+    {
-    printf("2. 玩家比赛\n");
+        printf("===== 五子棋游戏 =====\n");
-    printf("3. 复盘模式\n");
+        printf("1. AI模式\n");
-    int mode = get_integer_input("请输入模式(1/2/3): ", 1, 3);
+        printf("2. 玩家比赛\n");
+        printf("3. 复盘模式\n");
+        printf("4. 退出游戏\n");
+        int mode = get_integer_input("请输入模式(1/2/3/4): ", 1, 4);
 
-    if (mode == 1)
+        if (mode == 1)
-    {
+        {
-        run_ai_game();
+            run_ai_game();
+        }
+        else if (mode == 2)
+        {
+            run_pvp_game();
+        }
+        else if (mode == 3)
+        {
+            run_review_mode();
+        }
+        else if (mode == 4)
+        {
+            break;
+        }
     }
-    else if (mode == 2)
+    
-    {
-        run_pvp_game();
-    }
-    else if (mode == 3)
-    {
-        run_review_mode();
-    }
-
     return 0;
 }