From 377a047d42a43d442acfeab0b16153f538a78e1e Mon Sep 17 00:00:00 2001 From: LHY0125 <3364451258@qq.com> Date: Thu, 10 Jul 2025 14:01:42 +0800 Subject: [PATCH] Add files via upload --- ai.c | 204 +++++++++++++++---------------- ai.h | 24 ++-- config.h | 176 +++++++++++++-------------- gobang.c | 150 +++++++++++------------ gobang.h | 92 +++++++------- init_board.c | 52 ++++---- main.c | 45 ------- network.h | 172 +++++++++++++-------------- record.c | 330 +++++++++++++++++++++++++-------------------------- record.h | 30 ++--- 简介.txt | 76 ++++++++++++ 11 files changed, 691 insertions(+), 660 deletions(-) create mode 100644 简介.txt diff --git a/ai.c b/ai.c index 7bb45f5..5c639f4 100644 --- a/ai.c +++ b/ai.c @@ -7,102 +7,102 @@ #include /** - * @brief һλõۺϵ÷֣Ͻͷأ - * @param x - * @param y - * @return int ۺϵ÷ + * @brief 评估一个落子位置的综合得分（结合进攻和防守） + * @param x 行坐标 + * @param y 列坐标 + * @return int 综合得分 */ int evaluate_move(int x, int y) { - // ÷֣AIڴ˴ӵķ + // 进攻得分：评估AI在此处落子的分数 int attack_score = evaluate_pos(x, y, AI); - // ص÷֣ڴ˴ӵķΪص + // 防守得分：评估玩家在此处落子的分数，作为防守的依据 int defense_score = evaluate_pos(x, y, PLAYER); - // ۺϵ÷֣Ȩ defense_coefficient + // 综合得分，防守权重由 defense_coefficient 控制 return attack_score + (int)(defense_score * defense_coefficient); } /** - * @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() - * - λжӳ + * @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}; // ĸĵ÷ + 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 SEARCH_WIN_BONUS; // + board[x][y] = original; // 还原棋盘 + return SEARCH_WIN_BONUS; // 返回最大分 } - // + // 根据连续棋子数评分 switch (info.continuous_chess) { - case 4: // - if (info.check_start && info.check_end) // (˿) + case 4: // 四连珠 + if (info.check_start && info.check_end) // 活四(两端开放) line_scores[i] = AI_SCORE_LIVE_FOUR; - else if (info.check_start || info.check_end) // (һ˿) + else if (info.check_start || info.check_end) // 冲四(一端开放) line_scores[i] = AI_SCORE_RUSH_FOUR; - else // (˷) + else // 死四(两端封闭) line_scores[i] = AI_SCORE_DEAD_FOUR; break; - case 3: // - if (info.check_start && info.check_end) // + case 3: // 三连珠 + if (info.check_start && info.check_end) // 活三 line_scores[i] = AI_SCORE_LIVE_THREE; - else if (info.check_start || info.check_end) // + else if (info.check_start || info.check_end) // 眠三 line_scores[i] = AI_SCORE_SLEEP_THREE; - else // + else // 死三 line_scores[i] = AI_SCORE_DEAD_THREE; break; - case 2: // - if (info.check_start && info.check_end) // + case 2: // 二连珠 + if (info.check_start && info.check_end) // 活二 line_scores[i] = AI_SCORE_LIVE_TWO; - else if (info.check_start || info.check_end) // ߶ + else if (info.check_start || info.check_end) // 眠二 line_scores[i] = AI_SCORE_SLEEP_TWO; - else // + else // 死二 line_scores[i] = AI_SCORE_DEAD_TWO; break; - case 1: // - if (info.check_start && info.check_end) // λ + case 1: // 单子 + if (info.check_start && info.check_end) // 开放位置 line_scores[i] = AI_SCORE_LIVE_ONE; - else if (info.check_start || info.check_end) // 뿪λ + else if (info.check_start || info.check_end) // 半开放位置 line_scores[i] = AI_SCORE_HALF_ONE; - else // λ + else // 封闭位置 line_scores[i] = AI_SCORE_DEAD_ONE; break; } } - // ܷ֣߷+ּȨ + // 计算总分（最高方向分+其他方向分加权） int max_score = 0; int sum_score = 0; for (int i = 0; i < 4; i++) @@ -113,44 +113,44 @@ int evaluate_pos(int x, int y, int player) } sum_score += line_scores[i]; } - total_score = max_score * 10 + sum_score; // Ȩظ + 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 = AI_POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // ԽԽ + int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离 + int position_bonus = AI_POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高 - board[x][y] = original; // ԭ״̬ - return total_score + position_bonus; // + 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. ʹæ-¼֦Ż + * @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) ? SEARCH_WIN_BONUS + depth : -SEARCH_WIN_BONUS - depth; } - // ﵽȻƽ + // 达到搜索深度或平局 if (depth == 0 || step_count >= BOARD_SIZE * BOARD_SIZE) { return evaluate_pos(x, y, AI) - evaluate_pos(x, y, PLAYER); @@ -158,7 +158,7 @@ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximi int best_score = is_maximizing ? -1000000 : 1000000; - // пλ + // 遍历所有可能落子位置 for (int i = 0; i < BOARD_SIZE; i++) { for (int j = 0; j < BOARD_SIZE; j++) @@ -168,34 +168,34 @@ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximi 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)߼ + // 极大值玩家(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; @@ -204,7 +204,7 @@ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximi } if ((is_maximizing && best_score >= beta) || (!is_maximizing && best_score <= alpha)) { - break; // ǰ˳ѭ + break; // 提前退出外层循环 } } @@ -212,28 +212,28 @@ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximi } /** - * @brief AIʹ㷨ѡλ - * @note ׶ξ߼ - * 1. ׶Σ鲢ֹҼʤλãġġ - * 2. ׶Σ޽ʹѡѽλ - * @note ʵϸڣ - * - ȴһġĵΣվ - * - >AI_SEARCH_RANGE_THRESHOLDʱСΧӸAI_NEARBY_RANGE - * - ʹλȲ + * @brief AI决策主函数，使用评估函数和搜索算法选择最佳落子位置 + * @note 采用两阶段决策逻辑： + * 1. 防御阶段：检查并阻止玩家即将获胜的位置（活四、冲四、活三） + * 2. 进攻阶段：若无紧急防御需求，使用评估函数选择最佳进攻位置 + * @note 实现细节： + * - 优先处理玩家活四、冲四等危险局面 + * - 步数>AI_SEARCH_RANGE_THRESHOLD时缩小搜索范围到已有棋子附近AI_NEARBY_RANGE格 + * - 使用中心位置优先策略 */ void ai_move(int depth) { - // ǵһֱλø + // 如果是第一步，直接下在中心位置附近 if (step_count == 0) { int center = BOARD_SIZE / 2; board[center][center] = AI; steps[step_count++] = (Step){AI, center, center}; - printf("AI(%d, %d)\n", center + 1, center + 1); + printf("AI落子(%d, %d)\n", center + 1, center + 1); return; } - // 1. ȼǷҪֹҵӻ + // 1. 首先检查是否需要阻止玩家的四子连棋或三子活棋 for (int i = 0; i < BOARD_SIZE; i++) { for (int j = 0; j < BOARD_SIZE; j++) @@ -243,23 +243,23 @@ void ai_move(int depth) 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; @@ -267,24 +267,24 @@ void ai_move(int depth) } } - board[i][j] = EMPTY; // ָ + 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); + printf("AI落子(%d, %d)\n", i + 1, j + 1); return; } } } - // 2. ûҪֹ + // 2. 如果没有需要立即阻止的情况，则正常评估 int best_score = -SEARCH_WIN_BONUS; int best_x = -1, best_y = -1; - // пλ + // 遍历棋盘所有空位 for (int i = 0; i < BOARD_SIZE; i++) { for (int j = 0; j < BOARD_SIZE; j++) @@ -294,7 +294,7 @@ void ai_move(int depth) continue; } - // ֻӸ(AI_NEARBY_RANGEΧ) + // 只考虑已有棋子附近(AI_NEARBY_RANGE格范围内) bool has_nearby_stone = false; for (int di = -AI_NEARBY_RANGE; di <= AI_NEARBY_RANGE; di++) { @@ -321,10 +321,10 @@ void ai_move(int depth) continue; } - // ʹȡۺϵ÷ + // 使用评估函数获取综合得分 int current_score = evaluate_move(i, j); - // λ + // 更新最佳位置 if (current_score > best_score) { best_score = current_score; @@ -334,11 +334,11 @@ void ai_move(int depth) } } - // ִ + // 执行最佳落子 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); + printf("AI落子(%d, %d)\n", best_x + 1, best_y + 1); } } \ No newline at end of file diff --git a/ai.h b/ai.h index 2255c37..87f9fe8 100644 --- a/ai.h +++ b/ai.h @@ -4,33 +4,33 @@ #include "gobang.h" /** - * @brief һλõۺϵ÷֣Ͻͷأ + * @brief 评估一个落子位置的综合得分（结合进攻和防守） * - * @param x - * @param y - * @return int ۺϵ÷ + * @param x 行坐标 + * @param y 列坐标 + * @return int 综合得分 */ int evaluate_move(int x, int y); /** - * @brief ָλõļֵ + * @brief 评估指定位置的价值 * - * @param x λx - * @param y λy - * @param player ұʶ(PLAYER/AI) - * @return int λüֵ + * @param x 位置x坐标 + * @param y 位置y坐标 + * @param player 玩家标识(PLAYER/AI) + * @return int 位置价值 */ int evaluate_pos(int x, int y, int player); /** - * @brief ֵ̼ + * @brief 评估棋盘价值 * - * @param player ұʶ(PLAYER/AI) + * @param player 玩家标识(PLAYER/AI) */ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing); /** - * @brief AI + * @brief AI下棋 * * @param depth */ diff --git a/config.h b/config.h index 2c5bb7f..bcd92e2 100644 --- a/config.h +++ b/config.h @@ -1,151 +1,151 @@ /** * @file config.h - * @author (3364451258@qq.com15236416560@163.comlhy3364451258@outlook.com) - * @brief Ϸͷļ + * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com) + * @brief 五子棋游戏参数配置头文件 * @version 6.0 * @date 2025-07-10 * * @copyright Copyright (c) 2025 * - * @note ļжϷвãͳһ޸ + * @note 本文件集中定义了五子棋游戏的所有参数配置，便于统一管理和修改 */ #ifndef CONFIG_H #define CONFIG_H -//---------- ز ----------// -#define MAX_BOARD_SIZE 25 // ֵ֧̳ߴ -#define MIN_BOARD_SIZE 5 // ֵ֧С̳ߴ -#define DEFAULT_BOARD_SIZE 15 // Ĭ̳ߴ -#define MAX_STEPS (MAX_BOARD_SIZE * MAX_BOARD_SIZE) // Ϸ +//---------- 棋盘相关参数 ----------// +#define MAX_BOARD_SIZE 25 // 支持的最大棋盘尺寸 +#define MIN_BOARD_SIZE 5 // 支持的最小棋盘尺寸 +#define DEFAULT_BOARD_SIZE 15 // 默认棋盘尺寸 +#define MAX_STEPS (MAX_BOARD_SIZE * MAX_BOARD_SIZE) // 游戏最大步数 -//---------- ұʶ ----------// -#define EMPTY 0 // ̿λʶ -#define PLAYER 1 // ұʶ (˻սģʽ) -#define AI 2 // AIʶ (˻սģʽ) -#define PLAYER1 1 // 1ʶ (˫˶սģʽ) -#define PLAYER2 2 // 2ʶ (˫˶սģʽ) +//---------- 玩家标识参数 ----------// +#define EMPTY 0 // 棋盘空位标识 +#define PLAYER 1 // 玩家标识 (用于人机对战模式) +#define AI 2 // AI标识 (用于人机对战模式) +#define PLAYER1 1 // 玩家1标识 (用于双人对战模式) +#define PLAYER2 2 // 玩家2标识 (用于双人对战模式) -//---------- ----------// -#define INPUT_UNDO -1 // -#define INPUT_SAVE -2 // -#define INPUT_EXIT -3 // ˳ -#define INPUT_SURRENDER -4 // +//---------- 特殊输入命令 ----------// +#define INPUT_UNDO -1 // 悔棋 +#define INPUT_SAVE -2 // 保存 +#define INPUT_EXIT -3 // 退出 +#define INPUT_SURRENDER -4 // 认输 -//---------- ϷĬֵ ----------// -#define DEFAULT_USE_FORBIDDEN_MOVES false // Ĭϲýֹ -#define DEFAULT_USE_TIMER 0 // Ĭϲüʱ -#define DEFAULT_TIME_LIMIT 30 // ĬʱΪ30(ڲ洢) +//---------- 游戏设置默认值 ----------// +#define DEFAULT_USE_FORBIDDEN_MOVES false // 默认不启用禁手规则 +#define DEFAULT_USE_TIMER 0 // 默认不启用计时器 +#define DEFAULT_TIME_LIMIT 30 // 默认时间限制为30秒(内部存储) -//---------- AI ----------// -#define DEFAULT_AI_DEPTH 3 // ĬAI -#define DEFAULT_DEFENSE_COEFFICIENT 1.2 // ĬϷϵ +//---------- AI参数 ----------// +#define DEFAULT_AI_DEPTH 3 // 默认AI搜索深度 +#define DEFAULT_DEFENSE_COEFFICIENT 1.2 // 默认防守系数 -//---------- ----------// -#define DEFAULT_NETWORK_PORT 8888 // Ĭ˿ -#define MIN_NETWORK_PORT 1024 // С˿ -#define MAX_NETWORK_PORT 65535 // ˿ -#define NETWORK_TIMEOUT_MS 5000 // 糬ʱʱ() -#define NETWORK_BUFFER_SIZE 1024 // 绺С +//---------- 网络参数 ----------// +#define DEFAULT_NETWORK_PORT 8888 // 默认网络端口 +#define MIN_NETWORK_PORT 1024 // 最小网络端口 +#define MAX_NETWORK_PORT 65535 // 最大网络端口 +#define NETWORK_TIMEOUT_MS 5000 // 网络超时时间(毫秒) +#define NETWORK_BUFFER_SIZE 1024 // 网络缓冲区大小 -//---------- ֲ ----------// -// - calculate_step_score -#define SCORE_FIVE 0 // -#define SCORE_LIVE_FOUR 2000 // -#define SCORE_RUSH_FOUR 1000 // -#define SCORE_DEAD_FOUR 300 // -#define SCORE_LIVE_THREE 500 // -#define SCORE_SLEEP_THREE 200 // -#define SCORE_DEAD_THREE 80 // -#define SCORE_LIVE_TWO 100 // -#define SCORE_SLEEP_TWO 40 // ߶ -#define SCORE_DEAD_TWO 15 // -#define SCORE_LIVE_ONE 15 // ŵ -#define SCORE_HALF_ONE 8 // 뿪ŵ -#define SCORE_DEAD_ONE 2 // յ +//---------- 评分参数 ----------// +// 棋型评分 - 用于calculate_step_score函数 +#define SCORE_FIVE 0 // 五连 +#define SCORE_LIVE_FOUR 2000 // 活四 +#define SCORE_RUSH_FOUR 1000 // 冲四 +#define SCORE_DEAD_FOUR 300 // 死四 +#define SCORE_LIVE_THREE 500 // 活三 +#define SCORE_SLEEP_THREE 200 // 眠三 +#define SCORE_DEAD_THREE 80 // 死三 +#define SCORE_LIVE_TWO 100 // 活二 +#define SCORE_SLEEP_TWO 40 // 眠二 +#define SCORE_DEAD_TWO 15 // 死二 +#define SCORE_LIVE_ONE 15 // 开放单子 +#define SCORE_HALF_ONE 8 // 半开放单子 +#define SCORE_DEAD_ONE 2 // 封闭单子 -// λýϵ -#define POSITION_BONUS_FACTOR 10 // λý +// 位置奖励系数 +#define POSITION_BONUS_FACTOR 10 // 位置奖励因子 -// AI - evaluate_pos -#define AI_SCORE_FIVE 1000000 // AI- -#define AI_SCORE_LIVE_FOUR 100000 // AI- -#define AI_SCORE_RUSH_FOUR 10000 // AI- -#define AI_SCORE_DEAD_FOUR 500 // AI- -#define AI_SCORE_LIVE_THREE 5000 // AI- -#define AI_SCORE_SLEEP_THREE 1000 // AI- -#define AI_SCORE_DEAD_THREE 50 // AI- -#define AI_SCORE_LIVE_TWO 500 // AI- -#define AI_SCORE_SLEEP_TWO 100 // AI-߶ -#define AI_SCORE_DEAD_TWO 10 // AI- -#define AI_SCORE_LIVE_ONE 50 // AI-ŵ -#define AI_SCORE_HALF_ONE 10 // AI-뿪ŵ -#define AI_SCORE_DEAD_ONE 1 // AI-յ +// AI评估参数 - 用于evaluate_pos函数 +#define AI_SCORE_FIVE 1000000 // AI评估-五连 +#define AI_SCORE_LIVE_FOUR 100000 // AI评估-活四 +#define AI_SCORE_RUSH_FOUR 10000 // AI评估-冲四 +#define AI_SCORE_DEAD_FOUR 500 // AI评估-死四 +#define AI_SCORE_LIVE_THREE 5000 // AI评估-活三 +#define AI_SCORE_SLEEP_THREE 1000 // AI评估-眠三 +#define AI_SCORE_DEAD_THREE 50 // AI评估-死三 +#define AI_SCORE_LIVE_TWO 500 // AI评估-活二 +#define AI_SCORE_SLEEP_TWO 100 // AI评估-眠二 +#define AI_SCORE_DEAD_TWO 10 // AI评估-死二 +#define AI_SCORE_LIVE_ONE 50 // AI评估-开放单子 +#define AI_SCORE_HALF_ONE 10 // AI评估-半开放单子 +#define AI_SCORE_DEAD_ONE 1 // AI评估-封闭单子 -// AIλýϵ -#define AI_POSITION_BONUS_FACTOR 50 // AIλý +// AI位置奖励系数 +#define AI_POSITION_BONUS_FACTOR 50 // AI位置奖励因子 -// 㷨 -#define SEARCH_MAX_SCORE 1000000 // -#define SEARCH_WIN_BONUS 1000000 // ʤ -#define AI_NEARBY_RANGE 2 // AIڽΧ -#define AI_SEARCH_RANGE_THRESHOLD 10 // AIʼΧIJֵ +// 搜索算法参数 +#define SEARCH_MAX_SCORE 1000000 // 搜索最大分数 +#define SEARCH_WIN_BONUS 1000000 // 获胜奖励分数 +#define AI_NEARBY_RANGE 2 // AI搜索的邻近范围 +#define AI_SEARCH_RANGE_THRESHOLD 10 // AI开始限制搜索范围的步数阈值 -// Ȩز -#define TIME_WEIGHT_FACTOR 0.5 // ʱȨ -#define WIN_BONUS 2000 // ʤ +// 评分权重参数 +#define TIME_WEIGHT_FACTOR 0.5 // 时间权重因子 +#define WIN_BONUS 2000 // 胜利奖励分数 -// ļ· -#define RECORDS_DIR "records" // ¼ļĿ¼ -#define CONFIG_FILE "gobang_config.ini" // ļ· -#define MAX_PATH_LENGTH 256 // · +// 文件路径参数 +#define RECORDS_DIR "records" // 记录文件目录 +#define CONFIG_FILE "gobang_config.ini" // 配置文件路径 +#define MAX_PATH_LENGTH 256 // 最大路径长度 -//---------- ù ----------// +//---------- 配置管理函数声明 ----------// /** - * @brief Ϸ + * @brief 加载游戏配置 */ void load_game_config(); /** - * @brief Ϸ + * @brief 保存游戏配置 */ void save_game_config(); /** - * @brief ΪĬ + * @brief 重置为默认配置 */ void reset_to_default_config(); /** - * @brief ʾǰ + * @brief 显示当前配置 */ void display_current_config(); /** - * @brief ̴С + * @brief 配置棋盘大小 */ void config_board_size(); /** - * @brief ýֹ + * @brief 配置禁手规则 */ void config_forbidden_moves(); /** - * @brief üʱ + * @brief 配置计时器 */ void config_timer(); /** - * @brief + * @brief 配置网络参数 */ void config_network(); /** - * @brief ù˵ + * @brief 配置管理主菜单 */ void config_management_menu(); -//---------- ȫֱ ----------// ȫֱglobals.h +//---------- 网络配置全局变量声明 ----------// 全局变量声明现在在globals.h中 #endif // CONFIG_H \ No newline at end of file diff --git a/gobang.c b/gobang.c index 091e161..702926f 100644 --- a/gobang.c +++ b/gobang.c @@ -10,19 +10,19 @@ #include /** - * @brief (x, y)λǷΪ - * @param x (0-base) - * @param y (0-base) - * @return true-, false-ǿ + * @brief 检查棋盘(x, y)位置是否为空 + * @param x 行坐标(0-base) + * @param y 列坐标(0-base) + * @return true-空, false-非空 */ bool have_space(int x, int y) { return x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == EMPTY; } -// +// 函数定义 /** - * @brief ǷΪ + * @brief 检查是否为禁手 * * @param x * @param y @@ -53,7 +53,7 @@ bool is_forbidden_move(int x, int y, int player) if (info.continuous_chess > 5) { board[x][y] = EMPTY; - return true; // + return true; // 长连禁手 } if (info.continuous_chess == 3 && info.check_start && info.check_end) { @@ -69,64 +69,64 @@ bool is_forbidden_move(int x, int y, int player) if (three_count >= 2 || four_count >= 2) { - return true; // Ľ + return true; // 三三或四四禁手 } return false; } /** - * @brief ִӲ - * @param x (0-base) - * @param y (0-base) - * @return true ӳɹ - * @return false ʧ(λЧ) + * @brief 执行玩家落子操作 + * @param x 行坐标(0-base) + * @param y 列坐标(0-base) + * @return true 落子成功 + * @return false 落子失败(位置无效) */ bool player_move(int x, int y, int player) { - // λЧ򷵻false + // 位置无效则返回false if (!have_space(x, y)) return false; if (is_forbidden_move(x, y, player)) { - printf("֣ѡλá\n"); + printf("禁手！请选择其他位置。\n"); return false; } - // ״̬ + // 更新棋盘状态 board[x][y] = player; - // ¼Ӳ裺ұʶ + // 记录落子步骤：玩家标识和坐标 steps[step_count++] = (Step){player, x, y}; return true; } /** - * @brief ضͬɫ - * @param x ʼ - * @param y ʼ - * @param dx з(-1,0,1) - * @param dy з(-1,0,1) - * @param player ұʶ(PLAYER/AI) - * @return DirInfo ͷ򿪷״̬Ľṹ - * @note ͳж϶˵Ƿ񿪷 + * @brief 计算特定方向上连续同色棋子数量 + * @param x 起始行坐标 + * @param y 起始列坐标 + * @param dx 行方向增量(-1,0,1) + * @param dy 列方向增量(-1,0,1) + * @param player 玩家标识(PLAYER/AI) + * @return DirInfo 包含连续棋子数和方向开放状态的结构体 + * @note 检查正反两个方向，统计连续棋子数并判断端点是否开放 */ DirInfo count_specific_direction(int x, int y, int dx, int dy, int player) { DirInfo info; - info.continuous_chess = 1; // ʼλѾһ - info.check_start = false; // 㷽Ƿ񿪷 - info.check_end = false; // յ㷽Ƿ񿪷 + info.continuous_chess = 1; // 起始位置已经有一个棋子 + info.check_start = false; // 起点方向是否开放 + info.check_end = false; // 终点方向是否开放 - // dx, dy + // 检查正方向（dx, dy） int nx = x + dx, ny = y + dy; while (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player) { - info.continuous_chess++; // Ӽ - nx += dx; // صǰǰ + info.continuous_chess++; // 连续棋子计数增加 + nx += dx; // 沿当前方向前进 ny += dy; } - // ж˵Ƿ񿪷ţλ + // 判断正方向端点是否开放（遇到空位） if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE) { if (board[nx][ny] == EMPTY) @@ -135,15 +135,15 @@ DirInfo count_specific_direction(int x, int y, int dx, int dy, int player) } } - // 鷴-dx, -dy + // 检查反方向（-dx, -dy） nx = x - dx, ny = y - dy; while (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player) { - info.continuous_chess++; // Ӽ - nx -= dx; // ෴ǰ + info.continuous_chess++; // 连续棋子计数增加 + nx -= dx; // 沿相反方向前进 ny -= dy; } - // жϷ˵Ƿ񿪷ţλ + // 判断反方向端点是否开放（遇到空位） if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE) { if (board[nx][ny] == EMPTY) @@ -157,24 +157,24 @@ DirInfo count_specific_direction(int x, int y, int dx, int dy, int player) bool check_win(int x, int y, int player) { - // ĸǷ + // 检查四个方向是否存在五连珠 for (int i = 0; i < 4; i++) { DirInfo info = count_specific_direction(x, y, direction[i][0], direction[i][1], player); - if (info.continuous_chess >= 5) // >=5ʤ + if (info.continuous_chess >= 5) // 连续棋子>=5即获胜 { return true; } } - return false; // ĸû + return false; // 四个方向都没有五连珠 } /** - * @brief 幦ʵ + * @brief 悔棋功能实现 * - * @param steps_to_undo ҪIJ - * @return true ɹ - * @return false ʧ() + * @param steps_to_undo 要悔棋的步数 + * @return true 悔棋成功 + * @return false 悔棋失败(步数不足) */ bool return_move(int steps_to_undo) { @@ -196,74 +196,74 @@ bool return_move(int steps_to_undo) } /** - * @brief еı - * @param player Ҫ(PLAYER/AI) - * @return int ܷ(ѿǷظ) - * @note Ľֱ׼: - * - :5000 (Ȩأǿʤ) - * - :2000 :1000 :300 (Ȩأǿ) - * - :500 :200 :80 (ȨأǿսԼֵ) - * - :100 ߶:40 :15 (ʵȨ) - * - ŵ:15 뿪ŵ:8 յ:2 (ʵȨ) - * @note ʵϸ: - * 1. λ - * 2. ÿӼĸ - * 3. ͳ - * 4. շ4(ظӰ) + * @brief 评估玩家在整盘棋局中的表现 + * @param player 要评估的玩家(PLAYER/AI) + * @return int 总分(已考虑方向重复计算) + * @note 改进后的评分标准: + * - 五连:5000 (提高权重，更强调获胜) + * - 活四:2000 冲四:1000 死四:300 (提高权重，强调进攻性) + * - 活三:500 眠三:200 死三:80 (提高权重，强调战略价值) + * - 活二:100 眠二:40 死二:15 (适当提高权重) + * - 开放单子:15 半开放单子:8 封闭单子:2 (适当提高权重) + * @note 实现细节: + * 1. 遍历棋盘所有位置 + * 2. 对每个棋子检查四个方向 + * 3. 统计所有连子情况并评分 + * 4. 最终分数除以4(消除方向重复计算影响) */ int calculate_step_score(int x, int y, int player) { int step_score = 0; - // ĸ + // 检查四个方向 for (int k = 0; k < 4; k++) { DirInfo info = count_specific_direction(x, y, direction[k][0], direction[k][1], player); - // + // 根据连子数评分 switch (info.continuous_chess) { case 5: step_score += SCORE_FIVE; - break; // + break; // 五连 case 4: if (info.check_start && info.check_end) - step_score += SCORE_LIVE_FOUR; // + step_score += SCORE_LIVE_FOUR; // 活四 else if (info.check_start || info.check_end) - step_score += SCORE_RUSH_FOUR; // + step_score += SCORE_RUSH_FOUR; // 冲四 else - step_score += SCORE_DEAD_FOUR; // + step_score += SCORE_DEAD_FOUR; // 死四 break; case 3: if (info.check_start && info.check_end) - step_score += SCORE_LIVE_THREE; // + step_score += SCORE_LIVE_THREE; // 活三 else if (info.check_start || info.check_end) - step_score += SCORE_SLEEP_THREE; // + step_score += SCORE_SLEEP_THREE; // 眠三 else - step_score += SCORE_DEAD_THREE; // + step_score += SCORE_DEAD_THREE; // 死三 break; case 2: if (info.check_start && info.check_end) - step_score += SCORE_LIVE_TWO; // + step_score += SCORE_LIVE_TWO; // 活二 else if (info.check_start || info.check_end) - step_score += SCORE_SLEEP_TWO; // ߶ + step_score += SCORE_SLEEP_TWO; // 眠二 else - step_score += SCORE_DEAD_TWO; // + step_score += SCORE_DEAD_TWO; // 死二 break; case 1: if (info.check_start && info.check_end) - step_score += SCORE_LIVE_ONE; // ŵ + step_score += SCORE_LIVE_ONE; // 开放单子 else if (info.check_start || info.check_end) - step_score += SCORE_HALF_ONE; // 뿪ŵ + step_score += SCORE_HALF_ONE; // 半开放单子 else - step_score += SCORE_DEAD_ONE; // յ + step_score += SCORE_DEAD_ONE; // 封闭单子 break; } } - // λýԽķԽ + // 位置奖励：越靠近中心分数越高 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 = POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // ԽԽ + int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离 + int position_bonus = POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高 return step_score + position_bonus; } \ No newline at end of file diff --git a/gobang.h b/gobang.h index f6eaa1d..48ca98d 100644 --- a/gobang.h +++ b/gobang.h @@ -9,92 +9,92 @@ #include #include -// ݽṹ +// 数据结构 /** - * @brief ¼һϸϢ + * @brief 记录一步棋的详细信息 */ typedef struct { - int player; // ִиòұʶ - int x; // ӵ (0-based) - int y; // ӵ (0-based) + int player; // 执行该步的玩家标识 + int x; // 落子的行坐标 (0-based) + int y; // 落子的列坐标 (0-based) } Step; /** - * @brief 洢ضԵϢ - * @details Σжϻĵȹؼ̬ + * @brief 存储在特定方向上棋子连续性的信息 + * @details 用于评估棋形，例如判断活三、冲四等关键形态。 */ typedef struct { - int continuous_chess; // ͬɫӵ - bool check_start; // еʼǷΪλǷ񿪷ţ - bool check_end; // еĩβǷΪλǷ񿪷ţ + int continuous_chess; // 连续同色棋子的数量 + bool check_start; // 棋子序列的起始端是否为空位（即是否开放） + bool check_end; // 棋子序列的末尾端是否为空位（即是否开放） } DirInfo; -// ԭ +// 函数原型 -// --- Ϸ߼ --- +// --- 游戏核心逻辑 --- /** - * @brief ָǷΪЧӵ㣨Ϊգ - * @param x (0-based) - * @param y (0-based) - * @return λЧΪ򷵻true򷵻false + * @brief 检查指定坐标是否为有效落子点（在棋盘内且为空） + * @param x 待检查的行坐标 (0-based) + * @param y 待检查的列坐标 (0-based) + * @return 若位置有效且为空则返回true，否则返回false */ bool have_space(int x, int y); /** - * @brief жһǷΪ - * @param x ӵ (0-based) - * @param y ӵ (0-based) - * @param player ǰҵıʶ - * @return ǽ򷵻true򷵻false + * @brief 判断一个落子是否为禁手 + * @param x 落子的行坐标 (0-based) + * @param y 落子的列坐标 (0-based) + * @param player 当前玩家的标识 + * @return 如果是禁手则返回true，否则返回false */ bool is_forbidden_move(int x, int y, int player); /** - * @brief ִһӲ - * @param x ӵ (0-based) - * @param y ӵ (0-based) - * @param player ǰҵıʶ - * @return ӳɹ򷵻trueλЧռãfalse + * @brief 执行一次玩家落子操作 + * @param x 落子的行坐标 (0-based) + * @param y 落子的列坐标 (0-based) + * @param player 当前玩家的标识 + * @return 若落子成功则返回true，否则（位置无效或被占用）返回false */ bool player_move(int x, int y, int player); /** - * @brief ضϵϢ - * @param x ʼ - * @param y ʼ - * @param dx x (-1, 0, or 1) - * @param dy y (-1, 0, or 1) - * @param player ұʶ - * @return һϢ DirInfo ṹ + * @brief 计算在特定方向上的棋子连续信息 + * @param x 起始点的行坐标 + * @param y 起始点的列坐标 + * @param dx x方向的增量 (-1, 0, or 1) + * @param dy y方向的增量 (-1, 0, or 1) + * @param player 玩家标识 + * @return 返回一个包含连续棋子信息的 DirInfo 结构体 */ DirInfo count_specific_direction(int x, int y, int dx, int dy, int player); /** - * @brief ijӺ󣬸Ƿʤ - * @param x ӵ (0-based) - * @param y ӵ (0-based) - * @param player ǰҵıʶ - * @return ʤ򷵻true򷵻false + * @brief 检查在某点落子后，该玩家是否获胜 + * @param x 落子的行坐标 (0-based) + * @param y 落子的列坐标 (0-based) + * @param player 当前玩家的标识 + * @return 如果获胜则返回true，否则返回false */ bool check_win(int x, int y, int player); /** - * @brief 幦ܣָ - * @param steps_to_undo ҪIJÿ˫һӣ - * @return ɹ򷵻true򷵻false + * @brief 悔棋功能，撤销指定步数 + * @param steps_to_undo 要撤销的步数（每步包含双方各一次落子） + * @return 若悔棋成功则返回true，否则返回false */ bool return_move(int steps_to_undo); /** - * @brief 㲢һĵ÷ - * @param x ӵ - * @param y ӵ - * @param player ұʶ - * @return òĵ÷ + * @brief 计算并返回一步棋的得分 + * @param x 落子的行坐标 + * @param y 落子的列坐标 + * @param player 玩家标识 + * @return 该步棋的得分 */ int calculate_step_score(int x, int y, int player); diff --git a/init_board.c b/init_board.c index cb164da..465e03c 100644 --- a/init_board.c +++ b/init_board.c @@ -8,12 +8,12 @@ #include /** - * @brief ʼΪȫ״̬ò - * 鲢λΪEMPTYͬʱstep_countΪ0 + * @brief 初始化棋盘为全空状态并重置步数计数器 + * 清空棋盘数组并将所有位置设为EMPTY，同时将step_count重置为0 */ void empty_board() { - // ʼ״̬Ϊȫ + // 初始化棋盘状态为全空 for (int i = 0; i < BOARD_SIZE; i++) { for (int j = 0; j < BOARD_SIZE; j++) @@ -21,82 +21,82 @@ void empty_board() board[i][j] = EMPTY; } } - step_count = 0; // ò + step_count = 0; // 重置步数计数器 } /** - * @brief ӡǰ״̬ - * Կɶʽ̣кź״̬ - * ʾΪ'x'AIʾΪ''λʾΪ'' + * @brief 打印当前棋盘状态 + * 以可读格式输出棋盘，包括行列号和棋子状态 + * 玩家棋子显示为'x'，AI棋子显示为'○'，空位显示为'·' */ void print_board() { - // ӡкţ1-BOARD_SIZEʾ + // 打印列号（1-BOARD_SIZE显示） printf("\n "); for (int i = 0; i < BOARD_SIZE; i++) { printf("%2d", i + 1); - if (i + 1 == 9) // к910+Ķ + if (i + 1 == 9) // 处理列号9和10+的对齐 { printf(" "); } } printf("\n"); - // дӡ + // 逐行打印棋盘内容 for (int i = 0; i < BOARD_SIZE; i++) { - printf("%2d ", i + 1); // ӡкţ1-BOARD_SIZE + printf("%2d ", i + 1); // 打印行号（1-BOARD_SIZE） for (int j = 0; j < BOARD_SIZE; j++) { if (board[i][j] == PLAYER) { - printf("x "); // + printf("x "); // 玩家棋子 } else if (board[i][j] == AI) { - printf(" "); // AI(ʹáʾ) + printf("○ "); // AI棋子(使用○显示) } else { - printf(" "); // λ + printf("· "); // 空位 } } - printf("\n"); // ÿн + printf("\n"); // 每行结束换行 } } /** - * @brief ̴С + * @brief 配置棋盘大小 * - * @param player1 1 - * @param player2 2 + * @param player1 玩家1 + * @param player2 玩家2 */ void setup_board_size() { - printf("̴ͨСΪ(13X13)׼(15X15)(19X19)\n"); + printf("通常棋盘大小分为休闲棋盘(13X13)、标准棋盘(15X15)和特殊棋盘(19X19)\n"); char prompt[100]; - sprintf(prompt, "̴С(5~%d)(ĬΪ׼):\n", MAX_BOARD_SIZE); + sprintf(prompt, "请输入棋盘大小(5~%d)(默认为标准棋盘):\n", MAX_BOARD_SIZE); BOARD_SIZE = get_integer_input(prompt, 5, MAX_BOARD_SIZE); } /** * @brief Set the up game options object - * Ϸѡֹ򡢼ʱʱ + * 配置游戏选项，包括禁手规则、计时器和时间限制 */ void setup_game_options() { - use_forbidden_moves = get_integer_input("Ƿýֹ (1-, 0-): ", 0, 1); + use_forbidden_moves = get_integer_input("是否启用禁手规则 (1-是, 0-否): ", 0, 1); - use_timer = get_integer_input("Ƿüʱ (1-, 0-): ", 0, 1); + use_timer = get_integer_input("是否启用计时器 (1-是, 0-否): ", 0, 1); if (use_timer) { - time_limit = get_integer_input("ÿغϵʱ (1~60): ", 1, 60) * 60; + time_limit = get_integer_input("请输入每回合的时间限制 (1~60分钟): ", 1, 60) * 60; } } /** - * @brief ȷ + * @brief 确定先手玩家 * * @param player1 * @param player2 @@ -105,7 +105,7 @@ void setup_game_options() int determine_first_player(int player1, int player2) { char prompt[100]; - sprintf(prompt, "ѡַ (1 for Player %d, 2 for Player %d): ", player1, player2); + sprintf(prompt, "请选择先手方 (1 for Player %d, 2 for Player %d): ", player1, player2); int first_player_choice = get_integer_input(prompt, 1, 2); if (first_player_choice == 1) { diff --git a/main.c b/main.c index d394cd4..7864e1b 100644 --- a/main.c +++ b/main.c @@ -1,48 +1,3 @@ -/** - * @file 五子棋.c - * @brief 五子棋游戏核心逻辑头文件 - * @details 游戏核心逻辑实现 - * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com) - * @date 2025-07-10 - * @version 6.0 - * @note - * 1. 新增功能： - * - 增加了对禁手规则的支持，防止玩家进行无意义的走法。 - * - 新增了游戏计时器功能，限制每回合的思考时间。 - * - 添加了复盘功能，支持保存和回顾对局记录。 - * - 实现了评分系统，可以对每一步棋进行评分和分析。 - * 2. 性能优化： - * - 优化了评估函数的性能，减少了不必要的计算。 - * - 引入了 Alpha-Beta 剪枝算法，提高了 AI 搜索的效率。 - * - 改进了内存管理，减少了资源占用。 - * 3. 用户界面改进： - * - 新增了命令行界面，提供更友好的交互体验。 - * - 可以自定义棋盘大小，增加游戏的灵活性。 - * - 优化了提示信息，使游戏操作更加直观。 - * 4. 代码结构优化： - * - 将游戏逻辑和用户界面分离，提高代码的可读性和可维护性。 - * - 优化了代码结构，提高了代码的可读性和可维护性。 - * - 模块化设计，便于功能扩展和维护。 - * 5. 异常处理： - * - 增加了输入错误的异常处理机制，确保游戏的稳定性。 - * - 修复了一些已知的 bug，提高游戏的稳定性。 - * - 增强了错误提示，帮助用户快速定位问题。 - * 6. 文档更新： - * - 完善了代码注释，提高了代码的可读性。 - * - 更新了文档，包括功能描述、使用方法、注意事项等。 - * 7. 版本控制： - * - 使用 Git 进行版本控制，方便团队协作和代码管理。 - * 8. 测试： - * - 进行了全面的测试，确保游戏的稳定性和功能的正确性。 - * 9. 开源协议： - * - 选择了 MIT 开源协议，允许用户自由使用、修改和分发代码。 - * 10. 贡献者： - * - 刘航宇 - * 11. 联系信息： - * - 项目主页：[https://github.com/LHY0125/Gobang-Game] - * - 联系邮箱：[3364451258@qq.com][15236416560@163.com][lhy3364451258@outlook.com] - */ - #include "game_mode.h" #include "ui.h" #include "config.h" diff --git a/network.h b/network.h index 34cabc6..2086cb7 100644 --- a/network.h +++ b/network.h @@ -1,16 +1,16 @@ /** * @file network.h - * @author (3364451258@qq.com15236416560@163.comlhy3364451258@outlook.com) - * @brief սģͷļ + * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com) + * @brief 五子棋网络对战模块头文件 * @version 1.0 * @date 2025-01-15 * * @copyright Copyright (c) 2025 * - * @note ļϷսܣ - * 1. ģʽ - * 2. ͻģʽϷ - * 3. Ϣ + * @note 本文件定义了五子棋游戏的网络对战功能： + * 1. 服务器模式（主机） + * 2. 客户端模式（加入游戏） + * 3. 网络消息传输 */ #ifndef NETWORK_H @@ -34,152 +34,152 @@ #define closesocket close #endif -// +// 网络配置 #define DEFAULT_PORT 8888 #define BUFFER_SIZE 1024 #define MAX_IP_LENGTH 16 -// Ϣ -#define MSG_MOVE 1 // Ϣ -#define MSG_CHAT 2 // Ϣ -#define MSG_SURRENDER 3 // Ϣ -#define MSG_UNDO_REQUEST 4 // -#define MSG_UNDO_RESPONSE 5 // Ӧ -#define MSG_GAME_START 6 // Ϸʼ -#define MSG_GAME_END 7 // Ϸ -#define MSG_HEARTBEAT 8 // -#define MSG_DISCONNECT 9 // Ϣ +// 消息类型 +#define MSG_MOVE 1 // 落子消息 +#define MSG_CHAT 2 // 聊天消息 +#define MSG_SURRENDER 3 // 认输消息 +#define MSG_UNDO_REQUEST 4 // 悔棋请求 +#define MSG_UNDO_RESPONSE 5 // 悔棋回应 +#define MSG_GAME_START 6 // 游戏开始 +#define MSG_GAME_END 7 // 游戏结束 +#define MSG_HEARTBEAT 8 // 心跳包 +#define MSG_DISCONNECT 9 // 断线消息 -// Ϣṹ +// 网络消息结构 typedef struct { - int type; // Ϣ - int player_id; // ID - int x, y; // ꣨ӣ - char message[256]; // Ϣݣȣ - time_t timestamp; // ʱ + int type; // 消息类型 + int player_id; // 玩家ID + int x, y; // 坐标（用于落子） + char message[256]; // 消息内容（用于聊天等） + time_t timestamp; // 时间戳 } NetworkMessage; -// Ϸ״̬ +// 网络游戏状态 typedef struct { - SOCKET socket; // ׽ - bool is_server; // ǷΪ - bool is_connected; // Ƿ - int local_player_id; // ID - int remote_player_id; // ԶID - char remote_ip[MAX_IP_LENGTH]; // ԶIPַ - int port; // ˿ں + SOCKET socket; // 套接字 + bool is_server; // 是否为服务器 + bool is_connected; // 是否已连接 + int local_player_id; // 本地玩家ID + int remote_player_id; // 远程玩家ID + char remote_ip[MAX_IP_LENGTH]; // 远程IP地址 + int port; // 端口号 } NetworkGameState; -// ȫֱglobals.h +// 全局变量声明现在在globals.h中 -// +// 函数声明 /** - * @brief ʼģ - * @return true ʼɹ - * @return false ʼʧ + * @brief 初始化网络模块 + * @return true 初始化成功 + * @return false 初始化失败 */ bool init_network(); /** - * @brief ģ + * @brief 清理网络模块 */ void cleanup_network(); /** - * @brief ģʽ - * @param port ˿ - * @return true ɹ - * @return false ʧ + * @brief 创建服务器（主机模式） + * @param port 监听端口 + * @return true 创建成功 + * @return false 创建失败 */ bool create_server(int port); /** - * @brief ӵͻģʽ - * @param ip IPַ - * @param port ˿ - * @return true ӳɹ - * @return false ʧ + * @brief 连接到服务器（客户端模式） + * @param ip 服务器IP地址 + * @param port 服务器端口 + * @return true 连接成功 + * @return false 连接失败 */ bool connect_to_server(const char* ip, int port); /** - * @brief Ϣ - * @param msg Ҫ͵Ϣ - * @return true ͳɹ - * @return false ʧ + * @brief 发送网络消息 + * @param msg 要发送的消息 + * @return true 发送成功 + * @return false 发送失败 */ bool send_network_message(const NetworkMessage* msg); /** - * @brief Ϣ - * @param msg ϢĻ - * @param timeout_ms ʱʱ䣨룩0ʾȴ - * @return true ճɹ - * @return false ʧܻʱ + * @brief 接收网络消息 + * @param msg 接收消息的缓冲区 + * @param timeout_ms 超时时间（毫秒），0表示阻塞等待 + * @return true 接收成功 + * @return false 接收失败或超时 */ bool receive_network_message(NetworkMessage* msg, int timeout_ms); /** - * @brief Ͽ + * @brief 断开网络连接 */ void disconnect_network(); /** - * @brief ״̬ - * @return true - * @return false ӶϿ + * @brief 检查网络连接状态 + * @return true 连接正常 + * @return false 连接断开 */ bool is_network_connected(); /** - * @brief ȡIPַ - * @param ip_buffer 洢IPַĻ - * @param buffer_size С - * @return true ȡɹ - * @return false ȡʧ + * @brief 获取本机IP地址 + * @param ip_buffer 存储IP地址的缓冲区 + * @param buffer_size 缓冲区大小 + * @return true 获取成功 + * @return false 获取失败 */ bool get_local_ip(char* ip_buffer, int buffer_size); /** - * @brief Ϣ - * @param x - * @param y - * @param player_id ID - * @return true ͳɹ - * @return false ʧ + * @brief 发送落子消息 + * @param x 行坐标 + * @param y 列坐标 + * @param player_id 玩家ID + * @return true 发送成功 + * @return false 发送失败 */ bool send_move(int x, int y, int player_id); /** - * @brief Ϣ - * @param message - * @return true ͳɹ - * @return false ʧ + * @brief 发送聊天消息 + * @param message 聊天内容 + * @return true 发送成功 + * @return false 发送失败 */ bool send_chat_message(const char* message); /** - * @brief Ϣ - * @return true ͳɹ - * @return false ʧ + * @brief 发送认输消息 + * @return true 发送成功 + * @return false 发送失败 */ bool send_surrender(); /** - * @brief ͻ - * @param steps 岽 - * @return true ͳɹ - * @return false ʧ + * @brief 发送悔棋请求 + * @param steps 悔棋步数 + * @return true 发送成功 + * @return false 发送失败 */ bool send_undo_request(int steps); /** - * @brief ͻӦ - * @param accepted Ƿͬ - * @param steps 岽 - * @return true ͳɹ - * @return false ʧ + * @brief 发送悔棋回应 + * @param accepted 是否同意悔棋 + * @param steps 悔棋步数 + * @return true 发送成功 + * @return false 发送失败 */ bool send_undo_response(bool accepted, int steps); diff --git a/record.c b/record.c index 25a032a..fa30784 100644 --- a/record.c +++ b/record.c @@ -20,91 +20,91 @@ #endif /** - * @brief Ϸȫ̲չʾ - * @note ʵ: - * 1. ʼʱ - * 2. ˳ÿ - * 3. ÿʾ: - * - ǰ/ܲ - * - ӷ(/AI) - * - λ(1-based) - * - ǰ״̬ - * 4. ͨûEnterƲǰ - * 5. ̽Զֻ: - * - ˫ - * - ʾ÷ - * - ѡMVP - * @note ϸ: - * - ʹöʱ̱ӰϷ״̬ - * - ʾתΪ1-basedû - * - 뻺ֹ - * - ֻڵcalculate_final_score() + * @brief 复盘游戏全过程并展示评分 + * @note 实现流程: + * 1. 初始化临时复盘棋盘 + * 2. 按步数顺序逐步重现每个落子 + * 3. 每步显示: + * - 当前步数/总步数 + * - 落子方(玩家/AI) + * - 落子位置(1-based坐标) + * - 当前棋盘状态 + * 4. 通过用户按Enter键控制步骤前进 + * 5. 复盘结束后自动进入评分环节: + * - 评估双方表现 + * - 显示得分 + * - 评选MVP + * @note 技术细节: + * - 使用独立临时棋盘避免影响主游戏状态 + * - 坐标显示转换为1-based方便用户理解 + * - 包含输入缓冲区清理防止意外输入 + * - 评分环节调用calculate_final_score()函数 */ void review_process(int game_mode) { - int review_choice = get_integer_input("ǷҪֱ̱? (1-, 0-): ", 0, 1); + int review_choice = get_integer_input("是否要复盘本局比赛? (1-是, 0-否): ", 0, 1); - // δ㣬 + // 如果评分尚未计算，则计算评分 if (!scores_calculated) { calculate_game_scores(); } else { - // Ѵļмأֱʹ - printf("Ӽ¼ļм\n"); + // 评分已从文件中加载，直接使用 + printf("从记录文件中加载评分数据\n"); } if (review_choice == 1) { - printf("\n===== ̼¼(ܲ%d) =====\n", step_count); - // 뻺 + printf("\n===== 复盘记录(总步数：%d) =====\n", step_count); + // 清空输入缓冲区 int c; while ((c = getchar()) != '\n' && c != EOF) ; - // ʱ + // 创建临时复盘棋盘 int temp_board[MAX_BOARD_SIZE][MAX_BOARD_SIZE]; - memset(temp_board, EMPTY, sizeof(temp_board)); // ʼΪ + memset(temp_board, EMPTY, sizeof(temp_board)); // 初始化为空棋盘 - // Ϸ + // 逐步重现游戏过程 for (int i = 0; i < step_count; i++) { - Step s = steps[i]; // ȡǰ - temp_board[s.x][s.y] = s.player; // ʱ + Step s = steps[i]; // 获取当前步骤 + temp_board[s.x][s.y] = s.player; // 在临时棋盘上落子 - // ӡǰϢ - // ϷģʽʾͬıϢ + // 打印当前步骤信息 + // 根据游戏模式显示不同的标题和玩家信息 if (game_mode == 1) { - // ˻ս - printf("\n===== ˻ս(%dX%d) =====", BOARD_SIZE, BOARD_SIZE); - printf("\n %d/%d: %s (%d, %d)\n", + // 人机对战 + printf("\n===== 五子棋人机对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE); + printf("\n 第%d步/%d步: %s 落子于(%d, %d)\n", i + 1, step_count, - (s.player == PLAYER) ? "" : "AI", + (s.player == PLAYER) ? "玩家" : "AI", s.x + 1, s.y + 1); } else { - // ˫˶ս - printf("\n===== ˫˶ս(%dX%d) =====", BOARD_SIZE, BOARD_SIZE); - printf("\n %d/%d: %s (%d, %d)\n", + // 双人对战 + printf("\n===== 五子棋双人对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE); + printf("\n 第%d步/%d步: %s 落子于(%d, %d)\n", i + 1, step_count, - (s.player == PLAYER1) ? "1()" : "2()", + (s.player == PLAYER1) ? "玩家1(黑棋)" : "玩家2(白棋)", s.x + 1, s.y + 1); } - // ӡǰ + // 打印当前复盘棋盘 printf(" "); for (int col = 0; col < BOARD_SIZE; col++) { - printf("%2d", col + 1); // к + printf("%2d", col + 1); // 列号 } printf("\n"); for (int row = 0; row < BOARD_SIZE; row++) { - printf("%2d ", row + 1); // к + printf("%2d ", row + 1); // 行号 for (int col = 0; col < BOARD_SIZE; col++) { if (temp_board[row][col] == PLAYER || temp_board[row][col] == PLAYER1) @@ -113,72 +113,72 @@ void review_process(int game_mode) } else if (temp_board[row][col] == AI || temp_board[row][col] == PLAYER2) { - printf(" "); + printf("○ "); } else { - printf(" "); + printf("· "); } } - printf("\n"); // н + printf("\n"); // 行结束换行 } - // һȴû + // 如果不是最后一步，等待用户按键继续 if (i < step_count - 1) { - printf("\nEnterһ..."); + printf("\n按Enter继续下一步..."); while (getchar() != '\n') - ; // ȴس + ; // 等待回车 } } - // ʾʤֱʹļеϢ - printf("\n===== Ծֽ ====="); - if (strcmp(winner_info, "һʤ") == 0) + // 显示胜负结果（直接使用文件中的信息） + printf("\n===== 对局结果 ====="); + if (strcmp(winner_info, "玩家获胜") == 0) { - printf("\n? ϲһʤ\n"); + printf("\n? 恭喜！玩家获胜！\n"); } - else if (strcmp(winner_info, "AIʤ") == 0) + else if (strcmp(winner_info, "AI获胜") == 0) { - printf("\n? AIʤ\n"); + printf("\n? AI获胜！\n"); } - else if (strcmp(winner_info, "1ʤ") == 0) + else if (strcmp(winner_info, "玩家1获胜") == 0) { - printf("\n? ϲ1()ʤ\n"); + printf("\n? 恭喜！玩家1(黑棋)获胜！\n"); } - else if (strcmp(winner_info, "2ʤ") == 0) + else if (strcmp(winner_info, "玩家2获胜") == 0) { - printf("\n? ϲ2()ʤ\n"); + printf("\n? 恭喜！玩家2(白棋)获胜！\n"); } else { - printf("\n?? Ծƽֻδ\n"); + printf("\n?? 对局平局或未完成\n"); } - printf("\n̽Enter鿴..."); - getchar(); // ȴû + printf("\n复盘结束！按Enter查看评分..."); + getchar(); // 等待用户按键 } - // ʾֽ + // 显示评分结果 display_game_scores(game_mode); getchar(); } /** - * @brief Ϸ + * @brief 计算游戏评分 */ void calculate_game_scores() { - // ˫ + // 评估双方表现 player1_final_score = 0; player2_final_score = 0; - // вۻÿһĵ÷֣ڲȨظ + // 遍历所有步数，累积每一步的得分，后期步骤权重更高 for (int i = 0; i < step_count; i++) { - // ʱȨӣԽȨԽ - double time_weight = 1.0 + (double)i / step_count * TIME_WEIGHT_FACTOR; // IJȨǿʼ(1+TIME_WEIGHT_FACTOR) + // 计算时间权重因子：步数越靠后，权重越大 + double time_weight = 1.0 + (double)i / step_count * TIME_WEIGHT_FACTOR; // 最后的步骤权重是开始步骤的(1+TIME_WEIGHT_FACTOR)倍 if (steps[i].player == PLAYER || steps[i].player == PLAYER1) { @@ -190,50 +190,50 @@ void calculate_game_scores() } } - // ʤȨʤöֽ + // 胜负加权：获胜方获得额外的评分奖励 if (step_count > 0) { Step last_step = steps[step_count - 1]; if (check_win(last_step.x, last_step.y, last_step.player)) { - // ʤö⽱ + // 获胜方获得额外奖励分数 if (last_step.player == PLAYER || last_step.player == PLAYER1) { - player1_final_score += WIN_BONUS; // ʤ + player1_final_score += WIN_BONUS; // 获胜奖励 } else { - player2_final_score += WIN_BONUS; // ʤ + player2_final_score += WIN_BONUS; // 获胜奖励 } } } - scores_calculated = 1; // Ѽ + scores_calculated = 1; // 标记评分已计算 } /** - * @brief ʾϷֽMVPѡ - * @param game_mode Ϸģʽ(1-˻ս, 2-˫˶ս) + * @brief 显示游戏评分结果和MVP评选 + * @param game_mode 游戏模式(1-人机对战, 2-双人对战) */ void display_game_scores(int game_mode) { - printf("\n===== Ծ =====\n"); + printf("\n===== 对局评分 =====\n"); double sum_score = (long double)player1_final_score + (long double)player2_final_score; if (sum_score > 0) { if (game_mode == 1) { - printf("ҵ÷: %d, ռ: %.2f%%\n", + printf("玩家得分: %d, 占比: %.2f%%\n", player1_final_score, (double)player1_final_score * 100.0 / sum_score); - printf("AI÷: %d, ռ: %.2f%%\n", + printf("AI得分: %d, 占比: %.2f%%\n", player2_final_score, (double)player2_final_score * 100.0 / sum_score); } else { - printf("1()÷: %d, ռ: %.2f%%\n", + printf("玩家1(黑棋)得分: %d, 占比: %.2f%%\n", player1_final_score, (double)player1_final_score * 100.0 / sum_score); - printf("2()÷: %d, ռ: %.2f%%\n", + printf("玩家2(白棋)得分: %d, 占比: %.2f%%\n", player2_final_score, (double)player2_final_score * 100.0 / sum_score); } } @@ -241,41 +241,41 @@ void display_game_scores(int game_mode) { if (game_mode == 1) { - printf("ҵ÷: %d\n", player1_final_score); - printf("AI÷: %d\n", player2_final_score); + printf("玩家得分: %d\n", player1_final_score); + printf("AI得分: %d\n", player2_final_score); } else { - printf("1()÷: %d\n", player1_final_score); - printf("2()÷: %d\n", player2_final_score); + printf("玩家1(黑棋)得分: %d\n", player1_final_score); + printf("玩家2(白棋)得分: %d\n", player2_final_score); } - printf("ע: ˫÷־Ϊ0޷ռ\n"); + printf("注: 双方得分均为0，无法计算占比\n"); } - // ѡMVP + // 评选MVP if (player1_final_score > player2_final_score) { - printf("\nMVP: %s ( %d )\n", (game_mode == 1) ? "" : "1()", player1_final_score - player2_final_score); + printf("\nMVP: %s (领先 %d 分)\n", (game_mode == 1) ? "玩家" : "玩家1(黑棋)", player1_final_score - player2_final_score); } else if (player2_final_score > player1_final_score) { - printf("\nMVP: %s ( %d )\n", (game_mode == 1) ? "AI" : "2()", player2_final_score - player1_final_score); + printf("\nMVP: %s (领先 %d 分)\n", (game_mode == 1) ? "AI" : "玩家2(白棋)", player2_final_score - player1_final_score); } else { - printf("\n˫ƾУ\n"); + printf("\n双方势均力敌！\n"); } } /** - * @brief Ϸļ¼ - * @return int ״̬(0-ɹ, 1-Ŀ¼ʧ, 2-ļʧ, 3-ļдʧ) + * @brief 处理游戏结束后的记录保存 + * @return int 保存状态码(0-成功, 1-目录创建失败, 2-文件打开失败, 3-文件写入失败) */ void handle_save_record(int game_mode) { int save_choice = 0; - printf("===== Ϸ =====\n"); - printf("Ƿ񱣴Ϸ¼? (1-, 0-): "); + printf("===== 游戏结束 =====\n"); + printf("是否保存游戏记录? (1-是, 0-否): "); scanf("%d", &save_choice); if (save_choice == 1) @@ -288,75 +288,75 @@ void handle_save_record(int game_mode) int save_status = save_game_to_file(filename, game_mode); switch (save_status) { - case 0: // ɹ - printf("\nϷ¼ѳɹ: %s (CSVʽ)\n", filename); - printf("ʹи: .\\gobang.exe -l %s\n", filename); - printf("CSVʽļֱExcel򿪲鿴ͷ\n"); + case 0: // 成功 + printf("\n游戏记录已成功保存至: %s (CSV格式)\n", filename); + printf("您可以使用以下命令进行复盘: .\\gobang.exe -l %s\n", filename); + printf("CSV格式文件可以直接用Excel打开查看和分析\n"); break; - case 1: // Ŀ¼ʧ - printf("\nϷ¼ʧ: ޷ 'records' Ŀ¼\n"); - printf("Ƿ㹻дȨ޻̿ռǷ㡣\n"); + case 1: // 目录创建失败 + printf("\n游戏记录保存失败: 无法创建 'records' 目录。\n"); + printf("请检查程序是否具有足够的写入权限或磁盘空间是否充足。\n"); break; - case 2: // ļʧ - printf("\nϷ¼ʧ: ޷· '%s' ļ\n", filename); - printf("·ǷЧԼǷдȨޡ\n"); + case 2: // 文件打开失败 + printf("\n游戏记录保存失败: 无法在路径 '%s' 创建文件。\n", filename); + printf("请检查路径是否有效以及程序是否具有写入权限。\n"); break; - case 3: // ļдʧ - printf("\nϷ¼ʧ: дļʱ\n"); - printf("̿ռǷ\n"); + case 3: // 文件写入失败 + printf("\n游戏记录保存失败: 写入文件时发生错误。\n"); + printf("请检查磁盘空间是否已满。\n"); break; default: - printf("\nϷ¼ʧ: δ֪\n"); + printf("\n游戏记录保存失败: 发生未知错误。\n"); break; } } } /** - * @brief ǰϷ¼浽ļ - * @param filename Ҫļ - * @return int : - * 0: ɹ - * 1: Ŀ¼ʧ - * 2: ļʧ - * 3: ļдʧ + * @brief 将当前游戏记录保存到文件 + * @param filename 要保存的文件名 + * @return int 错误码: + * 0: 成功 + * 1: 目录创建失败 + * 2: 文件打开失败 + * 3: 文件写入失败 */ int save_game_to_file(const char *filename, int game_mode) { - // recordsĿ¼() + // 创建records目录(如果不存在) struct stat st = {0}; if (stat("records", &st) == -1) { if (mkdir("records") != 0) { - // ǷĿ¼Ѵ(߳¿̴ܱ߳) + // 检查是否目录已存在(多线程情况下可能被其他线程创建) if (stat("records", &st) == -1) { #ifdef _WIN32 - printf("޷recordsĿ¼\n"); - printf("ԭ\n"); - printf("1. ûдȨ - 볢ԹԱ\n"); - printf("2. ֹ - 鰲ȫ\n"); - printf("3. ·Ч - 鹤Ŀ¼\n"); + printf("错误：无法创建records目录\n"); + printf("可能原因：\n"); + printf("1. 没有写入权限 - 请尝试以管理员身份运行\n"); + printf("2. 防病毒软件阻止 - 请检查安全软件设置\n"); + printf("3. 路径无效 - 请检查工作目录\n"); #else - perror("Ŀ¼ʧ"); + perror("创建目录失败"); #endif - return 1; // Ŀ¼ʧ + return 1; // 目录创建失败 } } } - // ļ + // 打开文件 char fullpath[256]; snprintf(fullpath, sizeof(fullpath), "records/%s", filename); FILE *file = fopen(fullpath, "w"); if (!file) { - return 2; // ļʧ + return 2; // 文件打开失败 } - // жʤ - strcpy(winner_info, "ƽֻδ"); + // 判断胜负结果 + strcpy(winner_info, "平局或未完成"); if (step_count > 0) { Step last_step = steps[step_count - 1]; @@ -364,72 +364,72 @@ int save_game_to_file(const char *filename, int game_mode) { if (game_mode == 1) { - // ˻ս + // 人机对战 if (last_step.player == PLAYER) { - strcpy(winner_info, "һʤ"); + strcpy(winner_info, "玩家获胜"); } else { - strcpy(winner_info, "AIʤ"); + strcpy(winner_info, "AI获胜"); } } else { - // ˫˶ս + // 双人对战 if (last_step.player == PLAYER1) { - strcpy(winner_info, "1ʤ"); + strcpy(winner_info, "玩家1获胜"); } else { - strcpy(winner_info, "2ʤ"); + strcpy(winner_info, "玩家2获胜"); } } } } - // дCSVļͷ - if (fprintf(file, "Ϸģʽ,̴С,1÷,2÷,Ծֽ\n%d,%d,%d,%d,%s\n\n", game_mode, BOARD_SIZE, player1_final_score, player2_final_score, winner_info) < 0) + // 写入CSV文件头部 + if (fprintf(file, "游戏模式,棋盘大小,玩家1得分,玩家2得分,对局结果\n%d,%d,%d,%d,%s\n\n", game_mode, BOARD_SIZE, player1_final_score, player2_final_score, winner_info) < 0) { fclose(file); - return 3; // ļдʧ + return 3; // 文件写入失败 } - // дCSVͷ - if (fprintf(file, ",,,\n") < 0) + // 写入CSV表头 + if (fprintf(file, "步数,玩家,行坐标,列坐标\n") < 0) { fclose(file); - return 3; // ļдʧ + return 3; // 文件写入失败 } - // дӲ裨CSVʽ + // 写入所有落子步骤（CSV格式） for (int i = 0; i < step_count; i++) { if (fprintf(file, "%d,%d,%d,%d\n", i+1, steps[i].player, steps[i].x+1, steps[i].y+1) < 0) { fclose(file); - return 3; // ļдʧ + return 3; // 文件写入失败 } } if (fclose(file) != 0) { - return 3; // ļر/дʧ + return 3; // 文件关闭/写入失败 } - return 0; // ɹ + return 0; // 成功 } /** - * @brief ļϷ¼ - * @param filename Ҫصļ - * @return true سɹ - * @return false ʧ + * @brief 从文件加载游戏记录 + * @param filename 要加载的文件名 + * @return true 加载成功 + * @return false 加载失败 */ int load_game_from_file(const char *filename) { - // ļ + // 打开文件 char fullpath[256]; snprintf(fullpath, sizeof(fullpath), "records/%s", filename); FILE *file = fopen(fullpath, "r"); @@ -438,28 +438,28 @@ int load_game_from_file(const char *filename) return false; } - // CSVļͷ + // 跳过CSV文件头部行 char buffer[256]; - if (fgets(buffer, sizeof(buffer), file) == NULL) // "Ϸģʽ,̴С" + if (fgets(buffer, sizeof(buffer), file) == NULL) // 跳过"游戏模式,棋盘大小" { fclose(file); return 0; } - // ȡϷģʽ̴Сֽ + // 读取游戏模式、棋盘大小和评分结果 int game_mode, size; - // Զȡ¸ʽʤϢ + // 尝试读取新格式（包含胜负信息） int read_count = fscanf(file, "%d,%d,%d,%d,%49s", &game_mode, &size, &player1_final_score, &player2_final_score, winner_info); if (read_count == 4) { - // ɸʽļûʤϢ - strcpy(winner_info, "δ֪"); + // 旧格式文件，没有胜负信息 + strcpy(winner_info, "未知"); } else if (read_count != 5) { - // ļʽ + // 文件格式错误 fclose(file); return 0; } @@ -467,7 +467,7 @@ int load_game_from_file(const char *filename) if (game_mode != 1 && game_mode != 2) { fclose(file); - return 0; // ЧϷģʽ + return 0; // 无效的游戏模式 } if (size < 5 || size > MAX_BOARD_SIZE) { @@ -475,24 +475,24 @@ int load_game_from_file(const char *filename) return false; } - // Ѽ־ + // 设置评分已计算标志 scores_calculated = 1; - // кͱͷ - fgets(buffer, sizeof(buffer), file); // - fgets(buffer, sizeof(buffer), file); // - fgets(buffer, sizeof(buffer), file); // ",,," + // 跳过空行和表头行 + fgets(buffer, sizeof(buffer), file); // 跳过换行 + fgets(buffer, sizeof(buffer), file); // 跳过空行 + fgets(buffer, sizeof(buffer), file); // 跳过"步数,玩家,行坐标,列坐标" - // ʼ + // 初始化棋盘 BOARD_SIZE = size; empty_board(); - // ȡӲ + // 读取所有落子步骤 step_count = 0; - int step_num; // ڴ洢ʹ + int step_num; // 用于存储步数，但不使用 while (fscanf(file, "%d,%d,%d,%d", &step_num, &steps[step_count].player, &steps[step_count].x, &steps[step_count].y) == 4) { - // 1-basedתΪ0-based + // 将1-based坐标转换为0-based坐标 steps[step_count].x--; steps[step_count].y--; step_count++; diff --git a/record.h b/record.h index c0f0c68..8b29a08 100644 --- a/record.h +++ b/record.h @@ -3,42 +3,42 @@ #include "gobang.h" -// --- ¼ --- +// --- 复盘与记录功能 --- /** - * @brief 븴̣عϷ - * @param game_mode Ϸģʽ1Ϊ˻ս2Ϊ˫˶ս + * @brief 进入复盘流程，回顾整局游戏 + * @param game_mode 游戏模式（1为人机对战，2为双人对战） */ void review_process(int game_mode); /** - * @brief ǰԾּ¼浽ļ - * @param filename Ҫ浽ļ - * @param game_mode Ϸģʽ - * @return 0ʾɹ0ʾʧ + * @brief 将当前对局记录保存到文件 + * @param filename 要保存到的文件名 + * @param game_mode 游戏模式 + * @return 0表示成功，非0表示失败 */ int save_game_to_file(const char *filename, int game_mode); /** - * @brief Ϸ¼߼ - * @param game_mode Ϸģʽ + * @brief 处理保存游戏记录的逻辑 + * @param game_mode 游戏模式 */ void handle_save_record(int game_mode); /** - * @brief ļϷ¼ - * @param filename Ҫصļ - * @return Ϸģʽ120ʾʧ + * @brief 从文件加载游戏记录 + * @param filename 要加载的文件名 + * @return 游戏模式（1或2），0表示失败 */ int load_game_from_file(const char *filename); /** - * @brief Ϸ + * @brief 计算游戏评分 */ void calculate_game_scores(); /** - * @brief ʾϷֽMVPѡ - * @param game_mode Ϸģʽ1-˻ս2-˫˶ս + * @brief 显示游戏评分结果和MVP评选 + * @param game_mode 游戏模式（1-人机对战，2-双人对战） */ void display_game_scores(int game_mode); diff --git a/简介.txt b/简介.txt new file mode 100644 index 0000000..a0ebb23 --- /dev/null +++ b/简介.txt @@ -0,0 +1,76 @@ +/** + * @file 五子棋对战系统 + * @brief C语言五子棋多模式对战系统 + * @details 支持人机对战、双人对战、网络对战的完整五子棋游戏系统 + * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com) + * @date 2025-07-10 + * @version 6.0 + * @note + * 1. v6.0新增功能： + * - 🌐 完整的网络对战模式，支持服务器/客户端架构 + * - 🔗 实时数据同步，支持落子、悔棋、认输、聊天等网络功能 + * - 🛡️ 网络安全验证和连接状态管理 + * - 📡 跨平台网络支持（Windows/Linux） + * - 🔧 全局变量统一管理，优化代码结构 + * - 📋 宏定义统一管理，消除重复定义 + * 2. 核心游戏功能： + * - 增加了对禁手规则的支持，防止玩家进行无意义的走法。 + * - 新增了游戏计时器功能，限制每回合的思考时间。 + * - 添加了复盘功能，支持保存和回顾对局记录。 + * - 实现了评分系统，可以对每一步棋进行评分和分析。 + * 3. 性能优化： + * - 🚀 优化了AI算法，使用Alpha-Beta剪枝提高搜索效率 + * - 🎨 改进了棋盘渲染算法，减少了不必要的重绘操作 + * - 💾 增加了内存管理优化，避免内存泄漏问题 + * - ⚡ 网络通信优化，支持异步消息处理 + * - 🔍 智能评分算法优化，提升AI决策质量 + * 4. 用户界面改进： + * - 🎮 美化了游戏界面，增加了更多的视觉效果 + * - ⌨️ 改进了用户交互体验，增加了快捷键支持 + * - 🔊 添加了音效和背景音乐，提升游戏沉浸感 + * - 💬 网络对战聊天界面，支持实时交流 + * - 📊 游戏状态显示优化，清晰展示连接状态 + * 5. 代码结构优化： + * - 🏗️ 重构了代码架构，提高了代码的可读性和可维护性 + * - 📝 增加了详细的注释和文档，便于理解和修改 + * - 🧩 采用了模块化设计，各功能模块相对独立 + * - 🌍 新增网络模块，完整的网络通信架构 + * - 🔧 全局状态统一管理，消除代码重复 + * - 📋 配置文件标准化，支持灵活配置 + * 6. 异常处理： + * - 🛡️ 增加了输入错误的异常处理机制，确保游戏的稳定性 + * - 💡 优化了错误提示信息，帮助用户快速定位问题 + * - 🔄 增加了程序崩溃恢复功能，提高游戏的可靠性 + * - 🌐 网络连接异常处理，自动重连和超时管理 + * - 📡 消息传输错误处理，确保数据完整性 + * 7. 文档更新： + * - 📚 更新了README文件，提供详细的安装和使用说明 + * - 💬 增加了代码注释，提高代码的可读性 + * - 👨‍💻 添加了开发者文档，便于后续的功能扩展 + * - 🌐 新增网络对战使用指南和配置说明 + * - 🔧 API文档完善，支持二次开发 + * 8. 版本控制： + * - 📦 使用Git进行版本控制，便于代码管理和协作开发 + * - 🚀 建立了清晰的版本发布流程，确保代码质量 + * - 🏷️ v6.0重大版本更新，网络功能里程碑 + * - 📋 完整的变更日志，追踪功能演进 + * 9. 测试： + * - ✅ 进行了全面的功能测试，确保各项功能正常运行 + * - 🧪 增加了单元测试，提高代码的可靠性 + * - ⚡ 进行了性能测试，优化了程序的运行效率 + * - 🌐 网络功能压力测试，确保多人对战稳定性 + * - 🔒 安全性测试，验证网络通信安全 + * 10. 开源协议： + * - 📄 选择了MIT开源协议，允许用户自由使用、修改和分发代码 + * - 🤝 欢迎社区贡献，共同完善项目 + * 11. 贡献者： + * - 👨‍💻 感谢所有为项目做出贡献的开发者和用户 + * - 🌟 特别感谢网络功能开发和测试的贡献者 + * 12. 联系信息： + * - 📧 如有问题或建议，请联系开发者： + * - 3364451258@qq.com + * - 15236416560@163.com + * - lhy3364451258@outlook.com + * - 🐛 Bug报告和功能建议欢迎通过邮件反馈 + * - 💡 网络对战相关问题请详细描述网络环境 + */ \ No newline at end of file