Serendipity/Gobang-Game
1
0
Fork 0
mirror of https://github.com/LHY0125/Gobang-Game.git synced 2026-05-10 02:19:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add files via upload

Browse Source
This commit is contained in:
LHY0125
2025-07-10 13:23:09 +08:00
committed by GitHub
parent 7080797b85
commit cd3f128906
18 changed files with 1647 additions and 633 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ai.c
+103 -110
View File
@@ -1,115 +1,108 @@
#include "gobang.h" #include "gobang.h"
#include "ai.h" #include "ai.h"
#include "config.h" #include "config.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdbool.h> #include <stdbool.h>
// 防守系数
double defense_coefficient = DEFAULT_DEFENSE_COEFFICIENT;
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 评估一个落子位置的综合得分（结合进攻和防守） * @brief 评估一个落子位置的综合得分（结合进攻和防守）
* @param x 行坐标 * @param x 行坐标
* @param y 列坐标 * @param y 列坐标
* @return int 综合得分 * @return int 综合得分
*/ */
int evaluate_move(int x, int y) int evaluate_move(int x, int y)
{ {
// 进攻得分：评估AI在此处落子的分数 // 进攻得分：评估AI在此处落子的分数
int attack_score = evaluate_pos(x, y, AI); int attack_score = evaluate_pos(x, y, AI);
// 防守得分：评估玩家在此处落子的分数，作为防守的依据 // 防守得分：评估玩家在此处落子的分数，作为防守的依据
int defense_score = evaluate_pos(x, y, PLAYER); int defense_score = evaluate_pos(x, y, PLAYER);
// 综合得分，防守权重由 defense_coefficient 控制 // 综合得分，防守权重由 defense_coefficient 控制
return attack_score + (int)(defense_score * defense_coefficient); return attack_score + (int)(defense_score * defense_coefficient);
} }
/** /**
* @brief 评估特定位置对当前玩家的战略价值 * @brief 评估特定位置对当前玩家的战略价值
* @param x 行坐标(0-base) * @param x 行坐标(0-base)
* @param y 列坐标(0-base) * @param y 列坐标(0-base)
* @param player 玩家标识(PLAYER/AI) * @param player 玩家标识(PLAYER/AI)
* @return int 综合评估分数(越高表示位置越好) * @return int 综合评估分数(越高表示位置越好)
* @note 评分标准: * @note 评分标准:
* - 活四:100000 冲四:10000 死四:500 * - 活四:100000 冲四:10000 死四:500
* - 活三:5000 眠三:1000 死三:50 * - 活三:5000 眠三:1000 死三:50
* - 活二:500 眠二:100 死二:10 * - 活二:500 眠二:100 死二:10
* - 单子:50(开放)/10(半开放)/1(封闭) * - 单子:50(开放)/10(半开放)/1(封闭)
* - 中心位置有额外加成 * - 中心位置有额外加成
*/ */
int evaluate_pos(int x, int y, int player) int evaluate_pos(int x, int y, int player)
{ {
// 保存原始值用于还原 // 保存原始值用于还原
int original = board[x][y]; int original = board[x][y];
// 模拟在该位置落子 // 模拟在该位置落子
board[x][y] = player; board[x][y] = player;
int total_score = 0; // 总分 int total_score = 0; // 总分
int line_scores[4] = {0}; // 四个方向的得分 int line_scores[4] = {0}; // 四个方向的得分
// 遍历四个方向进行评估 // 遍历四个方向进行评估
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
int dx = direction[i][0], dy = direction[i][1]; int dx = direction[i][0], dy = direction[i][1];
// 获取当前方向上的棋型信息 // 获取当前方向上的棋型信息
DirInfo info = count_specific_direction(x, y, dx, dy, player); DirInfo info = count_specific_direction(x, y, dx, dy, player);
// 直接形成五连珠为必胜 // 直接形成五连珠为必胜
if (info.continuous_chess >= 5) if (info.continuous_chess >= 5)
{ {
board[x][y] = original; // 还原棋盘 board[x][y] = original; // 还原棋盘
return SEARCH_WIN_BONUS; // 返回最大分 return SEARCH_WIN_BONUS; // 返回最大分
} }
// 根据连续棋子数评分 // 根据连续棋子数评分
switch (info.continuous_chess) switch (info.continuous_chess)
{ {
case 4: // 四连珠 case 4: // 四连珠
if (info.check_start && info.check_end) // 活四(两端开放) if (info.check_start && info.check_end) // 活四(两端开放)
line_scores[i] = AI_SCORE_LIVE_FOUR; 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; line_scores[i] = AI_SCORE_RUSH_FOUR;
else // 死四(两端封闭) else // 死四(两端封闭)
line_scores[i] = AI_SCORE_DEAD_FOUR; line_scores[i] = AI_SCORE_DEAD_FOUR;
break; break;
case 3: // 三连珠 case 3: // 三连珠
if (info.check_start && info.check_end) // 活三 if (info.check_start && info.check_end) // 活三
line_scores[i] = AI_SCORE_LIVE_THREE; 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; line_scores[i] = AI_SCORE_SLEEP_THREE;
else // 死三 else // 死三
line_scores[i] = AI_SCORE_DEAD_THREE; line_scores[i] = AI_SCORE_DEAD_THREE;
break; break;
case 2: // 二连珠 case 2: // 二连珠
if (info.check_start && info.check_end) // 活二 if (info.check_start && info.check_end) // 活二
line_scores[i] = AI_SCORE_LIVE_TWO; 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; line_scores[i] = AI_SCORE_SLEEP_TWO;
else // 死二 else // 死二
line_scores[i] = AI_SCORE_DEAD_TWO; line_scores[i] = AI_SCORE_DEAD_TWO;
break; break;
case 1: // 单子 case 1: // 单子
if (info.check_start && info.check_end) // 开放位置 if (info.check_start && info.check_end) // 开放位置
line_scores[i] = AI_SCORE_LIVE_ONE; 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; line_scores[i] = AI_SCORE_HALF_ONE;
else // 封闭位置 else // 封闭位置
line_scores[i] = AI_SCORE_DEAD_ONE; line_scores[i] = AI_SCORE_DEAD_ONE;
break; break;
} }
} }
// 计算总分（最高方向分+其他方向分加权） // 计算总分（最高方向分+其他方向分加权）
int max_score = 0; int max_score = 0;
int sum_score = 0; int sum_score = 0;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
@@ -120,44 +113,44 @@ int evaluate_pos(int x, int y, int player)
} }
sum_score += line_scores[i]; 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_x = BOARD_SIZE / 2;
int center_y = BOARD_SIZE / 2; int center_y = BOARD_SIZE / 2;
int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离 int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离
int position_bonus = AI_POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高 int position_bonus = AI_POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高
board[x][y] = original; // 还原棋盘状态 board[x][y] = original; // 还原棋盘状态
return total_score + position_bonus; // 返回总评估分 return total_score + position_bonus; // 返回总评估分
} }
/** /**
* @brief 带α-β剪枝的深度优先搜索(极小极大算法实现) * @brief 带α-β剪枝的深度优先搜索(极小极大算法实现)
* @param x 当前行坐标 * @param x 当前行坐标
* @param y 当前列坐标 * @param y 当前列坐标
* @param player 当前玩家 * @param player 当前玩家
* @param depth 剩余搜索深度 * @param depth 剩余搜索深度
* @param alpha α值(当前最大值) * @param alpha α值(当前最大值)
* @param beta β值(当前最小值) * @param beta β值(当前最小值)
* @param is_maximizing 是否为极大化玩家(AI) * @param is_maximizing 是否为极大化玩家(AI)
* @return int 最佳评估分数 * @return int 最佳评估分数
* @note 算法流程: * @note 算法流程:
* 1. 检查是否获胜或达到搜索深度 * 1. 检查是否获胜或达到搜索深度
* 2. 遍历所有可能落子位置 * 2. 遍历所有可能落子位置
* 3. 递归评估每个位置的分数 * 3. 递归评估每个位置的分数
* 4. 根据is_maximizing选择最大/最小值 * 4. 根据is_maximizing选择最大/最小值
* 5. 使用α-β剪枝优化搜索过程 * 5. 使用α-β剪枝优化搜索过程
*/ */
int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing) int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing)
{ {
// 检查当前落子是否获胜 // 检查当前落子是否获胜
if (check_win(x, y, player)) if (check_win(x, y, player))
{ {
return (player == AI) ? SEARCH_WIN_BONUS + depth : -SEARCH_WIN_BONUS - depth; return (player == AI) ? SEARCH_WIN_BONUS + depth : -SEARCH_WIN_BONUS - depth;
} }
// 达到搜索深度或平局 // 达到搜索深度或平局
if (depth == 0 || step_count >= BOARD_SIZE * BOARD_SIZE) if (depth == 0 || step_count >= BOARD_SIZE * BOARD_SIZE)
{ {
return evaluate_pos(x, y, AI) - evaluate_pos(x, y, PLAYER); return evaluate_pos(x, y, AI) - evaluate_pos(x, y, PLAYER);
@@ -165,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; int best_score = is_maximizing ? -1000000 : 1000000;
// 遍历所有可能落子位置 // 遍历所有可能落子位置
for (int i = 0; i < BOARD_SIZE; i++) for (int i = 0; i < BOARD_SIZE; i++)
{ {
for (int j = 0; j < BOARD_SIZE; j++) for (int j = 0; j < BOARD_SIZE; j++)
@@ -175,34 +168,34 @@ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximi
continue; continue;
} }
// 模拟当前玩家落子 // 模拟当前玩家落子
board[i][j] = player; board[i][j] = player;
step_count++; step_count++;
// 递归搜索(切换玩家和搜索深度) // 递归搜索(切换玩家和搜索深度)
int current_score = dfs(i, j, (player == AI) ? PLAYER : AI, depth - 1, alpha, beta, !is_maximizing); int current_score = dfs(i, j, (player == AI) ? PLAYER : AI, depth - 1, alpha, beta, !is_maximizing);
// 撤销落子 // 撤销落子
board[i][j] = EMPTY; board[i][j] = EMPTY;
step_count--; step_count--;
// 极大值玩家(AI)逻辑 // 极大值玩家(AI)逻辑
if (is_maximizing) if (is_maximizing)
{ {
best_score = (current_score > best_score) ? current_score : best_score; best_score = (current_score > best_score) ? current_score : best_score;
alpha = (best_score > alpha) ? best_score : alpha; alpha = (best_score > alpha) ? best_score : alpha;
// α剪枝 // α剪枝
if (beta <= alpha) if (beta <= alpha)
{ {
break; break;
} }
} }
// 极小值玩家(人类)逻辑 // 极小值玩家(人类)逻辑
else else
{ {
best_score = (current_score < best_score) ? current_score : best_score; best_score = (current_score < best_score) ? current_score : best_score;
beta = (best_score < beta) ? best_score : beta; beta = (best_score < beta) ? best_score : beta;
// β剪枝 // β剪枝
if (beta <= alpha) if (beta <= alpha)
{ {
break; break;
@@ -211,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)) if ((is_maximizing && best_score >= beta) || (!is_maximizing && best_score <= alpha))
{ {
break; // 提前退出外层循环 break; // 提前退出外层循环
} }
} }
@@ -219,28 +212,28 @@ int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximi
} }
/** /**
* @brief AI决策主函数，使用评估函数和搜索算法选择最佳落子位置 * @brief AI决策主函数，使用评估函数和搜索算法选择最佳落子位置
* @note 采用两阶段决策逻辑： * @note 采用两阶段决策逻辑：
* 1. 防御阶段：检查并阻止玩家即将获胜的位置（活四、冲四、活三） * 1. 防御阶段：检查并阻止玩家即将获胜的位置（活四、冲四、活三）
* 2. 进攻阶段：若无紧急防御需求，使用评估函数选择最佳进攻位置 * 2. 进攻阶段：若无紧急防御需求，使用评估函数选择最佳进攻位置
* @note 实现细节： * @note 实现细节：
* - 优先处理玩家活四、冲四等危险局面 * - 优先处理玩家活四、冲四等危险局面
* - 步数>AI_SEARCH_RANGE_THRESHOLD时缩小搜索范围到已有棋子附近AI_NEARBY_RANGE格 * - 步数>AI_SEARCH_RANGE_THRESHOLD时缩小搜索范围到已有棋子附近AI_NEARBY_RANGE格
* - 使用中心位置优先策略 * - 使用中心位置优先策略
*/ */
void ai_move(int depth) void ai_move(int depth)
{ {
// 如果是第一步，直接下在中心位置附近 // 如果是第一步，直接下在中心位置附近
if (step_count == 0) if (step_count == 0)
{ {
int center = BOARD_SIZE / 2; int center = BOARD_SIZE / 2;
board[center][center] = AI; board[center][center] = AI;
steps[step_count++] = (Step){AI, center, center}; 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; return;
} }
// 1. 首先检查是否需要阻止玩家的四子连棋或三子活棋 // 1. 首先检查是否需要阻止玩家的四子连棋或三子活棋
for (int i = 0; i < BOARD_SIZE; i++) for (int i = 0; i < BOARD_SIZE; i++)
{ {
for (int j = 0; j < BOARD_SIZE; j++) for (int j = 0; j < BOARD_SIZE; j++)
@@ -250,23 +243,23 @@ void ai_move(int depth)
continue; continue;
} }
// 模拟玩家在此位置落子 // 模拟玩家在此位置落子
board[i][j] = PLAYER; board[i][j] = PLAYER;
bool need_block = false; bool need_block = false;
// 检查四个方向 // 检查四个方向
for (int k = 0; k < 4; k++) for (int k = 0; k < 4; k++)
{ {
DirInfo info = count_specific_direction(i, j, direction[k][0], direction[k][1], PLAYER); 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)) if (info.continuous_chess >= 4 && (info.check_start || info.check_end))
{ {
need_block = true; need_block = true;
break; break;
} }
// 如果玩家能形成三子活棋且两端开放 // 如果玩家能形成三子活棋且两端开放
if (info.continuous_chess == 3 && info.check_start && info.check_end) if (info.continuous_chess == 3 && info.check_start && info.check_end)
{ {
need_block = true; need_block = true;
@@ -274,24 +267,24 @@ void ai_move(int depth)
} }
} }
board[i][j] = EMPTY; // 恢复棋盘 board[i][j] = EMPTY; // 恢复棋盘
if (need_block) if (need_block)
{ {
// 必须在此位置落子阻止 // 必须在此位置落子阻止
board[i][j] = AI; board[i][j] = AI;
steps[step_count++] = (Step){AI, i, j}; 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; return;
} }
} }
} }
// 2. 如果没有需要立即阻止的情况，则正常评估 // 2. 如果没有需要立即阻止的情况，则正常评估
int best_score = -SEARCH_WIN_BONUS; int best_score = -SEARCH_WIN_BONUS;
int best_x = -1, best_y = -1; int best_x = -1, best_y = -1;
// 遍历棋盘所有空位 // 遍历棋盘所有空位
for (int i = 0; i < BOARD_SIZE; i++) for (int i = 0; i < BOARD_SIZE; i++)
{ {
for (int j = 0; j < BOARD_SIZE; j++) for (int j = 0; j < BOARD_SIZE; j++)
@@ -301,7 +294,7 @@ void ai_move(int depth)
continue; continue;
} }
// 只考虑已有棋子附近(AI_NEARBY_RANGE格范围内) // 只考虑已有棋子附近(AI_NEARBY_RANGE格范围内)
bool has_nearby_stone = false; bool has_nearby_stone = false;
for (int di = -AI_NEARBY_RANGE; di <= AI_NEARBY_RANGE; di++) for (int di = -AI_NEARBY_RANGE; di <= AI_NEARBY_RANGE; di++)
{ {
@@ -328,10 +321,10 @@ void ai_move(int depth)
continue; continue;
} }
// 使用评估函数获取综合得分 // 使用评估函数获取综合得分
int current_score = evaluate_move(i, j); int current_score = evaluate_move(i, j);
// 更新最佳位置 // 更新最佳位置
if (current_score > best_score) if (current_score > best_score)
{ {
best_score = current_score; best_score = current_score;
@@ -341,11 +334,11 @@ void ai_move(int depth)
} }
} }
// 执行最佳落子 // 执行最佳落子
if (best_x != -1 && best_y != -1) if (best_x != -1 && best_y != -1)
{ {
board[best_x][best_y] = AI; board[best_x][best_y] = AI;
steps[step_count++] = (Step){AI, best_x, best_y}; 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);
} }
} }
ai.h
+12 -15
View File
@@ -3,37 +3,34 @@
#include "gobang.h" #include "gobang.h"
// 防守系数
extern double defense_coefficient;
/** /**
* @brief 评估一个落子位置的综合得分（结合进攻和防守） * @brief 评估一个落子位置的综合得分（结合进攻和防守）
* *
* @param x 行坐标 * @param x 行坐标
* @param y 列坐标 * @param y 列坐标
* @return int 综合得分 * @return int 综合得分
*/ */
int evaluate_move(int x, int y); int evaluate_move(int x, int y);
/** /**
* @brief 评估指定位置的价值 * @brief 评估指定位置的价值
* *
* @param x 位置x坐标 * @param x 位置x坐标
* @param y 位置y坐标 * @param y 位置y坐标
* @param player 玩家标识(PLAYER/AI) * @param player 玩家标识(PLAYER/AI)
* @return int 位置价值 * @return int 位置价值
*/ */
int evaluate_pos(int x, int y, int player); 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); int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing);
/** /**
* @brief AI下棋 * @brief AI下棋
* *
* @param depth * @param depth
*/ */
config.c
+80 -4
View File
@@ -1,12 +1,11 @@
#include "config.h" #include "config.h"
#include "ui.h" #include "ui.h"
#include "game_mode.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
// 配置文件路径
#define CONFIG_FILE "gobang_config.ini"
/** /**
* @brief 加载游戏配置 * @brief 加载游戏配置
*/ */
@@ -47,6 +46,22 @@ void load_game_config()
{ {
time_limit = atoi(line + 11); time_limit = atoi(line + 11);
} }
else if (strncmp(line, "NETWORK_PORT=", 13) == 0)
{
int port = atoi(line + 13);
if (port >= MIN_NETWORK_PORT && port <= MAX_NETWORK_PORT)
{
network_port = port;
}
}
else if (strncmp(line, "NETWORK_TIMEOUT=", 16) == 0)
{
int timeout = atoi(line + 16);
if (timeout > 0)
{
network_timeout = timeout;
}
}
else if (strncmp(line, "AI_DIFFICULTY=", 14) == 0) else if (strncmp(line, "AI_DIFFICULTY=", 14) == 0)
{ {
int difficulty = atoi(line + 14); int difficulty = atoi(line + 14);
@@ -83,6 +98,10 @@ void save_game_config()
fprintf(file, "USE_TIMER=%d\n", use_timer); fprintf(file, "USE_TIMER=%d\n", use_timer);
fprintf(file, "\n# 时间限制 (分钟)\n"); fprintf(file, "\n# 时间限制 (分钟)\n");
fprintf(file, "TIME_LIMIT=%d\n", time_limit); fprintf(file, "TIME_LIMIT=%d\n", time_limit);
fprintf(file, "\n# 网络端口 (范围: %d-%d)\n", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
fprintf(file, "NETWORK_PORT=%d\n", network_port);
fprintf(file, "\n# 网络超时时间 (毫秒)\n");
fprintf(file, "NETWORK_TIMEOUT=%d\n", network_timeout);
fclose(file); fclose(file);
printf("配置保存完成\n"); printf("配置保存完成\n");
@@ -97,6 +116,8 @@ void reset_to_default_config()
use_forbidden_moves = DEFAULT_USE_FORBIDDEN_MOVES; use_forbidden_moves = DEFAULT_USE_FORBIDDEN_MOVES;
use_timer = DEFAULT_USE_TIMER; use_timer = DEFAULT_USE_TIMER;
time_limit = DEFAULT_TIME_LIMIT; time_limit = DEFAULT_TIME_LIMIT;
network_port = DEFAULT_NETWORK_PORT;
network_timeout = NETWORK_TIMEOUT_MS;
printf("已重置为默认配置\n"); printf("已重置为默认配置\n");
} }
@@ -114,6 +135,8 @@ void display_current_config()
{ {
printf("时间限制: %d 分钟\n", time_limit / 60); printf("时间限制: %d 分钟\n", time_limit / 60);
} }
printf("网络端口: %d\n", network_port);
printf("网络超时: %d 毫秒\n", network_timeout);
printf("=====================\n"); printf("=====================\n");
} }
@@ -206,6 +229,56 @@ void config_timer()
} }
} }
/**
* @brief 配置网络参数
*/
void config_network()
{
printf("\n===== 网络配置 =====\n");
printf("当前网络端口: %d\n", network_port);
printf("当前网络超时: %d 毫秒\n", network_timeout);
printf("\n请输入新的网络端口 (%d-%d): ", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
int new_port;
if (scanf("%d", &new_port) == 1)
{
if (new_port >= MIN_NETWORK_PORT && new_port <= MAX_NETWORK_PORT)
{
network_port = new_port;
printf("网络端口已设置为: %d\n", network_port);
}
else
{
printf("无效的端口号！端口范围: %d-%d\n", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
}
}
else
{
printf("输入格式错误！\n");
while (getchar() != '\n');
}
printf("\n请输入网络超时时间(毫秒, 建议1000-10000): ");
int new_timeout;
if (scanf("%d", &new_timeout) == 1)
{
if (new_timeout > 0)
{
network_timeout = new_timeout;
printf("网络超时已设置为: %d 毫秒\n", network_timeout);
}
else
{
printf("无效的超时时间！\n");
}
}
else
{
printf("输入格式错误！\n");
while (getchar() != '\n');
}
}
/** /**
* @brief 配置管理主菜单 * @brief 配置管理主菜单
*/ */
@@ -240,9 +313,12 @@ void config_management_menu()
config_timer(); config_timer();
break; break;
case 4: case 4:
printf("AI难度设置功能开发中...\n"); config_network();
break; break;
case 5: case 5:
printf("AI难度设置功能开发中...\n");
break;
case 6:
save_game_config(); save_game_config();
return; return;
default: default:
config.h
+95 -80
View File
@@ -1,136 +1,151 @@
/** /**
* @file config.h * @file config.h
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com) * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
* @brief 五子棋游戏参数配置头文件 * @brief 五子棋游戏参数配置头文件
* @version 5.0 * @version 6.0
* @date 2025-07-10 * @date 2025-07-10
* *
* @copyright Copyright (c) 2025 * @copyright Copyright (c) 2025
* *
* @note 本文件集中定义了五子棋游戏的所有参数配置，便于统一管理和修改 * @note 本文件集中定义了五子棋游戏的所有参数配置，便于统一管理和修改
*/ */
#ifndef CONFIG_H #ifndef CONFIG_H
#define CONFIG_H #define CONFIG_H
//---------- 棋盘相关参数 ----------// //---------- 棋盘相关参数 ----------//
#define MAX_BOARD_SIZE 25 // 支持的最大棋盘尺寸 #define MAX_BOARD_SIZE 25 // 支持的最大棋盘尺寸
#define MIN_BOARD_SIZE 5 // 支持的最小棋盘尺寸 #define MIN_BOARD_SIZE 5 // 支持的最小棋盘尺寸
#define DEFAULT_BOARD_SIZE 15 // 默认棋盘尺寸 #define DEFAULT_BOARD_SIZE 15 // 默认棋盘尺寸
#define MAX_STEPS (MAX_BOARD_SIZE * MAX_BOARD_SIZE) // 游戏最大步数 #define MAX_STEPS (MAX_BOARD_SIZE * MAX_BOARD_SIZE) // 游戏最大步数
//---------- 玩家标识参数 ----------// //---------- 玩家标识参数 ----------//
#define EMPTY 0 // 棋盘空位标识 #define EMPTY 0 // 棋盘空位标识
#define PLAYER 1 // 玩家标识 (用于人机对战模式) #define PLAYER 1 // 玩家标识 (用于人机对战模式)
#define AI 2 // AI标识 (用于人机对战模式) #define AI 2 // AI标识 (用于人机对战模式)
#define PLAYER1 1 // 玩家1标识 (用于双人对战模式) #define PLAYER1 1 // 玩家1标识 (用于双人对战模式)
#define PLAYER2 2 // 玩家2标识 (用于双人对战模式) #define PLAYER2 2 // 玩家2标识 (用于双人对战模式)
//---------- 特殊输入命令 ----------// //---------- 特殊输入命令 ----------//
#define INPUT_UNDO -1 // 悔棋 #define INPUT_UNDO -1 // 悔棋
#define INPUT_SAVE -2 // 保存 #define INPUT_SAVE -2 // 保存
#define INPUT_EXIT -3 // 退出 #define INPUT_EXIT -3 // 退出
#define INPUT_SURRENDER -4 // 认输 #define INPUT_SURRENDER -4 // 认输
//---------- 游戏设置默认值 ----------// //---------- 游戏设置默认值 ----------//
#define DEFAULT_USE_FORBIDDEN_MOVES false // 默认不启用禁手规则 #define DEFAULT_USE_FORBIDDEN_MOVES false // 默认不启用禁手规则
#define DEFAULT_USE_TIMER 0 // 默认不启用计时器 #define DEFAULT_USE_TIMER 0 // 默认不启用计时器
#define DEFAULT_TIME_LIMIT 30 // 默认时间限制为30秒(内部存储) #define DEFAULT_TIME_LIMIT 30 // 默认时间限制为30秒(内部存储)
//---------- AI参数 ----------// //---------- AI参数 ----------//
#define DEFAULT_AI_DEPTH 3 // 默认AI搜索深度 #define DEFAULT_AI_DEPTH 3 // 默认AI搜索深度
#define DEFAULT_DEFENSE_COEFFICIENT 1.2 // 默认防守系数 #define DEFAULT_DEFENSE_COEFFICIENT 1.2 // 默认防守系数
//---------- 评分参数 ----------// //---------- 网络参数 ----------//
// 棋型评分 - 用于calculate_step_score函数 #define DEFAULT_NETWORK_PORT 8888 // 默认网络端口
#define SCORE_FIVE 0 // 五连 #define MIN_NETWORK_PORT 1024 // 最小网络端口
#define SCORE_LIVE_FOUR 2000 // 活四 #define MAX_NETWORK_PORT 65535 // 最大网络端口
#define SCORE_RUSH_FOUR 1000 // 冲四 #define NETWORK_TIMEOUT_MS 5000 // 网络超时时间(毫秒)
#define SCORE_DEAD_FOUR 300 // 死四 #define NETWORK_BUFFER_SIZE 1024 // 网络缓冲区大小
#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 // 位置奖励因子 // 棋型评分 - 用于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 // 封闭单子
// AI评估参数 - 用于evaluate_pos函数 // 位置奖励系数
#define AI_SCORE_FIVE 1000000 // AI评估-五连 #define POSITION_BONUS_FACTOR 10 // 位置奖励因子
#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位置奖励系数 // AI评估参数 - 用于evaluate_pos函数
#define AI_POSITION_BONUS_FACTOR 50 // AI位置奖励因子 #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 SEARCH_MAX_SCORE 1000000 // 搜索最大分数 #define AI_POSITION_BONUS_FACTOR 50 // AI位置奖励因子
#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 SEARCH_MAX_SCORE 1000000 // 搜索最大分数
#define WIN_BONUS 2000 // 胜利奖励分数 #define SEARCH_WIN_BONUS 1000000 // 获胜奖励分数
#define AI_NEARBY_RANGE 2 // AI搜索的邻近范围
#define AI_SEARCH_RANGE_THRESHOLD 10 // AI开始限制搜索范围的步数阈值
// 文件路径参数 // 评分权重参数
#define RECORDS_DIR "records" // 记录文件目录 #define TIME_WEIGHT_FACTOR 0.5 // 时间权重因子
#define MAX_PATH_LENGTH 256 // 最大路径长度 #define WIN_BONUS 2000 // 胜利奖励分数
//---------- 配置管理函数声明 ----------// // 文件路径参数
#define RECORDS_DIR "records" // 记录文件目录
#define CONFIG_FILE "gobang_config.ini" // 配置文件路径
#define MAX_PATH_LENGTH 256 // 最大路径长度
//---------- 配置管理函数声明 ----------//
/** /**
* @brief 加载游戏配置 * @brief 加载游戏配置
*/ */
void load_game_config(); void load_game_config();
/** /**
* @brief 保存游戏配置 * @brief 保存游戏配置
*/ */
void save_game_config(); void save_game_config();
/** /**
* @brief 重置为默认配置 * @brief 重置为默认配置
*/ */
void reset_to_default_config(); void reset_to_default_config();
/** /**
* @brief 显示当前配置 * @brief 显示当前配置
*/ */
void display_current_config(); void display_current_config();
/** /**
* @brief 配置棋盘大小 * @brief 配置棋盘大小
*/ */
void config_board_size(); void config_board_size();
/** /**
* @brief 配置禁手规则 * @brief 配置禁手规则
*/ */
void config_forbidden_moves(); void config_forbidden_moves();
/** /**
* @brief 配置计时器 * @brief 配置计时器
*/ */
void config_timer(); void config_timer();
/** /**
* @brief 配置管理主菜单 * @brief 配置网络参数
*/
void config_network();
/**
* @brief 配置管理主菜单
*/ */
void config_management_menu(); void config_management_menu();
//---------- 网络配置全局变量声明 ----------// 全局变量声明现在在globals.h中
#endif // CONFIG_H #endif // CONFIG_H
game_mode.c
+238 -2
View File
@@ -4,13 +4,15 @@
#include "ai.h" #include "ai.h"
#include "record.h" #include "record.h"
#include "config.h" #include "config.h"
#include "network.h"
#include "ui.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/stat.h> #include <sys/stat.h>
// 引用record.h中定义的全局变量 // 全局变量现在在globals.c中定义
extern int scores_calculated;
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
#include <direct.h> #include <direct.h>
@@ -425,3 +427,237 @@ void run_review_mode()
printf("加载复盘文件失败！可能是旧版本文件格式或文件损坏\n"); printf("加载复盘文件失败！可能是旧版本文件格式或文件损坏\n");
} }
} }
/**
* @brief 网络对战模式
*/
void run_network_game()
{
// 重置评分计算标志
scores_calculated = 0;
// 初始化网络模块
if (!init_network()) {
printf("网络初始化失败！\n");
pause_for_input("按任意键返回主菜单...");
return;
}
printf("=== 网络对战模式 ===\n");
printf("1. 创建房间（作为主机）\n");
printf("2. 加入房间（连接到主机）\n");
int choice = get_integer_input("请选择模式(1-2): ", 1, 2);
bool connection_success = false;
if (choice == 1) {
// 服务器模式
int port = get_integer_input("请输入监听端口(默认8888): ", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
if (port == 0) port = network_port;
printf("\n正在创建房间...\n");
connection_success = create_server(port);
} else {
// 客户端模式
char ip[MAX_IP_LENGTH];
printf("请输入服务器IP地址: ");
scanf("%s", ip);
int port = get_integer_input("请输入服务器端口(默认8888): ", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
if (port == 0) port = network_port;
printf("\n正在连接到服务器...\n");
connection_success = connect_to_server(ip, port);
}
if (!connection_success) {
printf("网络连接失败！\n");
cleanup_network();
pause_for_input("按任意键返回主菜单...");
return;
}
printf("\n网络连接成功！游戏即将开始...\n");
printf("你是玩家%d，%s先手\n",
network_state.local_player_id,
network_state.local_player_id == PLAYER1 ? "你" : "对方");
// 开始网络游戏
empty_board();
print_board();
if (network_game_loop()) {
printf("===== 游戏结束 =====\n");
review_process(2); // 使用PvP模式的复盘
handle_save_record(2); // 保存为PvP模式记录
} else {
printf("游戏因网络错误而结束\n");
}
// 清理网络连接
disconnect_network();
pause_for_input("按任意键返回主菜单...");
}
/**
* @brief 处理网络玩家回合
*/
bool handle_network_player_turn(int current_player, bool is_local_turn)
{
if (is_local_turn) {
// 本地玩家回合
int x, y;
time_t start_time, end_time;
if (use_timer) {
time(&start_time);
}
printf("\n轮到你了，请输入落子坐标(行 列，1~%d)，或输入R/r悔棋，S/s认输: ", BOARD_SIZE);
while (1) {
if (use_timer) {
time(&end_time);
if (difftime(end_time, start_time) > time_limit) {
printf("\n你超时了，对方获胜！\n");
send_surrender(); // 发送认输消息
return false;
}
}
if (parse_player_input(&x, &y)) {
if (x == INPUT_SURRENDER) {
printf("\n你选择认输，对方获胜！\n");
send_surrender();
return false;
}
break;
} else {
// 处理特殊命令或继续等待输入
continue;
}
}
x--; y--; // 转换为0-based坐标
if (!player_move(x, y, current_player)) {
printf("坐标无效！请重新输入。\n");
return true; // 继续当前回合
}
// 发送落子消息
if (!send_move(x, y, current_player)) {
printf("发送落子消息失败！\n");
return false;
}
print_board();
if (check_win(x, y, current_player)) {
printf("\n你获胜了！\n");
return false;
}
} else {
// 等待对方落子
printf("\n等待对方落子...\n");
NetworkMessage msg;
time_t start_time = time(NULL);
while (1) {
if (receive_network_message(&msg, 1000)) { // 1秒超时
if (msg.type == MSG_MOVE && msg.player_id == current_player) {
// 收到落子消息
if (!player_move(msg.x, msg.y, current_player)) {
printf("收到无效的落子坐标！\n");
return false;
}
printf("对方落子: (%d, %d)\n", msg.x + 1, msg.y + 1);
print_board();
if (check_win(msg.x, msg.y, current_player)) {
printf("\n对方获胜！\n");
return false;
}
break;
} else if (msg.type == MSG_SURRENDER) {
printf("\n对方认输，你获胜了！\n");
return false;
} else if (msg.type == MSG_DISCONNECT) {
printf("\n对方已断开连接\n");
return false;
} else if (msg.type == MSG_CHAT) {
printf("[对方]: %s\n", msg.message);
} else if (msg.type == MSG_UNDO_REQUEST) {
int steps = msg.x;
printf("\n对方请求悔棋 %d 步，是否同意？(1:同意/0:拒绝): ", steps);
int response = get_integer_input("", 0, 1);
if (response && return_move(steps * 2)) {
printf("同意悔棋，双方各退 %d 步\n", steps);
send_undo_response(true, steps);
print_board();
return true; // 继续游戏
} else {
printf("拒绝悔棋\n");
send_undo_response(false, steps);
}
}
}
// 检查超时
if (use_timer && difftime(time(NULL), start_time) > time_limit) {
printf("\n对方超时，你获胜！\n");
return false;
}
// 检查网络连接
if (!is_network_connected()) {
printf("\n网络连接断开\n");
return false;
}
}
}
return true;
}
/**
* @brief 网络游戏主循环
*/
bool network_game_loop()
{
int current_player = PLAYER1; // 总是从玩家1开始
while (1) {
bool is_local_turn = (current_player == network_state.local_player_id);
if (!handle_network_player_turn(current_player, is_local_turn)) {
return true; // 游戏结束
}
// 检查平局
if (step_count == BOARD_SIZE * BOARD_SIZE) {
printf("\n平局！\n");
return true;
}
// 切换玩家
current_player = (current_player == PLAYER1) ? PLAYER2 : PLAYER1;
// 检查网络连接
if (!is_network_connected()) {
printf("\n网络连接断开\n");
return false;
}
}
return true;
}
game_mode.h
+26 -8
View File
@@ -7,22 +7,18 @@
* *
* @copyright Copyright (c) 2025 * @copyright Copyright (c) 2025
* *
* @note 本文件定义了五子棋游戏的三种主要模式： * @note 本文件定义了五子棋游戏的四种主要模式：
* 1. AI对战模式 * 1. AI对战模式
* 2. 双人对战模式 * 2. 双人对战模式
* 3. 复盘模式 * 3. 网络对战模式
* 4. 复盘模式
*/ */
#ifndef GAME_MODE_H #ifndef GAME_MODE_H
#define GAME_MODE_H #define GAME_MODE_H
#include "gobang.h" #include "gobang.h"
#include "config.h"
// 特殊输入命令
#define INPUT_UNDO -1 // 悔棋
#define INPUT_SAVE -2 // 保存
#define INPUT_EXIT -3 // 退出
#define INPUT_SURRENDER -4 // 认输
/** /**
* @brief 从用户获取整数输入 * @brief 从用户获取整数输入
@@ -69,4 +65,26 @@ void run_pvp_game();
*/ */
void run_review_mode(); void run_review_mode();
/**
* @brief 网络对战模式
* 实现两台设备之间的在线对战
*/
void run_network_game();
/**
* @brief 处理网络玩家回合
* @param current_player 当前玩家
* @param is_local_turn 是否为本地玩家回合
* @return true 回合处理成功
* @return false 游戏结束或网络错误
*/
bool handle_network_player_turn(int current_player, bool is_local_turn);
/**
* @brief 网络游戏主循环
* @return true 游戏正常结束
* @return false 网络错误或异常退出
*/
bool network_game_loop();
#endif // GAME_MODE_H #endif // GAME_MODE_H
globals.c
+37
View File
@@ -0,0 +1,37 @@
/**
* @file globals.c
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
* @brief 全局变量定义和初始化文件
* @version 6.0
* @date 2025-07-10
* @note 集中管理所有全局变量的定义和初始化，提高代码可维护性
*/
#include "globals.h"
#include "config.h"
// ==================== 游戏核心变量定义 ====================
int BOARD_SIZE = DEFAULT_BOARD_SIZE; // 实际使用的棋盘尺寸
int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE] = {0}; // 棋盘状态存储数组(默认棋盘全空为0)
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 = DEFAULT_USE_FORBIDDEN_MOVES; // 是否启用禁手规则
int use_timer = DEFAULT_USE_TIMER; // 是否启用计时器
int time_limit = DEFAULT_TIME_LIMIT; // 每回合的时间限制（秒）
int network_port = DEFAULT_NETWORK_PORT; // 网络端口
int network_timeout = NETWORK_TIMEOUT_MS; // 网络超时时间
// ==================== AI相关变量定义 ====================
double defense_coefficient = DEFAULT_DEFENSE_COEFFICIENT; // 防守系数
// ==================== 网络相关变量定义 ====================
NetworkGameState network_state = {0}; // 网络游戏状态
// ==================== 记录相关变量定义 ====================
int player1_final_score = 0; // 玩家1最终得分
int player2_final_score = 0; // 玩家2最终得分
int scores_calculated = 0; // 评分计算标志
char winner_info[50] = "平局或未完成"; // 存储胜负信息
globals.h
+43
View File
@@ -0,0 +1,43 @@
/**
* @file globals.h
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
* @brief 全局变量声明头文件
* @version 6.0
* @date 2025-07-10
* @note 集中管理所有全局变量的声明，提高代码可维护性
*/
#ifndef GLOBALS_H
#define GLOBALS_H
#include "gobang.h"
#include "network.h"
#include <stdbool.h>
// ==================== 游戏核心变量 ====================
extern int BOARD_SIZE; // 当前实际使用的棋盘尺寸
extern int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE]; // 棋盘状态存储数组
extern Step steps[MAX_STEPS]; // 存储所有落子步骤的数组
extern const int direction[4][2]; // 四个方向：向下、向右、右下、左下
extern int step_count; // 当前步数计数器
// ==================== 游戏配置变量 ====================
extern bool use_forbidden_moves; // 是否启用禁手规则的标志
extern int use_timer; // 是否启用计时器的标志
extern int time_limit; // 每回合的时间限制（秒，内部存储）
extern int network_port; // 网络端口
extern int network_timeout; // 网络超时时间
// ==================== AI相关变量 ====================
extern double defense_coefficient; // 防守系数
// ==================== 网络相关变量 ====================
extern NetworkGameState network_state; // 网络游戏状态
// ==================== 记录相关变量 ====================
extern int player1_final_score; // 玩家1最终得分
extern int player2_final_score; // 玩家2最终得分
extern int scores_calculated; // 评分计算标志
extern char winner_info[50]; // 存储胜负信息
#endif // GLOBALS_H
gobang.c
+76 -85
View File
@@ -4,34 +4,25 @@
#include "ai.h" #include "ai.h"
#include "record.h" #include "record.h"
#include "config.h" #include "config.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <time.h> #include <time.h>
// 全局变量定义
int BOARD_SIZE = DEFAULT_BOARD_SIZE; // 实际使用的棋盘尺寸
int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE] = {0}; // 棋盘状态存储数组(默认棋盘全空为0)
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 = DEFAULT_USE_FORBIDDEN_MOVES; // 是否启用禁手规则
int use_timer = DEFAULT_USE_TIMER; // 是否启用计时器
int time_limit = DEFAULT_TIME_LIMIT; // 每回合的时间限制（秒）
/** /**
* @brief 检查棋盘(x, y)位置是否为空 * @brief 检查棋盘(x, y)位置是否为空
* @param x 行坐标(0-base) * @param x 行坐标(0-base)
* @param y 列坐标(0-base) * @param y 列坐标(0-base)
* @return true-空, false-非空 * @return true-空, false-非空
*/ */
bool have_space(int x, int y) bool have_space(int x, int y)
{ {
return x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == EMPTY; return x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == EMPTY;
} }
// 函数定义 // 函数定义
/** /**
* @brief 检查是否为禁手 * @brief 检查是否为禁手
* *
* @param x * @param x
* @param y * @param y
@@ -62,7 +53,7 @@ bool is_forbidden_move(int x, int y, int player)
if (info.continuous_chess > 5) if (info.continuous_chess > 5)
{ {
board[x][y] = EMPTY; board[x][y] = EMPTY;
return true; // 长连禁手 return true; // 长连禁手
} }
if (info.continuous_chess == 3 && info.check_start && info.check_end) if (info.continuous_chess == 3 && info.check_start && info.check_end)
{ {
@@ -78,64 +69,64 @@ bool is_forbidden_move(int x, int y, int player)
if (three_count >= 2 || four_count >= 2) if (three_count >= 2 || four_count >= 2)
{ {
return true; // 三三或四四禁手 return true; // 三三或四四禁手
} }
return false; return false;
} }
/** /**
* @brief 执行玩家落子操作 * @brief 执行玩家落子操作
* @param x 行坐标(0-base) * @param x 行坐标(0-base)
* @param y 列坐标(0-base) * @param y 列坐标(0-base)
* @return true 落子成功 * @return true 落子成功
* @return false 落子失败(位置无效) * @return false 落子失败(位置无效)
*/ */
bool player_move(int x, int y, int player) bool player_move(int x, int y, int player)
{ {
// 位置无效则返回false // 位置无效则返回false
if (!have_space(x, y)) if (!have_space(x, y))
return false; return false;
if (is_forbidden_move(x, y, player)) if (is_forbidden_move(x, y, player))
{ {
printf("禁手！请选择其他位置。\n"); printf("禁手！请选择其他位置。\n");
return false; return false;
} }
// 更新棋盘状态 // 更新棋盘状态
board[x][y] = player; board[x][y] = player;
// 记录落子步骤：玩家标识和坐标 // 记录落子步骤：玩家标识和坐标
steps[step_count++] = (Step){player, x, y}; steps[step_count++] = (Step){player, x, y};
return true; return true;
} }
/** /**
* @brief 计算特定方向上连续同色棋子数量 * @brief 计算特定方向上连续同色棋子数量
* @param x 起始行坐标 * @param x 起始行坐标
* @param y 起始列坐标 * @param y 起始列坐标
* @param dx 行方向增量(-1,0,1) * @param dx 行方向增量(-1,0,1)
* @param dy 列方向增量(-1,0,1) * @param dy 列方向增量(-1,0,1)
* @param player 玩家标识(PLAYER/AI) * @param player 玩家标识(PLAYER/AI)
* @return DirInfo 包含连续棋子数和方向开放状态的结构体 * @return DirInfo 包含连续棋子数和方向开放状态的结构体
* @note 检查正反两个方向，统计连续棋子数并判断端点是否开放 * @note 检查正反两个方向，统计连续棋子数并判断端点是否开放
*/ */
DirInfo count_specific_direction(int x, int y, int dx, int dy, int player) DirInfo count_specific_direction(int x, int y, int dx, int dy, int player)
{ {
DirInfo info; DirInfo info;
info.continuous_chess = 1; // 起始位置已经有一个棋子 info.continuous_chess = 1; // 起始位置已经有一个棋子
info.check_start = false; // 起点方向是否开放 info.check_start = false; // 起点方向是否开放
info.check_end = false; // 终点方向是否开放 info.check_end = false; // 终点方向是否开放
// 检查正方向（dx, dy） // 检查正方向（dx, dy）
int nx = x + dx, ny = y + dy; int nx = x + dx, ny = y + dy;
while (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player) while (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player)
{ {
info.continuous_chess++; // 连续棋子计数增加 info.continuous_chess++; // 连续棋子计数增加
nx += dx; // 沿当前方向前进 nx += dx; // 沿当前方向前进
ny += dy; ny += dy;
} }
// 判断正方向端点是否开放（遇到空位） // 判断正方向端点是否开放（遇到空位）
if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE) if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE)
{ {
if (board[nx][ny] == EMPTY) if (board[nx][ny] == EMPTY)
@@ -144,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; nx = x - dx, ny = y - dy;
while (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player) while (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && board[nx][ny] == player)
{ {
info.continuous_chess++; // 连续棋子计数增加 info.continuous_chess++; // 连续棋子计数增加
nx -= dx; // 沿相反方向前进 nx -= dx; // 沿相反方向前进
ny -= dy; ny -= dy;
} }
// 判断反方向端点是否开放（遇到空位） // 判断反方向端点是否开放（遇到空位）
if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE) if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE)
{ {
if (board[nx][ny] == EMPTY) if (board[nx][ny] == EMPTY)
@@ -166,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) bool check_win(int x, int y, int player)
{ {
// 检查四个方向是否存在五连珠 // 检查四个方向是否存在五连珠
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
DirInfo info = count_specific_direction(x, y, direction[i][0], direction[i][1], player); 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 true;
} }
} }
return false; // 四个方向都没有五连珠 return false; // 四个方向都没有五连珠
} }
/** /**
* @brief 悔棋功能实现 * @brief 悔棋功能实现
* *
* @param steps_to_undo 要悔棋的步数 * @param steps_to_undo 要悔棋的步数
* @return true 悔棋成功 * @return true 悔棋成功
* @return false 悔棋失败(步数不足) * @return false 悔棋失败(步数不足)
*/ */
bool return_move(int steps_to_undo) bool return_move(int steps_to_undo)
{ {
@@ -205,74 +196,74 @@ bool return_move(int steps_to_undo)
} }
/** /**
* @brief 评估玩家在整盘棋局中的表现 * @brief 评估玩家在整盘棋局中的表现
* @param player 要评估的玩家(PLAYER/AI) * @param player 要评估的玩家(PLAYER/AI)
* @return int 总分(已考虑方向重复计算) * @return int 总分(已考虑方向重复计算)
* @note 改进后的评分标准: * @note 改进后的评分标准:
* - 五连:5000 (提高权重，更强调获胜) * - 五连:5000 (提高权重，更强调获胜)
* - 活四:2000 冲四:1000 死四:300 (提高权重，强调进攻性) * - 活四:2000 冲四:1000 死四:300 (提高权重，强调进攻性)
* - 活三:500 眠三:200 死三:80 (提高权重，强调战略价值) * - 活三:500 眠三:200 死三:80 (提高权重，强调战略价值)
* - 活二:100 眠二:40 死二:15 (适当提高权重) * - 活二:100 眠二:40 死二:15 (适当提高权重)
* - 开放单子:15 半开放单子:8 封闭单子:2 (适当提高权重) * - 开放单子:15 半开放单子:8 封闭单子:2 (适当提高权重)
* @note 实现细节: * @note 实现细节:
* 1. 遍历棋盘所有位置 * 1. 遍历棋盘所有位置
* 2. 对每个棋子检查四个方向 * 2. 对每个棋子检查四个方向
* 3. 统计所有连子情况并评分 * 3. 统计所有连子情况并评分
* 4. 最终分数除以4(消除方向重复计算影响) * 4. 最终分数除以4(消除方向重复计算影响)
*/ */
int calculate_step_score(int x, int y, int player) int calculate_step_score(int x, int y, int player)
{ {
int step_score = 0; int step_score = 0;
// 检查四个方向 // 检查四个方向
for (int k = 0; k < 4; k++) for (int k = 0; k < 4; k++)
{ {
DirInfo info = count_specific_direction(x, y, direction[k][0], direction[k][1], player); DirInfo info = count_specific_direction(x, y, direction[k][0], direction[k][1], player);
// 根据连子数评分 // 根据连子数评分
switch (info.continuous_chess) switch (info.continuous_chess)
{ {
case 5: case 5:
step_score += SCORE_FIVE; step_score += SCORE_FIVE;
break; // 五连 break; // 五连
case 4: case 4:
if (info.check_start && info.check_end) 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) else if (info.check_start || info.check_end)
step_score += SCORE_RUSH_FOUR; // 冲四 step_score += SCORE_RUSH_FOUR; // 冲四
else else
step_score += SCORE_DEAD_FOUR; // 死四 step_score += SCORE_DEAD_FOUR; // 死四
break; break;
case 3: case 3:
if (info.check_start && info.check_end) 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) else if (info.check_start || info.check_end)
step_score += SCORE_SLEEP_THREE; // 眠三 step_score += SCORE_SLEEP_THREE; // 眠三
else else
step_score += SCORE_DEAD_THREE; // 死三 step_score += SCORE_DEAD_THREE; // 死三
break; break;
case 2: case 2:
if (info.check_start && info.check_end) 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) else if (info.check_start || info.check_end)
step_score += SCORE_SLEEP_TWO; // 眠二 step_score += SCORE_SLEEP_TWO; // 眠二
else else
step_score += SCORE_DEAD_TWO; // 死二 step_score += SCORE_DEAD_TWO; // 死二
break; break;
case 1: case 1:
if (info.check_start && info.check_end) 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) else if (info.check_start || info.check_end)
step_score += SCORE_HALF_ONE; // 半开放单子 step_score += SCORE_HALF_ONE; // 半开放单子
else else
step_score += SCORE_DEAD_ONE; // 封闭单子 step_score += SCORE_DEAD_ONE; // 封闭单子
break; break;
} }
} }
// 位置奖励：越靠近中心分数越高 // 位置奖励：越靠近中心分数越高
int center_x = BOARD_SIZE / 2; int center_x = BOARD_SIZE / 2;
int center_y = BOARD_SIZE / 2; int center_y = BOARD_SIZE / 2;
int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离 int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离
int position_bonus = POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高 int position_bonus = POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高
return step_score + position_bonus; return step_score + position_bonus;
} }
gobang.h
+47 -66
View File
@@ -3,117 +3,98 @@
#include <stdio.h> #include <stdio.h>
#include <stdbool.h> #include <stdbool.h>
#include "config.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <math.h> #include <math.h>
// 宏定义 // 数据结构
#define MAX_BOARD_SIZE 25 // 支持的最大棋盘尺寸
#define PLAYER 1 // 玩家标识 (用于人机对战模式)
#define AI 2 // AI标识 (用于人机对战模式)
#define PLAYER1 1 // 玩家1标识 (用于双人对战模式)
#define PLAYER2 2 // 玩家2标识 (用于双人对战模式)
#define EMPTY 0 // 棋盘空位标识
#define MAX_STEPS (MAX_BOARD_SIZE * MAX_BOARD_SIZE) // 游戏最大步数
// 全局变量
extern int BOARD_SIZE; // 当前实际使用的棋盘尺寸
extern int board[MAX_BOARD_SIZE][MAX_BOARD_SIZE]; // 存储棋盘状态的二维数组
extern int step_count; // 当前游戏的总步数
extern bool use_forbidden_moves; // 是否启用禁手规则的标志
extern int use_timer; // 是否启用计时器的标志
extern int time_limit; // 每回合的时间限制（秒，内部存储）
extern const int direction[4][2]; // 定义四个基本搜索方向：水平、垂直、左斜、右斜
// 数据结构
/** /**
* @brief 记录一步棋的详细信息 * @brief 记录一步棋的详细信息
*/ */
typedef struct typedef struct
{ {
int player; // 执行该步的玩家标识 int player; // 执行该步的玩家标识
int x; // 落子的行坐标 (0-based) int x; // 落子的行坐标 (0-based)
int y; // 落子的列坐标 (0-based) int y; // 落子的列坐标 (0-based)
} Step; } Step;
extern Step steps[MAX_STEPS]; // 用于存储游戏中每一步棋的数组
/** /**
* @brief 存储在特定方向上棋子连续性的信息 * @brief 存储在特定方向上棋子连续性的信息
* @details 用于评估棋形，例如判断活三、冲四等关键形态。 * @details 用于评估棋形，例如判断活三、冲四等关键形态。
*/ */
typedef struct typedef struct
{ {
int continuous_chess; // 连续同色棋子的数量 int continuous_chess; // 连续同色棋子的数量
bool check_start; // 棋子序列的起始端是否为空位（即是否开放） bool check_start; // 棋子序列的起始端是否为空位（即是否开放）
bool check_end; // 棋子序列的末尾端是否为空位（即是否开放） bool check_end; // 棋子序列的末尾端是否为空位（即是否开放）
} DirInfo; } DirInfo;
// 函数原型 // 函数原型
// --- 游戏核心逻辑 ---
// --- 游戏核心逻辑 ---
/** /**
* @brief 检查指定坐标是否为有效落子点（在棋盘内且为空） * @brief 检查指定坐标是否为有效落子点（在棋盘内且为空）
* @param x 待检查的行坐标 (0-based) * @param x 待检查的行坐标 (0-based)
* @param y 待检查的列坐标 (0-based) * @param y 待检查的列坐标 (0-based)
* @return 若位置有效且为空则返回true，否则返回false * @return 若位置有效且为空则返回true，否则返回false
*/ */
bool have_space(int x, int y); bool have_space(int x, int y);
/** /**
* @brief 判断一个落子是否为禁手 * @brief 判断一个落子是否为禁手
* @param x 落子的行坐标 (0-based) * @param x 落子的行坐标 (0-based)
* @param y 落子的列坐标 (0-based) * @param y 落子的列坐标 (0-based)
* @param player 当前玩家的标识 * @param player 当前玩家的标识
* @return 如果是禁手则返回true，否则返回false * @return 如果是禁手则返回true，否则返回false
*/ */
bool is_forbidden_move(int x, int y, int player); bool is_forbidden_move(int x, int y, int player);
/** /**
* @brief 执行一次玩家落子操作 * @brief 执行一次玩家落子操作
* @param x 落子的行坐标 (0-based) * @param x 落子的行坐标 (0-based)
* @param y 落子的列坐标 (0-based) * @param y 落子的列坐标 (0-based)
* @param player 当前玩家的标识 * @param player 当前玩家的标识
* @return 若落子成功则返回true，否则（位置无效或被占用）返回false * @return 若落子成功则返回true，否则（位置无效或被占用）返回false
*/ */
bool player_move(int x, int y, int player); bool player_move(int x, int y, int player);
/** /**
* @brief 计算在特定方向上的棋子连续信息 * @brief 计算在特定方向上的棋子连续信息
* @param x 起始点的行坐标 * @param x 起始点的行坐标
* @param y 起始点的列坐标 * @param y 起始点的列坐标
* @param dx x方向的增量 (-1, 0, or 1) * @param dx x方向的增量 (-1, 0, or 1)
* @param dy y方向的增量 (-1, 0, or 1) * @param dy y方向的增量 (-1, 0, or 1)
* @param player 玩家标识 * @param player 玩家标识
* @return 返回一个包含连续棋子信息的 DirInfo 结构体 * @return 返回一个包含连续棋子信息的 DirInfo 结构体
*/ */
DirInfo count_specific_direction(int x, int y, int dx, int dy, int player); DirInfo count_specific_direction(int x, int y, int dx, int dy, int player);
/** /**
* @brief 检查在某点落子后，该玩家是否获胜 * @brief 检查在某点落子后，该玩家是否获胜
* @param x 落子的行坐标 (0-based) * @param x 落子的行坐标 (0-based)
* @param y 落子的列坐标 (0-based) * @param y 落子的列坐标 (0-based)
* @param player 当前玩家的标识 * @param player 当前玩家的标识
* @return 如果获胜则返回true，否则返回false * @return 如果获胜则返回true，否则返回false
*/ */
bool check_win(int x, int y, int player); bool check_win(int x, int y, int player);
/** /**
* @brief 悔棋功能，撤销指定步数 * @brief 悔棋功能，撤销指定步数
* @param steps_to_undo 要撤销的步数（每步包含双方各一次落子） * @param steps_to_undo 要撤销的步数（每步包含双方各一次落子）
* @return 若悔棋成功则返回true，否则返回false * @return 若悔棋成功则返回true，否则返回false
*/ */
bool return_move(int steps_to_undo); bool return_move(int steps_to_undo);
/** /**
* @brief 计算并返回一步棋的得分 * @brief 计算并返回一步棋的得分
* @param x 落子的行坐标 * @param x 落子的行坐标
* @param y 落子的列坐标 * @param y 落子的列坐标
* @param player 玩家标识 * @param player 玩家标识
* @return 该步棋的得分 * @return 该步棋的得分
*/ */
int calculate_step_score(int x, int y, int player); int calculate_step_score(int x, int y, int player);
gobang_config.ini
+11 -5
View File
@@ -1,12 +1,18 @@
# 五子棋游戏配置文件 # 五子棋游戏配置文件
# 棋盘大小 (范围: 5-25) # 棋盘大小 (范围: 5-25)
BOARD_SIZE=15 BOARD_SIZE=15
# 禁手规则 (0=关闭, 1=开启) # 禁手规则 (0=关闭, 1=开启)
USE_FORBIDDEN_MOVES=1 USE_FORBIDDEN_MOVES=1
# 计时器 (0=关闭, 1=开启) # 计时器 (0=关闭, 1=开启)
USE_TIMER=1 USE_TIMER=1
# 时间限制 (分钟) # 时间限制 (分钟)
TIME_LIMIT=60 TIME_LIMIT=60
# 网络端口 (范围: 1024-65535)
NETWORK_PORT=8888
# 网络超时时间 (毫秒)
NETWORK_TIMEOUT=5000
init_board.c
+30 -27
View File
@@ -1,16 +1,19 @@
#include "init_board.h" #include "init_board.h"
#include "game_mode.h"
#include "gobang.h" #include "gobang.h"
#include "game_mode.h"
#include "config.h" #include "config.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
/** /**
* @brief 初始化棋盘为全空状态并重置步数计数器 * @brief 初始化棋盘为全空状态并重置步数计数器
* 清空棋盘数组并将所有位置设为EMPTY，同时将step_count重置为0 * 清空棋盘数组并将所有位置设为EMPTY，同时将step_count重置为0
*/ */
void empty_board() void empty_board()
{ {
// 初始化棋盘状态为全空 // 初始化棋盘状态为全空
for (int i = 0; i < BOARD_SIZE; i++) for (int i = 0; i < BOARD_SIZE; i++)
{ {
for (int j = 0; j < BOARD_SIZE; j++) for (int j = 0; j < BOARD_SIZE; j++)
@@ -18,82 +21,82 @@ void empty_board()
board[i][j] = EMPTY; board[i][j] = EMPTY;
} }
} }
step_count = 0; // 重置步数计数器 step_count = 0; // 重置步数计数器
} }
/** /**
* @brief 打印当前棋盘状态 * @brief 打印当前棋盘状态
* 以可读格式输出棋盘，包括行列号和棋子状态 * 以可读格式输出棋盘，包括行列号和棋子状态
* 玩家棋子显示为'x'，AI棋子显示为'○'，空位显示为'·' * 玩家棋子显示为'x'，AI棋子显示为'○'，空位显示为'·'
*/ */
void print_board() void print_board()
{ {
// 打印列号（1-BOARD_SIZE显示） // 打印列号（1-BOARD_SIZE显示）
printf("\n "); printf("\n ");
for (int i = 0; i < BOARD_SIZE; i++) for (int i = 0; i < BOARD_SIZE; i++)
{ {
printf("%2d", i + 1); printf("%2d", i + 1);
if (i + 1 == 9) // 处理列号9和10+的对齐 if (i + 1 == 9) // 处理列号9和10+的对齐
{ {
printf(" "); printf(" ");
} }
} }
printf("\n"); printf("\n");
// 逐行打印棋盘内容 // 逐行打印棋盘内容
for (int i = 0; i < BOARD_SIZE; i++) 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++) for (int j = 0; j < BOARD_SIZE; j++)
{ {
if (board[i][j] == PLAYER) if (board[i][j] == PLAYER)
{ {
printf("x "); // 玩家棋子 printf("x "); // 玩家棋子
} }
else if (board[i][j] == AI) else if (board[i][j] == AI)
{ {
printf("○ "); // AI棋子(使用○显示) printf("○ "); // AI棋子(使用○显示)
} }
else else
{ {
printf("· "); // 空位 printf("· "); // 空位
} }
} }
printf("\n"); // 每行结束换行 printf("\n"); // 每行结束换行
} }
} }
/** /**
* @brief 配置棋盘大小 * @brief 配置棋盘大小
* *
* @param player1 玩家1 * @param player1 玩家1
* @param player2 玩家2 * @param player2 玩家2
*/ */
void setup_board_size() void setup_board_size()
{ {
printf("通常棋盘大小分为休闲棋盘(13X13)、标准棋盘(15X15)和特殊棋盘(19X19)\n"); printf("通常棋盘大小分为休闲棋盘(13X13)、标准棋盘(15X15)和特殊棋盘(19X19)\n");
char prompt[100]; 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); BOARD_SIZE = get_integer_input(prompt, 5, MAX_BOARD_SIZE);
} }
/** /**
* @brief Set the up game options object * @brief Set the up game options object
* 配置游戏选项，包括禁手规则、计时器和时间限制 * 配置游戏选项，包括禁手规则、计时器和时间限制
*/ */
void setup_game_options() 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) 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 player1
* @param player2 * @param player2
@@ -102,7 +105,7 @@ void setup_game_options()
int determine_first_player(int player1, int player2) int determine_first_player(int player1, int player2)
{ {
char prompt[100]; 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); int first_player_choice = get_integer_input(prompt, 1, 2);
if (first_player_choice == 1) if (first_player_choice == 1)
{ {
main.c
+11 -8
View File
@@ -4,7 +4,7 @@
* @details 游戏核心逻辑实现 * @details 游戏核心逻辑实现
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com) * @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
* @date 2025-07-10 * @date 2025-07-10
* @version 5.0 * @version 6.0
* @note * @note
* 1. 新增功能： * 1. 新增功能：
* - 增加了对禁手规则的支持，防止玩家进行无意义的走法。 * - 增加了对禁手规则的支持，防止玩家进行无意义的走法。
@@ -54,8 +54,8 @@
/** /**
* @brief 将指令复制到powershell * @brief 将指令复制到powershell
* gcc -o gobang.exe main.c gobang.c game_mode.c ai.c record.c init_board.c ui.c config.c * gcc -o gobang.exe main.c gobang.c game_mode.c ai.c record.c init_board.c ui.c config.c network.c globals.c -lws2_32
* gcc 为编译器，五子棋.c gobang.c game_mode.c 为源文件，output/为输出目录 * gcc 为编译器，添加了network.c网络模块，-lws2_32链接Windows网络库
* @brief 将指令复制到powershell * @brief 将指令复制到powershell
* .\gobang.exe * .\gobang.exe
*/ */
@@ -78,7 +78,7 @@ int main(int argc, char *argv[])
{ {
clear_screen(); clear_screen();
display_main_menu(); display_main_menu();
int mode = get_integer_input("请输入模式(1-7): ", 1, 7); int mode = get_integer_input("请输入模式(1-8): ", 1, 8);
switch (mode) switch (mode)
{ {
@@ -89,22 +89,25 @@ int main(int argc, char *argv[])
run_pvp_game(); run_pvp_game();
break; break;
case 3: case 3:
run_review_mode(); run_network_game();
break; break;
case 4: case 4:
config_management_menu(); run_review_mode();
break; break;
case 5: case 5:
config_management_menu();
break;
case 6:
clear_screen(); clear_screen();
display_game_rules(); display_game_rules();
pause_for_input("\n按任意键返回主菜单..."); pause_for_input("\n按任意键返回主菜单...");
break; break;
case 6: case 7:
clear_screen(); clear_screen();
display_about(); display_about();
pause_for_input("\n按任意键返回主菜单..."); pause_for_input("\n按任意键返回主菜单...");
break; break;
case 7: case 8:
save_game_config(); save_game_config();
printf("感谢使用五子棋游戏！\n"); printf("感谢使用五子棋游戏！\n");
return 0; return 0;
network.c
+426
View File
@@ -0,0 +1,426 @@
/**
* @file network.c
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
* @brief 五子棋网络对战模块实现
* @version 6.0
* @date 2025-07-10
*
* @copyright Copyright (c) 2025
*/
#include "network.h"
#include "gobang.h"
#include "config.h"
#include "globals.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket close
typedef int SOCKET;
#endif
/**
* @brief 初始化网络模块
*/
bool init_network()
{
#ifdef _WIN32
WSADATA wsaData;
int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (result != 0)
{
printf("WSAStartup failed: %d\n", result);
return false;
}
#endif
memset(&network_state, 0, sizeof(NetworkGameState));
network_state.socket = INVALID_SOCKET;
network_state.port = DEFAULT_PORT;
return true;
}
/**
* @brief 清理网络模块
*/
void cleanup_network()
{
if (network_state.socket != INVALID_SOCKET)
{
closesocket(network_state.socket);
network_state.socket = INVALID_SOCKET;
}
#ifdef _WIN32
WSACleanup();
#endif
network_state.is_connected = false;
}
/**
* @brief 创建服务器（主机模式）
*/
bool create_server(int port)
{
struct sockaddr_in server_addr, client_addr;
int addr_len = sizeof(client_addr);
// 创建套接字
SOCKET listen_socket = socket(AF_INET, SOCK_STREAM, 0);
if (listen_socket == INVALID_SOCKET)
{
printf("创建套接字失败\n");
return false;
}
// 设置地址重用
int opt = 1;
#ifdef _WIN32
setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));
#else
setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
#endif
// 绑定地址
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(port);
if (bind(listen_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR)
{
printf("绑定端口失败\n");
closesocket(listen_socket);
return false;
}
// 开始监听
if (listen(listen_socket, 1) == SOCKET_ERROR)
{
printf("监听失败\n");
closesocket(listen_socket);
return false;
}
char local_ip[MAX_IP_LENGTH];
if (get_local_ip(local_ip, sizeof(local_ip)))
{
printf("服务器已启动，等待客户端连接...\n");
printf("本机IP地址: %s\n", local_ip);
printf("监听端口: %d\n", port);
}
else
{
printf("服务器已启动，监听端口: %d\n", port);
}
// 等待客户端连接
SOCKET client_socket = accept(listen_socket, (struct sockaddr*)&client_addr, &addr_len);
if (client_socket == INVALID_SOCKET)
{
printf("接受连接失败\n");
closesocket(listen_socket);
return false;
}
// 关闭监听套接字
closesocket(listen_socket);
// 保存连接信息
network_state.socket = client_socket;
network_state.is_server = true;
network_state.is_connected = true;
network_state.local_player_id = PLAYER1;
network_state.remote_player_id = PLAYER2;
network_state.port = port;
strcpy(network_state.remote_ip, inet_ntoa(client_addr.sin_addr));
printf("客户端已连接: %s\n", network_state.remote_ip);
return true;
}
/**
* @brief 连接到服务器（客户端模式）
*/
bool connect_to_server(const char* ip, int port)
{
struct sockaddr_in server_addr;
// 创建套接字
SOCKET client_socket = socket(AF_INET, SOCK_STREAM, 0);
if (client_socket == INVALID_SOCKET)
{
printf("创建套接字失败\n");
return false;
}
// 设置服务器地址
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
#ifdef _WIN32
server_addr.sin_addr.s_addr = inet_addr(ip);
if (server_addr.sin_addr.s_addr == INADDR_NONE)
{
#else
if (inet_pton(AF_INET, ip, &server_addr.sin_addr) <= 0)
{
#endif
printf("无效的IP地址: %s\n", ip);
closesocket(client_socket);
return false;
}
printf("正在连接到服务器 %s:%d...\n", ip, port);
// 连接到服务器
if (connect(client_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) == SOCKET_ERROR)
{
printf("连接服务器失败\n");
closesocket(client_socket);
return false;
}
// 保存连接信息
network_state.socket = client_socket;
network_state.is_server = false;
network_state.is_connected = true;
network_state.local_player_id = PLAYER2;
network_state.remote_player_id = PLAYER1;
network_state.port = port;
strcpy(network_state.remote_ip, ip);
printf("成功连接到服务器\n");
return true;
}
/**
* @brief 发送网络消息
*/
bool send_network_message(const NetworkMessage* msg)
{
if (!network_state.is_connected || network_state.socket == INVALID_SOCKET)
{
return false;
}
int bytes_sent = send(network_state.socket, (const char*)msg, sizeof(NetworkMessage), 0);
return bytes_sent == sizeof(NetworkMessage);
}
/**
* @brief 接收网络消息
*/
bool receive_network_message(NetworkMessage* msg, int timeout_ms)
{
if (!network_state.is_connected || network_state.socket == INVALID_SOCKET)
{
return false;
}
// 设置超时
if (timeout_ms > 0)
{
#ifdef _WIN32
DWORD timeout = timeout_ms;
setsockopt(network_state.socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));
#else
struct timeval timeout;
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
setsockopt(network_state.socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
#endif
}
int bytes_received = recv(network_state.socket, (char*)msg, sizeof(NetworkMessage), 0);
if (bytes_received == sizeof(NetworkMessage))
{
return true;
} else if (bytes_received == 0)
{
// 连接已关闭
network_state.is_connected = false;
printf("对方已断开连接\n");
} else if (bytes_received == SOCKET_ERROR)
{
#ifdef _WIN32
int error = WSAGetLastError();
if (error != WSAETIMEDOUT)
{
#else
if (errno != EAGAIN && errno != EWOULDBLOCK)
{
#endif
network_state.is_connected = false;
printf("网络接收错误\n");
}
}
return false;
}
/**
* @brief 断开网络连接
*/
void disconnect_network()
{
if (network_state.is_connected)
{
NetworkMessage msg = {0};
msg.type = MSG_DISCONNECT;
msg.player_id = network_state.local_player_id;
msg.timestamp = time(NULL);
send_network_message(&msg);
}
cleanup_network();
}
/**
* @brief 检查网络连接状态
*/
bool is_network_connected()
{
return network_state.is_connected && network_state.socket != INVALID_SOCKET;
}
/**
* @brief 获取本机IP地址
*/
bool get_local_ip(char* ip_buffer, int buffer_size)
{
#ifdef _WIN32
char hostname[256];
if (gethostname(hostname, sizeof(hostname)) == 0)
{
struct hostent* host_entry = gethostbyname(hostname);
if (host_entry != NULL)
{
struct in_addr addr;
addr.s_addr = *((unsigned long*)host_entry->h_addr_list[0]);
strncpy(ip_buffer, inet_ntoa(addr), buffer_size - 1);
ip_buffer[buffer_size - 1] = '\0';
return true;
}
}
#else
// Linux实现
struct sockaddr_in addr;
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock != -1)
{
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr("8.8.8.8");
addr.sin_port = htons(80);
if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == 0)
{
socklen_t addr_len = sizeof(addr);
if (getsockname(sock, (struct sockaddr*)&addr, &addr_len) == 0)
{
strncpy(ip_buffer, inet_ntoa(addr.sin_addr), buffer_size - 1);
ip_buffer[buffer_size - 1] = '\0';
close(sock);
return true;
}
}
close(sock);
}
#endif
// 默认返回本地回环地址
strncpy(ip_buffer, "127.0.0.1", buffer_size - 1);
ip_buffer[buffer_size - 1] = '\0';
return false;
}
/**
* @brief 发送落子消息
*/
bool send_move(int x, int y, int player_id)
{
NetworkMessage msg = {0};
msg.type = MSG_MOVE;
msg.player_id = player_id;
msg.x = x;
msg.y = y;
msg.timestamp = time(NULL);
return send_network_message(&msg);
}
/**
* @brief 发送聊天消息
*/
bool send_chat_message(const char* message)
{
NetworkMessage msg = {0};
msg.type = MSG_CHAT;
msg.player_id = network_state.local_player_id;
strncpy(msg.message, message, sizeof(msg.message) - 1);
msg.timestamp = time(NULL);
return send_network_message(&msg);
}
/**
* @brief 发送认输消息
*/
bool send_surrender()
{
NetworkMessage msg = {0};
msg.type = MSG_SURRENDER;
msg.player_id = network_state.local_player_id;
msg.timestamp = time(NULL);
return send_network_message(&msg);
}
/**
* @brief 发送悔棋请求
*/
bool send_undo_request(int steps)
{
NetworkMessage msg = {0};
msg.type = MSG_UNDO_REQUEST;
msg.player_id = network_state.local_player_id;
msg.x = steps; // 使用x字段存储步数
msg.timestamp = time(NULL);
return send_network_message(&msg);
}
/**
* @brief 发送悔棋回应
*/
bool send_undo_response(bool accepted, int steps)
{
NetworkMessage msg = {0};
msg.type = MSG_UNDO_RESPONSE;
msg.player_id = network_state.local_player_id;
msg.x = steps; // 使用x字段存储步数
msg.y = accepted ? 1 : 0; // 使用y字段存储是否同意
msg.timestamp = time(NULL);
return send_network_message(&msg);
}
network.h
+186
View File
@@ -0,0 +1,186 @@
/**
* @file network.h
* @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. 网络消息传输
*/
#ifndef NETWORK_H
#define NETWORK_H
#include "gobang.h"
#include <stdbool.h>
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define SOCKET int
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#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 // 断线消息
// 网络消息结构
typedef struct {
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; // 端口号
} NetworkGameState;
// 全局变量声明现在在globals.h中
// 函数声明
/**
* @brief 初始化网络模块
* @return true 初始化成功
* @return false 初始化失败
*/
bool init_network();
/**
* @brief 清理网络模块
*/
void cleanup_network();
/**
* @brief 创建服务器（主机模式）
* @param port 监听端口
* @return true 创建成功
* @return false 创建失败
*/
bool create_server(int port);
/**
* @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 发送失败
*/
bool send_network_message(const NetworkMessage* msg);
/**
* @brief 接收网络消息
* @param msg 接收消息的缓冲区
* @param timeout_ms 超时时间（毫秒），0表示阻塞等待
* @return true 接收成功
* @return false 接收失败或超时
*/
bool receive_network_message(NetworkMessage* msg, int timeout_ms);
/**
* @brief 断开网络连接
*/
void disconnect_network();
/**
* @brief 检查网络连接状态
* @return true 连接正常
* @return false 连接断开
*/
bool is_network_connected();
/**
* @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 发送失败
*/
bool send_move(int x, int y, int player_id);
/**
* @brief 发送聊天消息
* @param message 聊天内容
* @return true 发送成功
* @return false 发送失败
*/
bool send_chat_message(const char* message);
/**
* @brief 发送认输消息
* @return true 发送成功
* @return false 发送失败
*/
bool send_surrender();
/**
* @brief 发送悔棋请求
* @param steps 悔棋步数
* @return true 发送成功
* @return false 发送失败
*/
bool send_undo_request(int steps);
/**
* @brief 发送悔棋回应
* @param accepted 是否同意悔棋
* @param steps 悔棋步数
* @return true 发送成功
* @return false 发送失败
*/
bool send_undo_response(bool accepted, int steps);
#endif // NETWORK_H
record.c
+176 -172
View File
@@ -2,105 +2,109 @@
#include "game_mode.h" #include "game_mode.h"
#include "gobang.h" #include "gobang.h"
#include "init_board.h" #include "init_board.h"
#include "ui.h"
#include "config.h" #include "config.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <sys/stat.h> #include <sys/stat.h>
#ifdef _WIN32
#include <direct.h>
#include <io.h>
#else
#include <unistd.h>
#include <sys/types.h>
#include <dirent.h>
#endif
/** /**
* @brief 复盘游戏全过程并展示评分 * @brief 复盘游戏全过程并展示评分
* @note 实现流程: * @note 实现流程:
* 1. 初始化临时复盘棋盘 * 1. 初始化临时复盘棋盘
* 2. 按步数顺序逐步重现每个落子 * 2. 按步数顺序逐步重现每个落子
* 3. 每步显示: * 3. 每步显示:
* - 当前步数/总步数 * - 当前步数/总步数
* - 落子方(玩家/AI) * - 落子方(玩家/AI)
* - 落子位置(1-based坐标) * - 落子位置(1-based坐标)
* - 当前棋盘状态 * - 当前棋盘状态
* 4. 通过用户按Enter键控制步骤前进 * 4. 通过用户按Enter键控制步骤前进
* 5. 复盘结束后自动进入评分环节: * 5. 复盘结束后自动进入评分环节:
* - 评估双方表现 * - 评估双方表现
* - 显示得分 * - 显示得分
* - 评选MVP * - 评选MVP
* @note 技术细节: * @note 技术细节:
* - 使用独立临时棋盘避免影响主游戏状态 * - 使用独立临时棋盘避免影响主游戏状态
* - 坐标显示转换为1-based方便用户理解 * - 坐标显示转换为1-based方便用户理解
* - 包含输入缓冲区清理防止意外输入 * - 包含输入缓冲区清理防止意外输入
* - 评分环节调用calculate_final_score()函数 * - 评分环节调用calculate_final_score()函数
*/ */
// 全局变量，用于存储对局评分，确保对战结束和复盘模式使用相同的评分
int player1_final_score = 0;
int player2_final_score = 0;
int scores_calculated = 0;
char winner_info[50] = "平局或未完成"; // 存储胜负信息
void review_process(int game_mode) 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) if (!scores_calculated)
{ {
calculate_game_scores(); calculate_game_scores();
} }
else else
{ {
// 评分已从文件中加载，直接使用 // 评分已从文件中加载，直接使用
printf("从记录文件中加载评分数据\n"); printf("从记录文件中加载评分数据\n");
} }
if (review_choice == 1) if (review_choice == 1)
{ {
printf("\n===== 复盘记录(总步数：%d) =====\n", step_count); printf("\n===== 复盘记录(总步数：%d) =====\n", step_count);
// 清空输入缓冲区 // 清空输入缓冲区
int c; int c;
while ((c = getchar()) != '\n' && c != EOF) while ((c = getchar()) != '\n' && c != EOF)
; ;
// 创建临时复盘棋盘 // 创建临时复盘棋盘
int temp_board[MAX_BOARD_SIZE][MAX_BOARD_SIZE]; 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++) for (int i = 0; i < step_count; i++)
{ {
Step s = steps[i]; // 获取当前步骤 Step s = steps[i]; // 获取当前步骤
temp_board[s.x][s.y] = s.player; // 在临时棋盘上落子 temp_board[s.x][s.y] = s.player; // 在临时棋盘上落子
// 打印当前步骤信息 // 打印当前步骤信息
// 根据游戏模式显示不同的标题和玩家信息 // 根据游戏模式显示不同的标题和玩家信息
if (game_mode == 1) if (game_mode == 1)
{ {
// 人机对战 // 人机对战
printf("\n===== 五子棋人机对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE); printf("\n===== 五子棋人机对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE);
printf("\n 第%d步/%d步: %s 落子于(%d, %d)\n", printf("\n 第%d步/%d步: %s 落子于(%d, %d)\n",
i + 1, step_count, i + 1, step_count,
(s.player == PLAYER) ? "玩家" : "AI", (s.player == PLAYER) ? "玩家" : "AI",
s.x + 1, s.y + 1); s.x + 1, s.y + 1);
} }
else else
{ {
// 双人对战 // 双人对战
printf("\n===== 五子棋双人对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE); printf("\n===== 五子棋双人对战(%dX%d棋盘) =====", BOARD_SIZE, BOARD_SIZE);
printf("\n 第%d步/%d步: %s 落子于(%d, %d)\n", printf("\n 第%d步/%d步: %s 落子于(%d, %d)\n",
i + 1, step_count, i + 1, step_count,
(s.player == PLAYER1) ? "玩家1(黑棋)" : "玩家2(白棋)", (s.player == PLAYER1) ? "玩家1(黑棋)" : "玩家2(白棋)",
s.x + 1, s.y + 1); s.x + 1, s.y + 1);
} }
// 打印当前复盘棋盘 // 打印当前复盘棋盘
printf(" "); printf(" ");
for (int col = 0; col < BOARD_SIZE; col++) for (int col = 0; col < BOARD_SIZE; col++)
{ {
printf("%2d", col + 1); // 列号 printf("%2d", col + 1); // 列号
} }
printf("\n"); printf("\n");
for (int row = 0; row < BOARD_SIZE; row++) for (int row = 0; row < BOARD_SIZE; row++)
{ {
printf("%2d ", row + 1); // 行号 printf("%2d ", row + 1); // 行号
for (int col = 0; col < BOARD_SIZE; col++) for (int col = 0; col < BOARD_SIZE; col++)
{ {
if (temp_board[row][col] == PLAYER || temp_board[row][col] == PLAYER1) if (temp_board[row][col] == PLAYER || temp_board[row][col] == PLAYER1)
@@ -109,72 +113,72 @@ void review_process(int game_mode)
} }
else if (temp_board[row][col] == AI || temp_board[row][col] == PLAYER2) else if (temp_board[row][col] == AI || temp_board[row][col] == PLAYER2)
{ {
printf("○ "); printf("○ ");
} }
else else
{ {
printf("· "); printf("· ");
} }
} }
printf("\n"); // 行结束换行 printf("\n"); // 行结束换行
} }
// 如果不是最后一步，等待用户按键继续 // 如果不是最后一步，等待用户按键继续
if (i < step_count - 1) if (i < step_count - 1)
{ {
printf("\n按Enter继续下一步..."); printf("\n按Enter继续下一步...");
while (getchar() != '\n') while (getchar() != '\n')
; // 等待回车 ; // 等待回车
} }
} }
// 显示胜负结果（直接使用文件中的信息） // 显示胜负结果（直接使用文件中的信息）
printf("\n===== 对局结果 ====="); printf("\n===== 对局结果 =====");
if (strcmp(winner_info, "玩家获胜") == 0) 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 else
{ {
printf("\n?? 对局平局或未完成\n"); printf("\n?? 对局平局或未完成\n");
} }
printf("\n复盘结束！按Enter查看评分..."); printf("\n复盘结束！按Enter查看评分...");
getchar(); // 等待用户按键 getchar(); // 等待用户按键
} }
// 显示评分结果 // 显示评分结果
display_game_scores(game_mode); display_game_scores(game_mode);
getchar(); getchar();
} }
/** /**
* @brief 计算游戏评分 * @brief 计算游戏评分
*/ */
void calculate_game_scores() void calculate_game_scores()
{ {
// 评估双方表现 // 评估双方表现
player1_final_score = 0; player1_final_score = 0;
player2_final_score = 0; player2_final_score = 0;
// 遍历所有步数，累积每一步的得分，后期步骤权重更高 // 遍历所有步数，累积每一步的得分，后期步骤权重更高
for (int i = 0; i < step_count; i++) for (int i = 0; i < step_count; i++)
{ {
// 计算时间权重因子：步数越靠后，权重越大 // 计算时间权重因子：步数越靠后，权重越大
double time_weight = 1.0 + (double)i / step_count * TIME_WEIGHT_FACTOR; // 最后的步骤权重是开始步骤的(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) if (steps[i].player == PLAYER || steps[i].player == PLAYER1)
{ {
@@ -186,50 +190,50 @@ void calculate_game_scores()
} }
} }
// 胜负加权：获胜方获得额外的评分奖励 // 胜负加权：获胜方获得额外的评分奖励
if (step_count > 0) if (step_count > 0)
{ {
Step last_step = steps[step_count - 1]; Step last_step = steps[step_count - 1];
if (check_win(last_step.x, last_step.y, last_step.player)) if (check_win(last_step.x, last_step.y, last_step.player))
{ {
// 获胜方获得额外奖励分数 // 获胜方获得额外奖励分数
if (last_step.player == PLAYER || last_step.player == PLAYER1) if (last_step.player == PLAYER || last_step.player == PLAYER1)
{ {
player1_final_score += WIN_BONUS; // 获胜奖励 player1_final_score += WIN_BONUS; // 获胜奖励
} }
else else
{ {
player2_final_score += WIN_BONUS; // 获胜奖励 player2_final_score += WIN_BONUS; // 获胜奖励
} }
} }
} }
scores_calculated = 1; // 标记评分已计算 scores_calculated = 1; // 标记评分已计算
} }
/** /**
* @brief 显示游戏评分结果和MVP评选 * @brief 显示游戏评分结果和MVP评选
* @param game_mode 游戏模式(1-人机对战, 2-双人对战) * @param game_mode 游戏模式(1-人机对战, 2-双人对战)
*/ */
void display_game_scores(int game_mode) 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; double sum_score = (long double)player1_final_score + (long double)player2_final_score;
if (sum_score > 0) if (sum_score > 0)
{ {
if (game_mode == 1) if (game_mode == 1)
{ {
printf("玩家得分: %d, 占比: %.2f%%\n", printf("玩家得分: %d, 占比: %.2f%%\n",
player1_final_score, (double)player1_final_score * 100.0 / sum_score); 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); player2_final_score, (double)player2_final_score * 100.0 / sum_score);
} }
else else
{ {
printf("玩家1(黑棋)得分: %d, 占比: %.2f%%\n", printf("玩家1(黑棋)得分: %d, 占比: %.2f%%\n",
player1_final_score, (double)player1_final_score * 100.0 / sum_score); 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); player2_final_score, (double)player2_final_score * 100.0 / sum_score);
} }
} }
@@ -237,41 +241,41 @@ void display_game_scores(int game_mode)
{ {
if (game_mode == 1) if (game_mode == 1)
{ {
printf("玩家得分: %d\n", player1_final_score); printf("玩家得分: %d\n", player1_final_score);
printf("AI得分: %d\n", player2_final_score); printf("AI得分: %d\n", player2_final_score);
} }
else else
{ {
printf("玩家1(黑棋)得分: %d\n", player1_final_score); printf("玩家1(黑棋)得分: %d\n", player1_final_score);
printf("玩家2(白棋)得分: %d\n", player2_final_score); printf("玩家2(白棋)得分: %d\n", player2_final_score);
} }
printf("注: 双方得分均为0，无法计算占比\n"); printf("注: 双方得分均为0，无法计算占比\n");
} }
// 评选MVP // 评选MVP
if (player1_final_score > player2_final_score) 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) 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 else
{ {
printf("\n双方势均力敌！\n"); printf("\n双方势均力敌！\n");
} }
} }
/** /**
* @brief 处理游戏结束后的记录保存 * @brief 处理游戏结束后的记录保存
* @return int 保存状态码(0-成功, 1-目录创建失败, 2-文件打开失败, 3-文件写入失败) * @return int 保存状态码(0-成功, 1-目录创建失败, 2-文件打开失败, 3-文件写入失败)
*/ */
void handle_save_record(int game_mode) void handle_save_record(int game_mode)
{ {
int save_choice = 0; int save_choice = 0;
printf("===== 游戏结束 =====\n"); printf("===== 游戏结束 =====\n");
printf("是否保存游戏记录? (1-是, 0-否): "); printf("是否保存游戏记录? (1-是, 0-否): ");
scanf("%d", &save_choice); scanf("%d", &save_choice);
if (save_choice == 1) if (save_choice == 1)
@@ -284,75 +288,75 @@ void handle_save_record(int game_mode)
int save_status = save_game_to_file(filename, game_mode); int save_status = save_game_to_file(filename, game_mode);
switch (save_status) switch (save_status)
{ {
case 0: // 成功 case 0: // 成功
printf("\n游戏记录已成功保存至: %s (CSV格式)\n", filename); printf("\n游戏记录已成功保存至: %s (CSV格式)\n", filename);
printf("您可以使用以下命令进行复盘: .\\gobang.exe -l %s\n", filename); printf("您可以使用以下命令进行复盘: .\\gobang.exe -l %s\n", filename);
printf("CSV格式文件可以直接用Excel打开查看和分析\n"); printf("CSV格式文件可以直接用Excel打开查看和分析\n");
break; break;
case 1: // 目录创建失败 case 1: // 目录创建失败
printf("\n游戏记录保存失败: 无法创建 'records' 目录。\n"); printf("\n游戏记录保存失败: 无法创建 'records' 目录。\n");
printf("请检查程序是否具有足够的写入权限或磁盘空间是否充足。\n"); printf("请检查程序是否具有足够的写入权限或磁盘空间是否充足。\n");
break; break;
case 2: // 文件打开失败 case 2: // 文件打开失败
printf("\n游戏记录保存失败: 无法在路径 '%s' 创建文件。\n", filename); printf("\n游戏记录保存失败: 无法在路径 '%s' 创建文件。\n", filename);
printf("请检查路径是否有效以及程序是否具有写入权限。\n"); printf("请检查路径是否有效以及程序是否具有写入权限。\n");
break; break;
case 3: // 文件写入失败 case 3: // 文件写入失败
printf("\n游戏记录保存失败: 写入文件时发生错误。\n"); printf("\n游戏记录保存失败: 写入文件时发生错误。\n");
printf("请检查磁盘空间是否已满。\n"); printf("请检查磁盘空间是否已满。\n");
break; break;
default: default:
printf("\n游戏记录保存失败: 发生未知错误。\n"); printf("\n游戏记录保存失败: 发生未知错误。\n");
break; break;
} }
} }
} }
/** /**
* @brief 将当前游戏记录保存到文件 * @brief 将当前游戏记录保存到文件
* @param filename 要保存的文件名 * @param filename 要保存的文件名
* @return int 错误码: * @return int 错误码:
* 0: 成功 * 0: 成功
* 1: 目录创建失败 * 1: 目录创建失败
* 2: 文件打开失败 * 2: 文件打开失败
* 3: 文件写入失败 * 3: 文件写入失败
*/ */
int save_game_to_file(const char *filename, int game_mode) int save_game_to_file(const char *filename, int game_mode)
{ {
// 创建records目录(如果不存在) // 创建records目录(如果不存在)
struct stat st = {0}; struct stat st = {0};
if (stat("records", &st) == -1) if (stat("records", &st) == -1)
{ {
if (mkdir("records") != 0) if (mkdir("records") != 0)
{ {
// 检查是否目录已存在(多线程情况下可能被其他线程创建) // 检查是否目录已存在(多线程情况下可能被其他线程创建)
if (stat("records", &st) == -1) if (stat("records", &st) == -1)
{ {
#ifdef _WIN32 #ifdef _WIN32
printf("错误：无法创建records目录\n"); printf("错误：无法创建records目录\n");
printf("可能原因：\n"); printf("可能原因：\n");
printf("1. 没有写入权限 - 请尝试以管理员身份运行\n"); printf("1. 没有写入权限 - 请尝试以管理员身份运行\n");
printf("2. 防病毒软件阻止 - 请检查安全软件设置\n"); printf("2. 防病毒软件阻止 - 请检查安全软件设置\n");
printf("3. 路径无效 - 请检查工作目录\n"); printf("3. 路径无效 - 请检查工作目录\n");
#else #else
perror("创建目录失败"); perror("创建目录失败");
#endif #endif
return 1; // 目录创建失败 return 1; // 目录创建失败
} }
} }
} }
// 打开文件 // 打开文件
char fullpath[256]; char fullpath[256];
snprintf(fullpath, sizeof(fullpath), "records/%s", filename); snprintf(fullpath, sizeof(fullpath), "records/%s", filename);
FILE *file = fopen(fullpath, "w"); FILE *file = fopen(fullpath, "w");
if (!file) if (!file)
{ {
return 2; // 文件打开失败 return 2; // 文件打开失败
} }
// 判断胜负结果 // 判断胜负结果
strcpy(winner_info, "平局或未完成"); strcpy(winner_info, "平局或未完成");
if (step_count > 0) if (step_count > 0)
{ {
Step last_step = steps[step_count - 1]; Step last_step = steps[step_count - 1];
@@ -360,72 +364,72 @@ int save_game_to_file(const char *filename, int game_mode)
{ {
if (game_mode == 1) if (game_mode == 1)
{ {
// 人机对战 // 人机对战
if (last_step.player == PLAYER) if (last_step.player == PLAYER)
{ {
strcpy(winner_info, "玩家获胜"); strcpy(winner_info, "玩家获胜");
} }
else else
{ {
strcpy(winner_info, "AI获胜"); strcpy(winner_info, "AI获胜");
} }
} }
else else
{ {
// 双人对战 // 双人对战
if (last_step.player == PLAYER1) if (last_step.player == PLAYER1)
{ {
strcpy(winner_info, "玩家1获胜"); strcpy(winner_info, "玩家1获胜");
} }
else else
{ {
strcpy(winner_info, "玩家2获胜"); strcpy(winner_info, "玩家2获胜");
} }
} }
} }
} }
// 写入CSV文件头部 // 写入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) 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); fclose(file);
return 3; // 文件写入失败 return 3; // 文件写入失败
} }
// 写入CSV表头 // 写入CSV表头
if (fprintf(file, "步数,玩家,行坐标,列坐标\n") < 0) if (fprintf(file, "步数,玩家,行坐标,列坐标\n") < 0)
{ {
fclose(file); fclose(file);
return 3; // 文件写入失败 return 3; // 文件写入失败
} }
// 写入所有落子步骤（CSV格式） // 写入所有落子步骤（CSV格式）
for (int i = 0; i < step_count; i++) 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) if (fprintf(file, "%d,%d,%d,%d\n", i+1, steps[i].player, steps[i].x+1, steps[i].y+1) < 0)
{ {
fclose(file); fclose(file);
return 3; // 文件写入失败 return 3; // 文件写入失败
} }
} }
if (fclose(file) != 0) if (fclose(file) != 0)
{ {
return 3; // 文件关闭/写入失败 return 3; // 文件关闭/写入失败
} }
return 0; // 成功 return 0; // 成功
} }
/** /**
* @brief 从文件加载游戏记录 * @brief 从文件加载游戏记录
* @param filename 要加载的文件名 * @param filename 要加载的文件名
* @return true 加载成功 * @return true 加载成功
* @return false 加载失败 * @return false 加载失败
*/ */
int load_game_from_file(const char *filename) int load_game_from_file(const char *filename)
{ {
// 打开文件 // 打开文件
char fullpath[256]; char fullpath[256];
snprintf(fullpath, sizeof(fullpath), "records/%s", filename); snprintf(fullpath, sizeof(fullpath), "records/%s", filename);
FILE *file = fopen(fullpath, "r"); FILE *file = fopen(fullpath, "r");
@@ -434,28 +438,28 @@ int load_game_from_file(const char *filename)
return false; return false;
} }
// 跳过CSV文件头部行 // 跳过CSV文件头部行
char buffer[256]; char buffer[256];
if (fgets(buffer, sizeof(buffer), file) == NULL) // 跳过"游戏模式,棋盘大小" if (fgets(buffer, sizeof(buffer), file) == NULL) // 跳过"游戏模式,棋盘大小"
{ {
fclose(file); fclose(file);
return 0; return 0;
} }
// 读取游戏模式、棋盘大小和评分结果 // 读取游戏模式、棋盘大小和评分结果
int game_mode, size; 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); 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) if (read_count == 4)
{ {
// 旧格式文件，没有胜负信息 // 旧格式文件，没有胜负信息
strcpy(winner_info, "未知"); strcpy(winner_info, "未知");
} }
else if (read_count != 5) else if (read_count != 5)
{ {
// 文件格式错误 // 文件格式错误
fclose(file); fclose(file);
return 0; return 0;
} }
@@ -463,7 +467,7 @@ int load_game_from_file(const char *filename)
if (game_mode != 1 && game_mode != 2) if (game_mode != 1 && game_mode != 2)
{ {
fclose(file); fclose(file);
return 0; // 无效的游戏模式 return 0; // 无效的游戏模式
} }
if (size < 5 || size > MAX_BOARD_SIZE) if (size < 5 || size > MAX_BOARD_SIZE)
{ {
@@ -471,24 +475,24 @@ int load_game_from_file(const char *filename)
return false; return false;
} }
// 设置评分已计算标志 // 设置评分已计算标志
scores_calculated = 1; 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; BOARD_SIZE = size;
empty_board(); empty_board();
// 读取所有落子步骤 // 读取所有落子步骤
step_count = 0; 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) 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].x--;
steps[step_count].y--; steps[step_count].y--;
step_count++; step_count++;
record.h
+15 -21
View File
@@ -3,48 +3,42 @@
#include "gobang.h" #include "gobang.h"
// 全局变量，用于存储对局评分，确保对战结束和复盘模式使用相同的评分 // --- 复盘与记录功能 ---
extern int player1_final_score; // 玩家1最终得分
extern int player2_final_score; // 玩家2最终得分
extern int scores_calculated; // 评分计算标志
extern char winner_info[50]; // 存储胜负信息
// --- 复盘与记录功能 ---
/** /**
* @brief 进入复盘流程，回顾整局游戏 * @brief 进入复盘流程，回顾整局游戏
* @param game_mode 游戏模式（1为人机对战，2为双人对战） * @param game_mode 游戏模式（1为人机对战，2为双人对战）
*/ */
void review_process(int game_mode); void review_process(int game_mode);
/** /**
* @brief 将当前对局记录保存到文件 * @brief 将当前对局记录保存到文件
* @param filename 要保存到的文件名 * @param filename 要保存到的文件名
* @param game_mode 游戏模式 * @param game_mode 游戏模式
* @return 0表示成功，非0表示失败 * @return 0表示成功，非0表示失败
*/ */
int save_game_to_file(const char *filename, int game_mode); int save_game_to_file(const char *filename, int game_mode);
/** /**
* @brief 处理保存游戏记录的逻辑 * @brief 处理保存游戏记录的逻辑
* @param game_mode 游戏模式 * @param game_mode 游戏模式
*/ */
void handle_save_record(int game_mode); void handle_save_record(int game_mode);
/** /**
* @brief 从文件加载游戏记录 * @brief 从文件加载游戏记录
* @param filename 要加载的文件名 * @param filename 要加载的文件名
* @return 游戏模式（1或2），0表示失败 * @return 游戏模式（1或2），0表示失败
*/ */
int load_game_from_file(const char *filename); int load_game_from_file(const char *filename);
/** /**
* @brief 计算游戏评分 * @brief 计算游戏评分
*/ */
void calculate_game_scores(); void calculate_game_scores();
/** /**
* @brief 显示游戏评分结果和MVP评选 * @brief 显示游戏评分结果和MVP评选
* @param game_mode 游戏模式（1-人机对战，2-双人对战） * @param game_mode 游戏模式（1-人机对战，2-双人对战）
*/ */
void display_game_scores(int game_mode); void display_game_scores(int game_mode);
ui.c
+35 -30
View File
@@ -1,5 +1,7 @@
#include "ui.h" #include "ui.h"
#include "gobang.h"
#include "config.h" #include "config.h"
#include "globals.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#ifdef _WIN32 #ifdef _WIN32
@@ -17,11 +19,12 @@ void display_main_menu()
printf("===== 五子棋游戏 =====\n"); printf("===== 五子棋游戏 =====\n");
printf("1. AI模式\n"); printf("1. AI模式\n");
printf("2. 玩家比赛\n"); printf("2. 玩家比赛\n");
printf("3. 复盘模式\n"); printf("3. 网络对战\n");
printf("4. 游戏设置\n"); printf("4. 复盘模式\n");
printf("5. 游戏规则\n"); printf("5. 游戏设置\n");
printf("6. 关于游戏\n"); printf("6. 游戏规则\n");
printf("7. 退出游戏\n"); printf("7. 关于游戏\n");
printf("8. 退出游戏\n");
printf("=====================\n"); printf("=====================\n");
} }
@@ -86,26 +89,26 @@ void display_game_status(int current_player, int step_count)
*/ */
void display_winner(int winner) void display_winner(int winner)
{ {
printf("\n? 游戏结束！\n"); printf("\n游戏结束！\n");
if (winner == PLAYER) if (winner == PLAYER)
{ {
printf("? 玩家获胜！\n"); printf("玩家获胜！\n");
} }
else if (winner == AI) else if (winner == AI)
{ {
printf("? AI获胜！\n"); printf("AI获胜！\n");
} }
else if (winner == PLAYER1) else if (winner == PLAYER1)
{ {
printf("? 玩家1获胜！\n"); printf("玩家1获胜！\n");
} }
else if (winner == PLAYER2) else if (winner == PLAYER2)
{ {
printf("? 玩家2获胜！\n"); printf("玩家2获胜！\n");
} }
else else
{ {
printf("? 平局！\n"); printf("平局！\n");
} }
} }
@@ -118,8 +121,9 @@ void display_settings_menu()
printf("1. 棋盘大小设置\n"); printf("1. 棋盘大小设置\n");
printf("2. 禁手规则设置\n"); printf("2. 禁手规则设置\n");
printf("3. 计时器设置\n"); printf("3. 计时器设置\n");
printf("4. AI难度设置\n"); printf("4. 网络配置设置\n");
printf("5. 返回主菜单\n"); printf("5. AI难度设置\n");
printf("6. 返回主菜单\n");
printf("==================\n"); printf("==================\n");
} }
@@ -155,24 +159,24 @@ void pause_for_input(const char* prompt)
void display_game_rules() void display_game_rules()
{ {
printf("\n===== 五子棋游戏规则 =====\n"); printf("\n===== 五子棋游戏规则 =====\n");
printf("1. 游戏目标：\n"); printf("1. 🎮 游戏目标：\n");
printf(" 在棋盘上连成五个同色棋子（横、竖、斜均可）\n\n"); printf(" 在棋盘上连成五个同色棋子（横、竖、斜均可）\n\n");
printf("2. 游戏流程：\n"); printf("2. 🔄 游戏流程：\n");
printf(" - 黑棋先行，双方轮流落子\n"); printf(" - ⚫ 黑棋先行，双方轮流落子\n");
printf(" - 输入坐标格式：行号 列号（如：7 7）\n"); printf(" - 📍 输入坐标格式：行号 列号（如：7 7）\n");
printf(" - 棋子落在棋盘交叉点上\n\n"); printf(" - ✨ 棋子落在棋盘交叉点上\n\n");
printf("3. 胜负判定：\n"); printf("3. 🏆 胜负判定：\n");
printf(" - 率先连成五子者获胜\n"); printf(" - 🎉 率先连成五子者获胜\n");
printf(" - 棋盘下满无人获胜则为平局\n\n"); printf(" - 🤝 棋盘下满无人获胜则为平局\n\n");
printf("4. 禁手规则（可选）：\n"); printf("4. 🚫 禁手规则（可选）：\n");
printf(" - 三三禁手：同时形成两个活三\n"); printf(" - ❌ 三三禁手：同时形成两个活三\n");
printf(" - 四四禁手：同时形成两个冲四\n"); printf(" - ❌ 四四禁手：同时形成两个冲四\n");
printf(" - 长连禁手：连成六子或以上\n\n"); printf(" - ❌ 长连禁手：连成六子或以上\n\n");
printf("5. 特殊功能：\n"); printf("5. 🛠️ 特殊功能：\n");
printf(" - 悔棋：输入 'R' 或 'r' 可悔棋\n"); printf(" - ↩️ 悔棋：输入 'R' 或 'r' 可悔棋\n");
printf(" - 保存：游戏结束后可保存对局记录\n"); printf(" - 💾 保存：游戏结束后可保存对局记录\n");
printf(" - 复盘：可加载历史对局进行复盘\n"); printf(" - 📖 复盘：可加载历史对局进行复盘\n");
printf("========================\n"); printf("============================\n");
} }
/** /**
@@ -189,6 +193,7 @@ void display_about()
printf("✨ 主要特性：\n"); printf("✨ 主要特性：\n");
printf(" 🤖 智能AI对战（支持多种难度）\n"); printf(" 🤖 智能AI对战（支持多种难度）\n");
printf(" 👥 双人对战模式\n"); printf(" 👥 双人对战模式\n");
printf(" 🌐 网络对战（局域网/互联网）\n");
printf(" 📝 对局记录与复盘\n"); printf(" 📝 对局记录与复盘\n");
printf(" 🚫 禁手规则支持\n"); printf(" 🚫 禁手规则支持\n");
printf(" ⏱️ 计时器功能\n"); printf(" ⏱️ 计时器功能\n");