mirror of
https://github.com/LHY0125/Gobang-Game.git
synced 2026-06-30 18:45:56 +08:00
重构项目结构：将源文件和头文件分别移动到src和include目录
This commit is contained in:
@@ -0,0 +1,598 @@
|
||||
/**
|
||||
* @file ai.c
|
||||
* @note 本文件定义了AI模块的函数和变量
|
||||
* @note 包括：
|
||||
* 1. 评估一个落子位置的综合得分（结合进攻和防守）
|
||||
* 2. 评估指定位置的价值
|
||||
* 3. 评估棋盘价值
|
||||
*/
|
||||
|
||||
#include "gobang.h"
|
||||
#include "ai.h"
|
||||
#include "config.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
// ==================== 辅助函数声明 ====================
|
||||
static int compare_moves(const void *a, const void *b);
|
||||
|
||||
/**
|
||||
* @brief 评估一个落子位置的综合得分（结合进攻和防守）
|
||||
* @param x 行坐标
|
||||
* @param y 列坐标
|
||||
* @return int 综合得分
|
||||
*/
|
||||
int evaluate_move(int x, int y)
|
||||
{
|
||||
// 进攻得分：评估AI在此处落子的分数
|
||||
int attack_score = evaluate_pos(x, y, AI);
|
||||
|
||||
// 防守得分：评估玩家在此处落子的分数，作为防守的依据
|
||||
int defense_score = evaluate_pos(x, y, PLAYER);
|
||||
|
||||
// 综合得分，防守权重由 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(封闭)
|
||||
* - 中心位置有额外加成
|
||||
*/
|
||||
int evaluate_pos(int x, int y, int player)
|
||||
{
|
||||
// 保存原始值用于还原
|
||||
int original = board[x][y];
|
||||
// 模拟在该位置落子
|
||||
board[x][y] = player;
|
||||
|
||||
int total_score = 0; // 总分
|
||||
int line_scores[4] = {0}; // 四个方向的得分
|
||||
|
||||
// 遍历四个方向进行评估
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
int dx = direction[i][0], dy = direction[i][1];
|
||||
// 获取当前方向上的棋型信息
|
||||
DirInfo info = count_specific_direction(x, y, dx, dy, player);
|
||||
|
||||
// 直接形成五连珠为必胜
|
||||
if (info.continuous_chess >= 5)
|
||||
{
|
||||
board[x][y] = original; // 还原棋盘
|
||||
return SEARCH_WIN_BONUS; // 返回最大分
|
||||
}
|
||||
|
||||
// 根据连续棋子数评分
|
||||
switch (info.continuous_chess)
|
||||
{
|
||||
case 4: // 四连珠
|
||||
if (info.check_start && info.check_end) // 活四(两端开放)
|
||||
line_scores[i] = AI_SCORE_LIVE_FOUR;
|
||||
else if (info.check_start || info.check_end) // 冲四(一端开放)
|
||||
line_scores[i] = AI_SCORE_RUSH_FOUR;
|
||||
else // 死四(两端封闭)
|
||||
line_scores[i] = AI_SCORE_DEAD_FOUR;
|
||||
break;
|
||||
|
||||
case 3: // 三连珠
|
||||
if (info.check_start && info.check_end) // 活三
|
||||
line_scores[i] = AI_SCORE_LIVE_THREE;
|
||||
else if (info.check_start || info.check_end) // 眠三
|
||||
line_scores[i] = AI_SCORE_SLEEP_THREE;
|
||||
else // 死三
|
||||
line_scores[i] = AI_SCORE_DEAD_THREE;
|
||||
break;
|
||||
|
||||
case 2: // 二连珠
|
||||
if (info.check_start && info.check_end) // 活二
|
||||
line_scores[i] = AI_SCORE_LIVE_TWO;
|
||||
else if (info.check_start || info.check_end) // 眠二
|
||||
line_scores[i] = AI_SCORE_SLEEP_TWO;
|
||||
else // 死二
|
||||
line_scores[i] = AI_SCORE_DEAD_TWO;
|
||||
break;
|
||||
|
||||
case 1: // 单子
|
||||
if (info.check_start && info.check_end) // 开放位置
|
||||
line_scores[i] = AI_SCORE_LIVE_ONE;
|
||||
else if (info.check_start || info.check_end) // 半开放位置
|
||||
line_scores[i] = AI_SCORE_HALF_ONE;
|
||||
else // 封闭位置
|
||||
line_scores[i] = AI_SCORE_DEAD_ONE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 计算总分（最高方向分+其他方向分加权）
|
||||
int max_score = 0;
|
||||
int sum_score = 0;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
if (line_scores[i] > max_score)
|
||||
{
|
||||
max_score = line_scores[i];
|
||||
}
|
||||
sum_score += line_scores[i];
|
||||
}
|
||||
total_score = max_score * 10 + sum_score; // 主方向权重更高
|
||||
|
||||
// 位置奖励：越靠近中心分数越高
|
||||
int center_x = BOARD_SIZE / 2;
|
||||
int center_y = BOARD_SIZE / 2;
|
||||
int distance = abs(x - center_x) + abs(y - center_y); // 曼哈顿距离
|
||||
int position_bonus = AI_POSITION_BONUS_FACTOR * (BOARD_SIZE - distance); // 距离中心越近奖励越高
|
||||
|
||||
board[x][y] = original; // 还原棋盘状态
|
||||
return total_score + position_bonus; // 返回总评估分
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 带α-β剪枝的深度优先搜索(极小极大算法实现)
|
||||
* @param x 当前行坐标
|
||||
* @param y 当前列坐标
|
||||
* @param player 当前玩家
|
||||
* @param depth 剩余搜索深度
|
||||
* @param alpha α值(当前最大值)
|
||||
* @param beta β值(当前最小值)
|
||||
* @param is_maximizing 是否为极大化玩家(AI)
|
||||
* @return int 最佳评估分数
|
||||
* @note 算法流程:
|
||||
* 1. 检查是否获胜或达到搜索深度
|
||||
* 2. 遍历所有可能落子位置
|
||||
* 3. 递归评估每个位置的分数
|
||||
* 4. 根据is_maximizing选择最大/最小值
|
||||
* 5. 使用α-β剪枝优化搜索过程
|
||||
*/
|
||||
int dfs(int x, int y, int player, int depth, int alpha, int beta, bool is_maximizing)
|
||||
{
|
||||
// 检查当前落子是否获胜
|
||||
if (check_win(x, y, player))
|
||||
{
|
||||
return (player == AI) ? 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);
|
||||
}
|
||||
|
||||
int best_score = is_maximizing ? -1000000 : 1000000;
|
||||
|
||||
// 使用移动排序优化搜索效率
|
||||
ScoredMove candidate_moves[BOARD_SIZE * BOARD_SIZE];
|
||||
int move_count = generate_candidate_moves(candidate_moves, player);
|
||||
|
||||
// 限制搜索的候选移动数量以提高性能
|
||||
int max_candidates = (depth >= 3) ? 15 : 25; // 深度越大，候选移动越少
|
||||
if (move_count > max_candidates)
|
||||
{
|
||||
move_count = max_candidates;
|
||||
}
|
||||
|
||||
// 遍历排序后的候选移动
|
||||
for (int idx = 0; idx < move_count; idx++)
|
||||
{
|
||||
int i = candidate_moves[idx].x;
|
||||
int j = candidate_moves[idx].y;
|
||||
|
||||
// 模拟当前玩家落子
|
||||
board[i][j] = player;
|
||||
step_count++;
|
||||
|
||||
// 递归搜索(切换玩家和搜索深度)
|
||||
int current_score = dfs(i, j, (player == AI) ? PLAYER : AI, depth - 1, alpha, beta, !is_maximizing);
|
||||
|
||||
// 撤销落子
|
||||
board[i][j] = EMPTY;
|
||||
step_count--;
|
||||
|
||||
// 极大值玩家(AI)逻辑
|
||||
if (is_maximizing)
|
||||
{
|
||||
best_score = (current_score > best_score) ? current_score : best_score;
|
||||
alpha = (best_score > alpha) ? best_score : alpha;
|
||||
// α剪枝
|
||||
if (beta <= alpha)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 极小值玩家(人类)逻辑
|
||||
else
|
||||
{
|
||||
best_score = (current_score < best_score) ? current_score : best_score;
|
||||
beta = (best_score < beta) ? best_score : beta;
|
||||
// β剪枝
|
||||
if (beta <= alpha)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return best_score;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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);
|
||||
return;
|
||||
}
|
||||
|
||||
// 1. 使用增强的威胁检测系统
|
||||
ScoredMove candidate_moves[BOARD_SIZE * BOARD_SIZE];
|
||||
int move_count = generate_candidate_moves(candidate_moves, AI);
|
||||
|
||||
// 首先检查是否有直接获胜的机会
|
||||
for (int idx = 0; idx < move_count; idx++)
|
||||
{
|
||||
int i = candidate_moves[idx].x;
|
||||
int j = candidate_moves[idx].y;
|
||||
|
||||
ThreatLevel ai_threat = detect_threat(i, j, AI);
|
||||
if (ai_threat == THREAT_WIN)
|
||||
{
|
||||
// 直接获胜
|
||||
board[i][j] = AI;
|
||||
steps[step_count++] = (Step){AI, i, j};
|
||||
printf("AI落子(%d, %d) - 获胜!\n", i + 1, j + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 检查是否需要阻止玩家的威胁
|
||||
for (int idx = 0; idx < move_count; idx++)
|
||||
{
|
||||
int i = candidate_moves[idx].x;
|
||||
int j = candidate_moves[idx].y;
|
||||
|
||||
ThreatLevel player_threat = detect_threat(i, j, PLAYER);
|
||||
if (player_threat >= THREAT_FOUR)
|
||||
{
|
||||
// 必须阻止玩家的四子威胁
|
||||
board[i][j] = AI;
|
||||
steps[step_count++] = (Step){AI, i, j};
|
||||
printf("AI落子(%d, %d) - 防守!\n", i + 1, j + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 检查是否需要阻止玩家的活三威胁
|
||||
for (int idx = 0; idx < move_count; idx++)
|
||||
{
|
||||
int i = candidate_moves[idx].x;
|
||||
int j = candidate_moves[idx].y;
|
||||
|
||||
ThreatLevel player_threat = detect_threat(i, j, PLAYER);
|
||||
if (player_threat == THREAT_THREE)
|
||||
{
|
||||
// 阻止玩家的活三
|
||||
board[i][j] = AI;
|
||||
steps[step_count++] = (Step){AI, i, j};
|
||||
printf("AI落子(%d, %d) - 阻止活三!\n", i + 1, j + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 2. 寻找最佳进攻位置
|
||||
// 优先考虑能形成威胁的位置
|
||||
for (int idx = 0; idx < move_count; idx++)
|
||||
{
|
||||
int i = candidate_moves[idx].x;
|
||||
int j = candidate_moves[idx].y;
|
||||
|
||||
ThreatLevel ai_threat = detect_threat(i, j, AI);
|
||||
if (ai_threat >= THREAT_FOUR)
|
||||
{
|
||||
// 形成四子威胁
|
||||
board[i][j] = AI;
|
||||
steps[step_count++] = (Step){AI, i, j};
|
||||
printf("AI落子(%d, %d) - 形成威胁!\n", i + 1, j + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 寻找能形成活三的位置
|
||||
for (int idx = 0; idx < move_count; idx++)
|
||||
{
|
||||
int i = candidate_moves[idx].x;
|
||||
int j = candidate_moves[idx].y;
|
||||
|
||||
ThreatLevel ai_threat = detect_threat(i, j, AI);
|
||||
if (ai_threat == THREAT_THREE)
|
||||
{
|
||||
// 形成活三
|
||||
board[i][j] = AI;
|
||||
steps[step_count++] = (Step){AI, i, j};
|
||||
printf("AI落子(%d, %d) - 形成活三!\n", i + 1, j + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. 如果没有明显的威胁机会，选择评分最高的位置
|
||||
if (move_count > 0)
|
||||
{
|
||||
// candidate_moves已经按分数排序，直接选择第一个
|
||||
int best_x = candidate_moves[0].x;
|
||||
int best_y = candidate_moves[0].y;
|
||||
|
||||
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);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 备用方案：如果没有候选移动，随机选择一个位置
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
for (int j = 0; j < BOARD_SIZE; j++)
|
||||
{
|
||||
if (board[i][j] == EMPTY)
|
||||
{
|
||||
board[i][j] = AI;
|
||||
steps[step_count++] = (Step){AI, i, j};
|
||||
printf("AI落子(%d, %d) - 备用位置!\n", i + 1, j + 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== AI增强：辅助函数实现 ====================
|
||||
|
||||
/**
|
||||
* @brief 比较函数，用于移动排序（按分数降序）
|
||||
*/
|
||||
static int compare_moves(const void *a, const void *b)
|
||||
{
|
||||
const ScoredMove *move_a = (const ScoredMove *)a;
|
||||
const ScoredMove *move_b = (const ScoredMove *)b;
|
||||
return move_b->score - move_a->score; // 降序排列
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 生成候选移动并按评估分数排序
|
||||
* @param moves 存储候选移动的数组
|
||||
* @param player 当前玩家
|
||||
* @return 候选移动数量
|
||||
*/
|
||||
int generate_candidate_moves(ScoredMove *moves, int player)
|
||||
{
|
||||
int count = 0;
|
||||
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
for (int j = 0; j < BOARD_SIZE; j++)
|
||||
{
|
||||
if (board[i][j] != EMPTY)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// 只考虑有意义的位置（附近有棋子）
|
||||
if (step_count > AI_SEARCH_RANGE_THRESHOLD && !is_near_stones(i, j))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// 计算该位置的评估分数
|
||||
moves[count].x = i;
|
||||
moves[count].y = j;
|
||||
|
||||
// 结合威胁检测和位置评估
|
||||
ThreatLevel threat = detect_threat(i, j, player);
|
||||
int base_score = evaluate_move(i, j);
|
||||
|
||||
// 根据威胁等级调整分数
|
||||
switch (threat)
|
||||
{
|
||||
case THREAT_WIN:
|
||||
moves[count].score = base_score + 10000;
|
||||
break;
|
||||
case THREAT_FOUR:
|
||||
moves[count].score = base_score + 5000;
|
||||
break;
|
||||
case THREAT_THREE:
|
||||
moves[count].score = base_score + 2000;
|
||||
break;
|
||||
case THREAT_DOUBLE:
|
||||
moves[count].score = base_score + 1000;
|
||||
break;
|
||||
case THREAT_POTENTIAL:
|
||||
moves[count].score = base_score + 500;
|
||||
break;
|
||||
default:
|
||||
moves[count].score = base_score;
|
||||
break;
|
||||
}
|
||||
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// 按分数降序排序
|
||||
qsort(moves, count, sizeof(ScoredMove), compare_moves);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 检查位置是否在已有棋子附近
|
||||
* @param x, y 要检查的位置
|
||||
* @return 如果附近有棋子返回true
|
||||
*/
|
||||
bool is_near_stones(int x, int y)
|
||||
{
|
||||
for (int di = -AI_NEARBY_RANGE; di <= AI_NEARBY_RANGE; di++)
|
||||
{
|
||||
for (int dj = -AI_NEARBY_RANGE; dj <= AI_NEARBY_RANGE; dj++)
|
||||
{
|
||||
int ni = x + di;
|
||||
int nj = y + dj;
|
||||
if (ni >= 0 && ni < BOARD_SIZE && nj >= 0 && nj < BOARD_SIZE)
|
||||
{
|
||||
if (board[ni][nj] != EMPTY)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 检测在指定位置落子的威胁等级
|
||||
* @param x, y 落子位置
|
||||
* @param player 落子玩家
|
||||
* @return 威胁等级
|
||||
*/
|
||||
ThreatLevel detect_threat(int x, int y, int player)
|
||||
{
|
||||
// 模拟落子
|
||||
board[x][y] = player;
|
||||
|
||||
ThreatLevel max_threat = THREAT_NONE;
|
||||
int threat_count = 0;
|
||||
|
||||
// 检查四个方向
|
||||
for (int k = 0; k < 4; k++)
|
||||
{
|
||||
DirInfo info = count_specific_direction(x, y, direction[k][0], direction[k][1], player);
|
||||
ThreatLevel current_threat = THREAT_NONE;
|
||||
|
||||
// 检查是否形成五子连珠（获胜）
|
||||
if (info.continuous_chess >= 5)
|
||||
{
|
||||
current_threat = THREAT_WIN;
|
||||
}
|
||||
// 检查是否形成活四或冲四
|
||||
else if (info.continuous_chess == 4)
|
||||
{
|
||||
if (info.check_start && info.check_end)
|
||||
{
|
||||
current_threat = THREAT_FOUR; // 活四
|
||||
}
|
||||
else if (info.check_start || info.check_end)
|
||||
{
|
||||
current_threat = THREAT_FOUR; // 冲四
|
||||
}
|
||||
}
|
||||
// 检查是否形成活三
|
||||
else if (info.continuous_chess == 3 && info.check_start && info.check_end)
|
||||
{
|
||||
current_threat = THREAT_THREE;
|
||||
}
|
||||
// 检查潜在威胁
|
||||
else if (info.continuous_chess >= 2)
|
||||
{
|
||||
current_threat = THREAT_POTENTIAL;
|
||||
}
|
||||
|
||||
if (current_threat > max_threat)
|
||||
{
|
||||
max_threat = current_threat;
|
||||
}
|
||||
|
||||
if (current_threat >= THREAT_THREE)
|
||||
{
|
||||
threat_count++;
|
||||
}
|
||||
}
|
||||
|
||||
// 恢复棋盘
|
||||
board[x][y] = EMPTY;
|
||||
|
||||
// 如果有多个威胁，提升威胁等级
|
||||
if (threat_count >= 2 && max_threat >= THREAT_THREE)
|
||||
{
|
||||
max_threat = THREAT_DOUBLE;
|
||||
}
|
||||
|
||||
return max_threat;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 计算指定方向的威胁数量
|
||||
* @param x, y 起始位置
|
||||
* @param dx, dy 方向向量
|
||||
* @param player 玩家
|
||||
* @return 威胁数量
|
||||
*/
|
||||
int count_threats_in_direction(int x, int y, int dx, int dy, int player)
|
||||
{
|
||||
int threats = 0;
|
||||
|
||||
// 向前搜索
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
int nx = x + i * dx;
|
||||
int ny = y + i * dy;
|
||||
|
||||
if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (board[nx][ny] == player)
|
||||
{
|
||||
threats++;
|
||||
}
|
||||
else if (board[nx][ny] != EMPTY)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 向后搜索
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
int nx = x - i * dx;
|
||||
int ny = y - i * dy;
|
||||
|
||||
if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (board[nx][ny] == player)
|
||||
{
|
||||
threats++;
|
||||
}
|
||||
else if (board[nx][ny] != EMPTY)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return threats;
|
||||
}
|
||||
+254
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* @file config.c
|
||||
* @brief 五子棋游戏参数配置源文件
|
||||
* @note 本文件集中定义了五子棋游戏的所有参数配置，便于统一管理和修改
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include "ui.h"
|
||||
#include "game_mode.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief 加载游戏配置
|
||||
*/
|
||||
void load_game_config()
|
||||
{
|
||||
FILE *file = fopen(CONFIG_FILE, "r");
|
||||
if (file == NULL)
|
||||
{
|
||||
// 配置文件不存在，使用默认配置
|
||||
printf("配置文件不存在，使用默认配置\n");
|
||||
return;
|
||||
}
|
||||
|
||||
char line[256];
|
||||
while (fgets(line, sizeof(line), file))
|
||||
{
|
||||
// 去除换行符
|
||||
line[strcspn(line, "\n")] = 0;
|
||||
|
||||
// 解析配置项
|
||||
if (strncmp(line, "BOARD_SIZE=", 11) == 0)
|
||||
{
|
||||
int size = atoi(line + 11);
|
||||
if (size >= MIN_BOARD_SIZE && size <= MAX_BOARD_SIZE)
|
||||
{
|
||||
BOARD_SIZE = size;
|
||||
}
|
||||
}
|
||||
else if (strncmp(line, "USE_FORBIDDEN_MOVES=", 20) == 0)
|
||||
{
|
||||
use_forbidden_moves = (atoi(line + 20) != 0);
|
||||
}
|
||||
else if (strncmp(line, "USE_TIMER=", 10) == 0)
|
||||
{
|
||||
use_timer = atoi(line + 10);
|
||||
}
|
||||
else if (strncmp(line, "TIME_LIMIT=", 11) == 0)
|
||||
{
|
||||
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)
|
||||
{
|
||||
int difficulty = atoi(line + 14);
|
||||
if (difficulty >= 1 && difficulty <= 5)
|
||||
{
|
||||
// 根据难度设置AI搜索深度
|
||||
// 这里可以添加AI难度相关的配置
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fclose(file);
|
||||
printf("配置加载完成\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 保存游戏配置
|
||||
*/
|
||||
void save_game_config()
|
||||
{
|
||||
FILE *file = fopen(CONFIG_FILE, "w");
|
||||
if (file == NULL)
|
||||
{
|
||||
printf("无法保存配置文件\n");
|
||||
return;
|
||||
}
|
||||
|
||||
fprintf(file, "# 五子棋游戏配置文件\n");
|
||||
fprintf(file, "# 棋盘大小 (范围: %d-%d)\n", MIN_BOARD_SIZE, MAX_BOARD_SIZE);
|
||||
fprintf(file, "BOARD_SIZE=%d\n", BOARD_SIZE);
|
||||
fprintf(file, "\n# 禁手规则 (0=关闭, 1=开启)\n");
|
||||
fprintf(file, "USE_FORBIDDEN_MOVES=%d\n", use_forbidden_moves ? 1 : 0);
|
||||
fprintf(file, "\n# 计时器 (0=关闭, 1=开启)\n");
|
||||
fprintf(file, "USE_TIMER=%d\n", use_timer);
|
||||
fprintf(file, "\n# 时间限制 (分钟)\n");
|
||||
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);
|
||||
printf("配置保存完成\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 重置为默认配置
|
||||
*/
|
||||
void reset_to_default_config()
|
||||
{
|
||||
BOARD_SIZE = DEFAULT_BOARD_SIZE;
|
||||
use_forbidden_moves = DEFAULT_USE_FORBIDDEN_MOVES;
|
||||
use_timer = DEFAULT_USE_TIMER;
|
||||
time_limit = DEFAULT_TIME_LIMIT;
|
||||
network_port = DEFAULT_NETWORK_PORT;
|
||||
network_timeout = NETWORK_TIMEOUT_MS;
|
||||
|
||||
printf("已重置为默认配置\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示当前配置
|
||||
*/
|
||||
void display_current_config()
|
||||
{
|
||||
printf("\n===== 当前游戏配置 =====\n");
|
||||
printf("棋盘大小: %d x %d\n", BOARD_SIZE, BOARD_SIZE);
|
||||
printf("禁手规则: %s\n", use_forbidden_moves ? "开启" : "关闭");
|
||||
printf("计时器: %s\n", use_timer ? "开启" : "关闭");
|
||||
if (use_timer)
|
||||
{
|
||||
printf("时间限制: %d 分钟\n", time_limit / 60);
|
||||
}
|
||||
printf("网络端口: %d\n", network_port);
|
||||
printf("网络超时: %d 毫秒\n", network_timeout);
|
||||
printf("=====================\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 配置棋盘大小
|
||||
*/
|
||||
void config_board_size()
|
||||
{
|
||||
printf("\n当前棋盘大小: %d x %d\n", BOARD_SIZE, BOARD_SIZE);
|
||||
|
||||
int new_size = get_integer_input("请输入新的棋盘大小: ", MIN_BOARD_SIZE, MAX_BOARD_SIZE);
|
||||
BOARD_SIZE = new_size;
|
||||
printf("棋盘大小已设置为: %d x %d\n", BOARD_SIZE, BOARD_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 配置禁手规则
|
||||
*/
|
||||
void config_forbidden_moves()
|
||||
{
|
||||
printf("\n当前禁手规则: %s\n", use_forbidden_moves ? "开启" : "关闭");
|
||||
|
||||
int choice = get_integer_input("是否启用禁手规则？(1=开启, 0=关闭): ", 0, 1);
|
||||
use_forbidden_moves = (choice != 0);
|
||||
printf("禁手规则已%s\n", use_forbidden_moves ? "开启" : "关闭");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 配置计时器
|
||||
*/
|
||||
void config_timer()
|
||||
{
|
||||
printf("\n当前计时器: %s\n", use_timer ? "开启" : "关闭");
|
||||
|
||||
int choice = get_integer_input("是否启用计时器？(1=开启, 0=关闭): ", 0, 1);
|
||||
use_timer = choice;
|
||||
if (use_timer)
|
||||
{
|
||||
int new_limit = get_integer_input("请输入时间限制(分钟): ", 1, 999);
|
||||
time_limit = new_limit * 60; // 转换为秒数存储
|
||||
printf("计时器已开启，时间限制: %d 分钟\n", time_limit / 60);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("计时器已关闭\n");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 配置网络参数
|
||||
*/
|
||||
void config_network()
|
||||
{
|
||||
printf("\n===== 网络配置 =====\n");
|
||||
printf("当前网络端口: %d\n", network_port);
|
||||
printf("当前网络超时: %d 毫秒\n", network_timeout);
|
||||
|
||||
int new_port = get_integer_input("请输入新的网络端口: ", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
|
||||
network_port = new_port;
|
||||
printf("网络端口已设置为: %d\n", network_port);
|
||||
|
||||
int new_timeout = get_integer_input("请输入网络超时时间(毫秒, 建议1000-10000): ", 1000, 60000);
|
||||
network_timeout = new_timeout;
|
||||
printf("网络超时已设置为: %d 毫秒\n", network_timeout);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 配置管理主菜单
|
||||
*/
|
||||
void config_management_menu()
|
||||
{
|
||||
int choice;
|
||||
|
||||
while (1)
|
||||
{
|
||||
clear_screen();
|
||||
display_settings_menu();
|
||||
display_current_config();
|
||||
|
||||
choice = get_integer_input("请选择操作(0-5): ", 0, 5);
|
||||
|
||||
switch (choice)
|
||||
{
|
||||
case 1:
|
||||
config_board_size();
|
||||
break;
|
||||
case 2:
|
||||
config_forbidden_moves();
|
||||
break;
|
||||
case 3:
|
||||
config_timer();
|
||||
break;
|
||||
case 4:
|
||||
config_network();
|
||||
break;
|
||||
case 5:
|
||||
printf("AI难度设置功能开发中...\n");
|
||||
break;
|
||||
case 0:
|
||||
save_game_config();
|
||||
return;
|
||||
default:
|
||||
printf("无效的选择！\n");
|
||||
break;
|
||||
}
|
||||
|
||||
pause_for_input("按任意键继续...");
|
||||
}
|
||||
}
|
||||
+973
@@ -0,0 +1,973 @@
|
||||
/**
|
||||
* @file game_mode.c
|
||||
* @brief 五子棋游戏框架源文件
|
||||
* @note 本文件定义了五子棋游戏的四种主要模式：
|
||||
* 1. AI对战模式
|
||||
* 2. 双人对战模式
|
||||
* 3. 网络对战模式
|
||||
* 4. 复盘模式
|
||||
*/
|
||||
|
||||
#include "game_mode.h"
|
||||
#include "init_board.h"
|
||||
#include "gobang.h"
|
||||
#include "ai.h"
|
||||
#include "record.h"
|
||||
#include "config.h"
|
||||
#include "network.h"
|
||||
#include "ui.h"
|
||||
#include "gui.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
#include <ctype.h>
|
||||
|
||||
// 全局变量现在在globals.c中定义
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#include <direct.h>
|
||||
#include <conio.h>
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief 从用户获取整数输入
|
||||
*
|
||||
* @param prompt 提示信息
|
||||
* @param min 最小值
|
||||
* @param max 最大值
|
||||
* @return int 用户输入的整数
|
||||
*/
|
||||
int get_integer_input(const char *prompt, int min, int max)
|
||||
{
|
||||
int value;
|
||||
int result;
|
||||
char ch;
|
||||
|
||||
while (1)
|
||||
{
|
||||
printf("%s", prompt);
|
||||
result = scanf("%d", &value);
|
||||
|
||||
if (result == 1 && value >= min && value <= max)
|
||||
{
|
||||
// 清除输入缓冲区中剩余的字符
|
||||
while ((ch = getchar()) != '\n' && ch != EOF)
|
||||
;
|
||||
return value;
|
||||
}
|
||||
else
|
||||
{
|
||||
// 清除无效输入
|
||||
while ((ch = getchar()) != '\n' && ch != EOF)
|
||||
;
|
||||
printf("输入无效，请输入一个介于 %d 和 %d 之间的整数。\n", min, max);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 处理玩家回合
|
||||
*
|
||||
* @param current_player
|
||||
* @return true
|
||||
* @return false
|
||||
*/
|
||||
bool parse_player_input(int *x, int *y)
|
||||
{
|
||||
char input[10];
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (_kbhit())
|
||||
{
|
||||
scanf("%s", input);
|
||||
break;
|
||||
}
|
||||
Sleep(100); // 短暂延迟以防止CPU占用过高
|
||||
}
|
||||
|
||||
if (sscanf(input, "%d", x) == 1)
|
||||
{
|
||||
// 成功解析第一个数字，现在解析第二个
|
||||
if (scanf("%d", y) != 1)
|
||||
{
|
||||
// 如果第二个数字不可用，则检查特殊命令
|
||||
if (*x == INPUT_UNDO)
|
||||
{
|
||||
int steps_to_undo;
|
||||
steps_to_undo = get_integer_input("请输入要悔棋的步数(双方各退步数相同): ", 1, step_count / 2);
|
||||
if (return_move(steps_to_undo * 2))
|
||||
{
|
||||
printf("成功悔棋，双方各退 %d 步！\n", steps_to_undo);
|
||||
print_board();
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("无法悔棋！\n");
|
||||
}
|
||||
return 0; // 特殊命令已处理
|
||||
}
|
||||
else if (*x == INPUT_SAVE)
|
||||
{
|
||||
// ... 处理保存 ...
|
||||
return false; // 特殊命令
|
||||
}
|
||||
else if (*x == INPUT_EXIT)
|
||||
{
|
||||
// ... 处理退出 ...
|
||||
return false; // 特殊命令
|
||||
}
|
||||
printf("无效输入，请输入两个数字坐标。\n");
|
||||
while (getchar() != '\n')
|
||||
;
|
||||
return 0; // 无效输入
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// sscanf失败，检查特殊命令
|
||||
if (input[0] == 'r' || input[0] == 'R')
|
||||
{
|
||||
int steps_to_undo;
|
||||
steps_to_undo = get_integer_input("请输入要悔棋的步数(双方各退步数相同): ", 1, step_count / 2);
|
||||
if (return_move(steps_to_undo * 2))
|
||||
{
|
||||
printf("成功悔棋，双方各退 %d 步！\n", steps_to_undo);
|
||||
print_board();
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("无法悔棋！\n");
|
||||
}
|
||||
return false; // 特殊命令
|
||||
}
|
||||
else if (input[0] == 's' || input[0] == 'S')
|
||||
{
|
||||
*x = INPUT_SURRENDER;
|
||||
int confirm = get_integer_input("确认认输？(1:是/0:否): ", 0, 1);
|
||||
if (confirm)
|
||||
{
|
||||
printf("玩家选择认输！\n");
|
||||
return 1; // 正常回合完成 // 返回认输命令
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("取消认输！\n");
|
||||
return false; // 取消认输
|
||||
}
|
||||
}
|
||||
printf("无效输入，请输入数字坐标、'r'悔棋或's'认输。\n");
|
||||
return 0; // 无效输入
|
||||
}
|
||||
return 1; // 有效坐标
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 解析网络对战模式下的玩家输入
|
||||
* @param x 行坐标指针
|
||||
* @param y 列坐标指针
|
||||
* @return true 有效坐标输入
|
||||
* @return false 特殊命令或无效输入
|
||||
*/
|
||||
bool parse_network_player_input(int *x, int *y)
|
||||
{
|
||||
char input[10];
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (_kbhit())
|
||||
{
|
||||
scanf("%s", input);
|
||||
break;
|
||||
}
|
||||
Sleep(100); // 短暂延迟以防止CPU占用过高
|
||||
}
|
||||
|
||||
if (sscanf(input, "%d", x) == 1)
|
||||
{
|
||||
// 成功解析第一个数字，现在解析第二个
|
||||
if (scanf("%d", y) != 1)
|
||||
{
|
||||
printf("无效输入，请输入两个数字坐标。\n");
|
||||
while (getchar() != '\n')
|
||||
;
|
||||
return false; // 无效输入
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// sscanf失败，检查特殊命令
|
||||
if (input[0] == 'r' || input[0] == 'R')
|
||||
{
|
||||
int steps_to_undo;
|
||||
steps_to_undo = get_integer_input("请输入要悔棋的步数(双方各退步数相同): ", 1, step_count / 2);
|
||||
|
||||
printf("发送悔棋请求给对方...\n");
|
||||
if (send_undo_request(steps_to_undo))
|
||||
{
|
||||
printf("悔棋请求已发送，等待对方回应...\n");
|
||||
|
||||
// 等待对方回应
|
||||
NetworkMessage msg;
|
||||
time_t start_time = time(NULL);
|
||||
|
||||
while (difftime(time(NULL), start_time) < 30) // 30秒超时
|
||||
{
|
||||
if (receive_network_message(&msg, 1000))
|
||||
{
|
||||
if (msg.type == MSG_UNDO_RESPONSE && msg.x == steps_to_undo)
|
||||
{
|
||||
if (msg.y == 1) // 对方同意
|
||||
{
|
||||
if (return_move(steps_to_undo * 2))
|
||||
{
|
||||
printf("对方同意悔棋，双方各退 %d 步！\n", steps_to_undo);
|
||||
print_board();
|
||||
return 2; // 悔棋成功，需要重新开始回合
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("悔棋失败！\n");
|
||||
return 0; // 悔棋失败，继续当前回合
|
||||
}
|
||||
}
|
||||
else // 对方拒绝
|
||||
{
|
||||
printf("对方拒绝了悔棋请求。\n");
|
||||
return 0; // 悔棋被拒绝，继续当前回合
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!is_network_connected())
|
||||
{
|
||||
printf("网络连接断开\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
printf("悔棋请求超时，对方未回应。\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("发送悔棋请求失败！\n");
|
||||
}
|
||||
return 0; // 特殊命令已处理
|
||||
}
|
||||
else if (input[0] == 's' || input[0] == 'S')
|
||||
{
|
||||
*x = INPUT_SURRENDER;
|
||||
int confirm = get_integer_input("确认认输？(1:是/0:否): ", 0, 1);
|
||||
if (confirm)
|
||||
{
|
||||
printf("你选择认输！\n");
|
||||
*x = INPUT_SURRENDER;
|
||||
return -1; // 返回认输命令
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("取消认输！\n");
|
||||
return 0; // 取消认输
|
||||
}
|
||||
}
|
||||
printf("无效输入，请输入数字坐标、'r'悔棋或's'认输。\n");
|
||||
return false; // 无效输入
|
||||
}
|
||||
return true; // 有效坐标
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 处理玩家回合
|
||||
* @param current_player 当前玩家
|
||||
* @return true
|
||||
*/
|
||||
bool handle_player_turn(int current_player)
|
||||
{
|
||||
int x, y;
|
||||
time_t start_time, end_time;
|
||||
if (use_timer)
|
||||
{
|
||||
time(&start_time);
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
printf("\n玩家%d, 请输入落子坐标(行 列，1~%d)，或输入R/r悔棋，S/s认输:", current_player, BOARD_SIZE);
|
||||
|
||||
bool input_received = false;
|
||||
while (!input_received)
|
||||
{
|
||||
if (use_timer)
|
||||
{
|
||||
time(&end_time);
|
||||
if (difftime(end_time, start_time) > time_limit)
|
||||
{
|
||||
printf("\n玩家%d超时, 对方获胜！\n", current_player);
|
||||
return false; // Timeout
|
||||
}
|
||||
}
|
||||
|
||||
if (parse_player_input(&x, &y))
|
||||
{
|
||||
if (x == INPUT_SURRENDER)
|
||||
{
|
||||
printf("\n玩家%d选择认输，对方获胜！\n", current_player);
|
||||
return false; // 游戏结束，认输
|
||||
}
|
||||
input_received = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// 已处理特殊命令或无效输入，继续循环
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
x--;
|
||||
y--;
|
||||
|
||||
if (player_move(x, y, current_player))
|
||||
{
|
||||
break; // 成功落子，跳出循环
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("坐标无效！请重新输入。\n");
|
||||
// 继续循环，重新输入坐标
|
||||
}
|
||||
}
|
||||
print_board();
|
||||
|
||||
if (check_win(x, y, current_player))
|
||||
{
|
||||
printf("\n玩家%d获胜！\n", current_player);
|
||||
return false; // 游戏结束
|
||||
}
|
||||
|
||||
return true; // 成功落子
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 运行AI游戏
|
||||
* @note 从文件中加载历史记录并进行复盘
|
||||
* @param AI_DEPTH AI的搜索深度
|
||||
*/
|
||||
void run_ai_game()
|
||||
{
|
||||
// 重置评分计算标志，确保每局游戏都会重新计算评分
|
||||
scores_calculated = 0;
|
||||
|
||||
// AI对战模式
|
||||
int AI_DEPTH = DEFAULT_AI_DEPTH;
|
||||
AI_DEPTH = get_integer_input("请选择AI难度(1~5), 数字越大越强，注意数字越大AI思考时间越长！):", 1, 5);
|
||||
|
||||
/**
|
||||
* @brief AI的防守系数，系数越大越倾向于防守
|
||||
* @note 1~1.5
|
||||
* 2~1.6
|
||||
* 3~1.7
|
||||
* 4~1.8
|
||||
* 5~1.9
|
||||
*/
|
||||
defense_coefficient = DEFAULT_DEFENSE_COEFFICIENT + (AI_DEPTH - 1) * 0.1;
|
||||
|
||||
empty_board();
|
||||
int current_player = determine_first_player(PLAYER, AI);
|
||||
print_board();
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (current_player == PLAYER)
|
||||
{
|
||||
int old_step_count = step_count;
|
||||
if (!handle_player_turn(current_player))
|
||||
{
|
||||
break; // 游戏结束或超时
|
||||
}
|
||||
if (step_count > old_step_count)
|
||||
{
|
||||
// 检查玩家是否获胜
|
||||
Step last_step = steps[step_count - 1];
|
||||
if (check_win(last_step.x, last_step.y, PLAYER))
|
||||
{
|
||||
printf("\n玩家获胜！\n");
|
||||
break;
|
||||
}
|
||||
current_player = AI;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\nAI思考中...\n");
|
||||
time_t start_time, end_time;
|
||||
if (use_timer)
|
||||
{
|
||||
time(&start_time);
|
||||
}
|
||||
|
||||
ai_move(AI_DEPTH);
|
||||
|
||||
if (use_timer)
|
||||
{
|
||||
time(&end_time);
|
||||
if (difftime(end_time, start_time) > time_limit)
|
||||
{
|
||||
printf("\nAI超时, 玩家获胜！\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
print_board();
|
||||
Step last_step = steps[step_count - 1];
|
||||
if (check_win(last_step.x, last_step.y, AI))
|
||||
{
|
||||
printf("\nAI获胜！\n");
|
||||
break;
|
||||
}
|
||||
current_player = PLAYER;
|
||||
}
|
||||
|
||||
if (step_count == BOARD_SIZE * BOARD_SIZE)
|
||||
{
|
||||
printf("\n平局！\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("===== 游戏结束 =====\n");
|
||||
review_process(GAME_MODE_AI); // AI对战模式
|
||||
handle_save_record(GAME_MODE_AI); // AI对战模式
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 运行双人对战模式
|
||||
* @note 从文件中加载历史记录并进行复盘
|
||||
*/
|
||||
void run_pvp_game()
|
||||
{
|
||||
// 重置评分计算标志，确保每局游戏都会重新计算评分
|
||||
scores_calculated = 0;
|
||||
|
||||
// 双人对战模式
|
||||
empty_board();
|
||||
int current_player = determine_first_player(PLAYER1, PLAYER2);
|
||||
print_board();
|
||||
|
||||
while (1)
|
||||
{
|
||||
int old_step_count = step_count;
|
||||
if (!handle_player_turn(current_player))
|
||||
{
|
||||
break; // 游戏结束或超时
|
||||
}
|
||||
|
||||
if (step_count == BOARD_SIZE * BOARD_SIZE)
|
||||
{
|
||||
printf("\n平局！\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (step_count > old_step_count)
|
||||
{
|
||||
current_player = (current_player == PLAYER1) ? PLAYER2 : PLAYER1;
|
||||
}
|
||||
}
|
||||
printf("===== 游戏结束 =====\n");
|
||||
review_process(GAME_MODE_PVP); // 双人对战模式
|
||||
handle_save_record(GAME_MODE_PVP); // 双人对战模式
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 运行复盘模式
|
||||
* @note 从文件中加载历史记录并进行复盘
|
||||
*/
|
||||
void run_review_mode()
|
||||
{
|
||||
char filename[100];
|
||||
char record_files[100][100];
|
||||
int file_count = 0;
|
||||
|
||||
#ifdef _WIN32
|
||||
WIN32_FIND_DATA ffd;
|
||||
HANDLE hFind = FindFirstFile("records\\*", &ffd);
|
||||
if (hFind != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
do
|
||||
{
|
||||
if (!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
||||
{
|
||||
strcpy(record_files[file_count++], ffd.cFileName);
|
||||
}
|
||||
} while (FindNextFile(hFind, &ffd) != 0);
|
||||
FindClose(hFind);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (file_count > 0)
|
||||
{
|
||||
printf("发现以下复盘文件:\n");
|
||||
for (int i = 0; i < file_count; i++)
|
||||
{
|
||||
printf("%d. %s\n", i + 1, record_files[i]);
|
||||
}
|
||||
|
||||
char prompt[150];
|
||||
sprintf(prompt, "请输入复盘文件编号(1-%d)，或输入0以手动输入文件名: ", file_count);
|
||||
int choice = get_integer_input(prompt, 0, file_count);
|
||||
|
||||
if (choice > 0)
|
||||
{
|
||||
strcpy(filename, record_files[choice - 1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("请输入完整文件名: ");
|
||||
scanf("%s", filename);
|
||||
int c;
|
||||
while ((c = getchar()) != '\n' && c != EOF)
|
||||
;
|
||||
|
||||
int possible_choice = atoi(filename);
|
||||
if (possible_choice > 0 && possible_choice <= file_count)
|
||||
{
|
||||
strcpy(filename, record_files[possible_choice - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("未找到任何复盘文件，请输入复盘文件地址: ");
|
||||
scanf("%s", filename);
|
||||
int c;
|
||||
while ((c = getchar()) != '\n' && c != EOF)
|
||||
;
|
||||
}
|
||||
|
||||
int game_mode = load_game_from_file(filename);
|
||||
if (game_mode != 0)
|
||||
{
|
||||
if (game_mode == 1)
|
||||
{
|
||||
printf("加载AI对战模式复盘文件成功！\n");
|
||||
}
|
||||
else if (game_mode == 2)
|
||||
{
|
||||
printf("加载双人对战模式复盘文件成功！\n");
|
||||
}
|
||||
review_process(game_mode);
|
||||
}
|
||||
else
|
||||
{
|
||||
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];
|
||||
|
||||
// 循环直到输入有效的IP地址或用户选择退出
|
||||
while (1)
|
||||
{
|
||||
printf("请输入服务器IP地址 (输入'exit'退出): ");
|
||||
if (scanf("%s", ip) != 1)
|
||||
{
|
||||
printf("输入错误，请重新输入。\n");
|
||||
// 清除输入缓冲区
|
||||
while (getchar() != '\n');
|
||||
continue;
|
||||
}
|
||||
|
||||
// 检查是否要退出
|
||||
if (strcmp(ip, "exit") == 0 || strcmp(ip, "EXIT") == 0)
|
||||
{
|
||||
printf("取消连接，返回主菜单。\n");
|
||||
cleanup_network();
|
||||
pause_for_input("按任意键返回主菜单...");
|
||||
return;
|
||||
}
|
||||
|
||||
// 简单的IP地址格式验证
|
||||
if (strlen(ip) < 7 || strlen(ip) > 15)
|
||||
{
|
||||
printf("IP地址格式错误！请输入有效的IP地址（如：192.168.1.100）\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
// 检查IP地址是否包含有效字符
|
||||
bool valid_ip = true;
|
||||
for (int i = 0; i < strlen(ip); i++)
|
||||
{
|
||||
if (!(isdigit(ip[i]) || ip[i] == '.'))
|
||||
{
|
||||
valid_ip = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!valid_ip)
|
||||
{
|
||||
printf("IP地址格式错误！只能包含数字和点号。\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
// 检查点号数量
|
||||
int dot_count = 0;
|
||||
for (int i = 0; i < strlen(ip); i++)
|
||||
{
|
||||
if (ip[i] == '.') dot_count++;
|
||||
}
|
||||
|
||||
if (dot_count != 3)
|
||||
{
|
||||
printf("IP地址格式错误！应包含3个点号（如：192.168.1.100）\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
printf("输入的IP地址: %s\n", ip);
|
||||
int confirm = get_integer_input("确认连接到此IP？(1:是/0:否，重新输入): ", 0, 1);
|
||||
if (confirm)
|
||||
{
|
||||
break; // 确认IP地址，跳出循环
|
||||
}
|
||||
// 如果选择否，继续循环重新输入
|
||||
}
|
||||
|
||||
int port = get_integer_input("请输入服务器端口(默认8888): ", MIN_NETWORK_PORT, MAX_NETWORK_PORT);
|
||||
if (port == 0) port = network_port;
|
||||
|
||||
printf("\n正在连接到服务器 %s:%d...\n", ip, port);
|
||||
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(GAME_MODE_NETWORK); // 网络对战模式的复盘
|
||||
handle_save_record(GAME_MODE_NETWORK); // 保存为网络对战模式记录
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("游戏因网络错误而结束\n");
|
||||
}
|
||||
|
||||
// 清理网络连接
|
||||
disconnect_network();
|
||||
pause_for_input("按任意键返回主菜单...");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示游戏规则
|
||||
*/
|
||||
void show_game_rules()
|
||||
{
|
||||
clear_screen();
|
||||
display_game_rules();
|
||||
pause_for_input("\n按任意键返回主菜单...");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示关于游戏信息
|
||||
*/
|
||||
void show_about_game()
|
||||
{
|
||||
clear_screen();
|
||||
display_about();
|
||||
pause_for_input("\n按任意键返回主菜单...");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 启动图形化界面
|
||||
*/
|
||||
void run_gui_mode()
|
||||
{
|
||||
if (init_gui() == 0)
|
||||
{
|
||||
printf("启动图形化界面...\n");
|
||||
printf("图形化界面已启动，窗口应该可见\n");
|
||||
printf("如果看不到窗口，请检查任务栏或按Alt+Tab切换\n");
|
||||
while (gui_running && handle_events())
|
||||
{
|
||||
render_game();
|
||||
SDL_Delay(16); // 约60FPS
|
||||
}
|
||||
printf("退出图形化界面\n");
|
||||
cleanup_gui();
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("图形化界面启动失败！请检查SDL3库是否正确安装。\n");
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
while (1)
|
||||
{
|
||||
printf("\n轮到你了，请输入落子坐标(行 列，1~%d)，或输入R/r悔棋，S/s认输: ", BOARD_SIZE);
|
||||
|
||||
bool input_received = false;
|
||||
while (!input_received)
|
||||
{
|
||||
if (use_timer)
|
||||
{
|
||||
time(&end_time);
|
||||
if (difftime(end_time, start_time) > time_limit)
|
||||
{
|
||||
printf("\n你超时了，对方获胜！\n");
|
||||
send_surrender(); // 发送认输消息
|
||||
return 0; // 游戏结束
|
||||
}
|
||||
}
|
||||
|
||||
int parse_result = parse_network_player_input(&x, &y);
|
||||
if (parse_result == 1) // 有效坐标输入
|
||||
{
|
||||
input_received = true;
|
||||
}
|
||||
else if (parse_result == -1) // 认输命令
|
||||
{
|
||||
printf("\n你选择认输，对方获胜！\n");
|
||||
send_surrender();
|
||||
return 0; // 游戏结束
|
||||
}
|
||||
else if (parse_result == 2) // 悔棋成功
|
||||
{
|
||||
return 2; // 悔棋发生，需要重新开始回合
|
||||
}
|
||||
else // parse_result == 0, 特殊命令已处理或无效输入
|
||||
{
|
||||
// 继续等待输入
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
x--; y--; // 转换为0-based坐标
|
||||
|
||||
if (player_move(x, y, current_player))
|
||||
{
|
||||
break; // 成功落子，跳出循环
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("坐标无效！请重新输入。\n");
|
||||
// 继续循环，重新输入坐标
|
||||
}
|
||||
}
|
||||
|
||||
// 发送落子消息
|
||||
if (!send_move(x, y, current_player))
|
||||
{
|
||||
printf("发送落子消息失败！\n");
|
||||
return 0; // 游戏结束
|
||||
}
|
||||
|
||||
print_board();
|
||||
|
||||
if (check_win(x, y, current_player))
|
||||
{
|
||||
printf("\n你获胜了！\n");
|
||||
return 0; // 游戏结束
|
||||
}
|
||||
|
||||
}
|
||||
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 0; // 游戏结束
|
||||
}
|
||||
|
||||
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 0; // 游戏结束
|
||||
}
|
||||
break;
|
||||
|
||||
}
|
||||
else if (msg.type == MSG_SURRENDER)
|
||||
{
|
||||
printf("\n对方认输，你获胜了！\n");
|
||||
return 0; // 游戏结束
|
||||
|
||||
}
|
||||
else if (msg.type == MSG_DISCONNECT)
|
||||
{
|
||||
printf("\n对方已断开连接\n");
|
||||
return 0; // 游戏结束
|
||||
|
||||
}
|
||||
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();
|
||||
// 悔棋后需要重新开始当前回合，不改变current_player
|
||||
return 2; // 悔棋发生，需要重新开始回合
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("拒绝悔棋\n");
|
||||
send_undo_response(false, steps);
|
||||
// 继续等待对方落子
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 检查超时
|
||||
if (use_timer && difftime(time(NULL), start_time) > time_limit)
|
||||
{
|
||||
printf("\n对方超时，你获胜！\n");
|
||||
return 0; // 游戏结束
|
||||
}
|
||||
|
||||
// 检查网络连接
|
||||
if (!is_network_connected())
|
||||
{
|
||||
printf("\n网络连接断开\n");
|
||||
return 0; // 游戏结束
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1; // 正常回合完成
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 网络游戏主循环
|
||||
*/
|
||||
bool network_game_loop()
|
||||
{
|
||||
int current_player = PLAYER1; // 总是从玩家1开始
|
||||
|
||||
while (1)
|
||||
{
|
||||
bool is_local_turn = (current_player == network_state.local_player_id);
|
||||
|
||||
int turn_result = handle_network_player_turn(current_player, is_local_turn);
|
||||
if (turn_result == 0) // 游戏结束
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else if (turn_result == 2) // 悔棋发生，重新开始当前回合
|
||||
{
|
||||
continue; // 不切换玩家，重新开始当前回合
|
||||
}
|
||||
|
||||
// 检查平局
|
||||
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;
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
/**
|
||||
* @file globals.c
|
||||
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
|
||||
* @brief 全局变量定义和初始化文件
|
||||
* @note 集中管理所有全局变量的定义和初始化，提高代码可维护性
|
||||
*/
|
||||
|
||||
#include "globals.h"
|
||||
#include "config.h"
|
||||
#include <SDL3/SDL.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}; // 网络游戏状态
|
||||
|
||||
// ==================== GUI相关变量定义 ====================
|
||||
SDL_Window* window = NULL; // SDL窗口指针
|
||||
SDL_Renderer* renderer = NULL; // SDL渲染器指针
|
||||
int gui_running = 1; // GUI运行状态标志
|
||||
int current_player_gui = PLAYER; // GUI当前玩家
|
||||
int game_over = 0; // 游戏结束标志
|
||||
char status_message[256] = "五子棋游戏 - 黑子先行"; // 状态消息
|
||||
|
||||
// ==================== 记录相关变量定义 ====================
|
||||
int player1_final_score = 0; // 玩家1最终得分
|
||||
int player2_final_score = 0; // 玩家2最终得分
|
||||
int scores_calculated = 0; // 评分计算标志
|
||||
char winner_info[50] = "平局或未完成"; // 存储胜负信息
|
||||
+276
@@ -0,0 +1,276 @@
|
||||
/**
|
||||
* @file gobang.c
|
||||
* @brief 五子棋游戏源文件
|
||||
* @note 本文件定义了五子棋游戏的主要数据结构、函数和全局变量。
|
||||
* 它包含了游戏棋盘的表示、玩家操作、规则检查以及AI决策等功能。
|
||||
*/
|
||||
|
||||
#include "game_mode.h"
|
||||
#include "init_board.h"
|
||||
#include "gobang.h"
|
||||
#include "ai.h"
|
||||
#include "record.h"
|
||||
#include "config.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <sys/stat.h>
|
||||
#include <time.h>
|
||||
|
||||
/**
|
||||
* @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 检查是否为禁手
|
||||
*
|
||||
* @param x
|
||||
* @param y
|
||||
* @param player
|
||||
* @return true
|
||||
* @return false
|
||||
*/
|
||||
bool is_forbidden_move(int x, int y, int player)
|
||||
{
|
||||
if (!use_forbidden_moves)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (player != PLAYER && player != PLAYER1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
board[x][y] = player;
|
||||
|
||||
int three_count = 0;
|
||||
int four_count = 0;
|
||||
|
||||
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)
|
||||
{
|
||||
board[x][y] = EMPTY;
|
||||
return true; // 长连禁手
|
||||
}
|
||||
if (info.continuous_chess == 3 && info.check_start && info.check_end)
|
||||
{
|
||||
three_count++;
|
||||
}
|
||||
if (info.continuous_chess == 4 && (info.check_start || info.check_end))
|
||||
{
|
||||
four_count++;
|
||||
}
|
||||
}
|
||||
|
||||
board[x][y] = EMPTY;
|
||||
|
||||
if (three_count >= 2 || four_count >= 2)
|
||||
{
|
||||
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
|
||||
if (!have_space(x, y))
|
||||
return false;
|
||||
|
||||
if (is_forbidden_move(x, y, player))
|
||||
{
|
||||
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 检查正反两个方向，统计连续棋子数并判断端点是否开放
|
||||
*/
|
||||
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; // 终点方向是否开放
|
||||
|
||||
// 检查正方向（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; // 沿当前方向前进
|
||||
ny += dy;
|
||||
}
|
||||
// 判断正方向端点是否开放（遇到空位）
|
||||
if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE)
|
||||
{
|
||||
if (board[nx][ny] == EMPTY)
|
||||
{
|
||||
info.check_end = true;
|
||||
}
|
||||
}
|
||||
|
||||
// 检查反方向（-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; // 沿相反方向前进
|
||||
ny -= dy;
|
||||
}
|
||||
// 判断反方向端点是否开放（遇到空位）
|
||||
if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE)
|
||||
{
|
||||
if (board[nx][ny] == EMPTY)
|
||||
{
|
||||
info.check_start = true;
|
||||
}
|
||||
}
|
||||
|
||||
return info;
|
||||
}
|
||||
|
||||
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即获胜
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false; // 四个方向都没有五连珠
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 悔棋功能实现
|
||||
*
|
||||
* @param steps_to_undo 要悔棋的步数
|
||||
* @return true 悔棋成功
|
||||
* @return false 悔棋失败(步数不足)
|
||||
*/
|
||||
bool return_move(int steps_to_undo)
|
||||
{
|
||||
if (step_count < steps_to_undo)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int i = 0; i < steps_to_undo; i++)
|
||||
{
|
||||
if (step_count > 0)
|
||||
{
|
||||
step_count--;
|
||||
board[steps[step_count].x][steps[step_count].y] = EMPTY;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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; // 五连
|
||||
case 4:
|
||||
if (info.check_start && info.check_end)
|
||||
step_score += SCORE_LIVE_FOUR; // 活四
|
||||
else if (info.check_start || info.check_end)
|
||||
step_score += SCORE_RUSH_FOUR; // 冲四
|
||||
else
|
||||
step_score += SCORE_DEAD_FOUR; // 死四
|
||||
break;
|
||||
case 3:
|
||||
if (info.check_start && info.check_end)
|
||||
step_score += SCORE_LIVE_THREE; // 活三
|
||||
else if (info.check_start || info.check_end)
|
||||
step_score += SCORE_SLEEP_THREE; // 眠三
|
||||
else
|
||||
step_score += SCORE_DEAD_THREE; // 死三
|
||||
break;
|
||||
case 2:
|
||||
if (info.check_start && info.check_end)
|
||||
step_score += SCORE_LIVE_TWO; // 活二
|
||||
else if (info.check_start || info.check_end)
|
||||
step_score += SCORE_SLEEP_TWO; // 眠二
|
||||
else
|
||||
step_score += SCORE_DEAD_TWO; // 死二
|
||||
break;
|
||||
case 1:
|
||||
if (info.check_start && info.check_end)
|
||||
step_score += SCORE_LIVE_ONE; // 开放单子
|
||||
else if (info.check_start || info.check_end)
|
||||
step_score += SCORE_HALF_ONE; // 半开放单子
|
||||
else
|
||||
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); // 距离中心越近奖励越高
|
||||
|
||||
return step_score + position_bonus;
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
/**
|
||||
* @file gui.c
|
||||
* @brief 图形化用户界面实现文件
|
||||
* @note 使用SDL3库实现五子棋的图形化界面
|
||||
* @author 刘航宇
|
||||
* @date 2025-01-15
|
||||
*/
|
||||
|
||||
#include "gui.h"
|
||||
#include "ui.h"
|
||||
#include "globals.h"
|
||||
#include "game_mode.h"
|
||||
#include "init_board.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
/**
|
||||
* @brief 初始化GUI
|
||||
* @details 初始化SDL3图形库和游戏界面组件：
|
||||
* - 初始化SDL视频子系统
|
||||
* - 创建游戏窗口（可调整大小）
|
||||
* - 创建SDL渲染器
|
||||
* - 初始化游戏状态和棋盘数据
|
||||
* @return 成功返回0，失败返回-1
|
||||
* @note 窗口标题为"五子棋游戏 - SDL3版本"
|
||||
* 窗口尺寸由WINDOW_WIDTH和WINDOW_HEIGHT定义
|
||||
* 失败时会自动清理已创建的资源
|
||||
*/
|
||||
int init_gui() {
|
||||
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
|
||||
printf("SDL初始化失败: %s\n", SDL_GetError());
|
||||
return -1;
|
||||
}
|
||||
|
||||
window = SDL_CreateWindow(
|
||||
"五子棋游戏 - SDL3版本",
|
||||
WINDOW_WIDTH, WINDOW_HEIGHT,
|
||||
SDL_WINDOW_RESIZABLE
|
||||
);
|
||||
|
||||
// 设置窗口位置到屏幕中央
|
||||
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
|
||||
|
||||
if (!window) {
|
||||
printf("窗口创建失败: %s\n", SDL_GetError());
|
||||
SDL_Quit();
|
||||
return -1;
|
||||
}
|
||||
|
||||
// 显示窗口
|
||||
SDL_ShowWindow(window);
|
||||
|
||||
renderer = SDL_CreateRenderer(window, NULL);
|
||||
if (!renderer) {
|
||||
printf("渲染器创建失败: %s\n", SDL_GetError());
|
||||
SDL_DestroyWindow(window);
|
||||
SDL_Quit();
|
||||
return -1;
|
||||
}
|
||||
|
||||
// 初始化游戏状态
|
||||
// 初始化棋盘
|
||||
for (int i = 0; i < BOARD_SIZE; i++) {
|
||||
for (int j = 0; j < BOARD_SIZE; j++) {
|
||||
board[i][j] = EMPTY;
|
||||
}
|
||||
}
|
||||
current_player_gui = PLAYER;
|
||||
game_over = 0;
|
||||
|
||||
printf("图形化界面初始化成功！\n");
|
||||
printf("使用鼠标点击棋盘进行落子\n");
|
||||
printf("按ESC键退出游戏\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 清理GUI资源
|
||||
* @details 按顺序释放所有SDL相关资源：
|
||||
* - 销毁SDL渲染器
|
||||
* - 销毁SDL窗口
|
||||
* - 退出SDL子系统
|
||||
* @note 函数会检查资源是否存在再进行释放
|
||||
* 释放后将指针设置为NULL防止重复释放
|
||||
* 程序退出时必须调用此函数避免内存泄漏
|
||||
*/
|
||||
void cleanup_gui() {
|
||||
if (renderer) {
|
||||
SDL_DestroyRenderer(renderer);
|
||||
renderer = NULL;
|
||||
}
|
||||
if (window) {
|
||||
SDL_DestroyWindow(window);
|
||||
window = NULL;
|
||||
}
|
||||
SDL_Quit();
|
||||
printf("图形化界面已关闭\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 渲染游戏画面
|
||||
* @details 完整的游戏画面渲染流程：
|
||||
* - 清空屏幕并设置背景色
|
||||
* - 绘制棋盘网格和标记点
|
||||
* - 绘制所有棋子
|
||||
* - 绘制UI界面元素
|
||||
* - 将渲染结果显示到屏幕
|
||||
* @note 使用双缓冲技术，通过SDL_RenderPresent显示最终结果
|
||||
* 背景色由GUI_COLOR_BACKGROUND定义
|
||||
* 每帧都会完全重绘整个画面
|
||||
*/
|
||||
void render_game() {
|
||||
// 清空屏幕 - 设置背景色
|
||||
SDL_Color bg_color = GUI_COLOR_BACKGROUND;
|
||||
SDL_SetRenderDrawColor(renderer, bg_color.r, bg_color.g, bg_color.b, bg_color.a);
|
||||
SDL_RenderClear(renderer);
|
||||
|
||||
// 绘制棋盘
|
||||
draw_board();
|
||||
|
||||
// 绘制棋子
|
||||
draw_stones();
|
||||
|
||||
// 绘制UI元素
|
||||
draw_ui_elements();
|
||||
|
||||
// 显示渲染结果
|
||||
SDL_RenderPresent(renderer);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 处理事件
|
||||
* @details 处理所有SDL事件并执行相应操作：
|
||||
* - SDL_EVENT_QUIT：用户关闭窗口
|
||||
* - SDL_EVENT_KEY_DOWN：键盘按键（ESC退出）
|
||||
* - SDL_EVENT_MOUSE_BUTTON_DOWN：鼠标点击落子
|
||||
* @return 继续运行返回1，退出返回0
|
||||
* @note 鼠标左键点击会转换为棋盘坐标并尝试落子
|
||||
* 落子后会检查胜负并切换玩家
|
||||
* 游戏结束后不再响应落子操作
|
||||
*/
|
||||
int handle_events() {
|
||||
SDL_Event event;
|
||||
|
||||
while (SDL_PollEvent(&event)) {
|
||||
switch (event.type) {
|
||||
case SDL_EVENT_QUIT:
|
||||
gui_running = 0;
|
||||
return 0;
|
||||
|
||||
case SDL_EVENT_KEY_DOWN:
|
||||
if (event.key.key == SDLK_ESCAPE) {
|
||||
gui_running = 0;
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case SDL_EVENT_MOUSE_BUTTON_DOWN:
|
||||
if (event.button.button == SDL_BUTTON_LEFT && !game_over) {
|
||||
int board_x, board_y;
|
||||
if (screen_to_board(event.button.x, event.button.y, &board_x, &board_y)) {
|
||||
if (have_space(board_x, board_y)) {
|
||||
// 执行落子操作
|
||||
if (player_move(board_x, board_y, current_player_gui)) {
|
||||
// 检查是否获胜
|
||||
if (check_win(board_x, board_y, current_player_gui)) {
|
||||
game_over = 1;
|
||||
if (current_player_gui == PLAYER) {
|
||||
sprintf(status_message, "游戏结束 - 黑子获胜！");
|
||||
} else {
|
||||
sprintf(status_message, "游戏结束 - 白子获胜！");
|
||||
}
|
||||
} else {
|
||||
// 切换玩家
|
||||
current_player_gui = (current_player_gui == PLAYER) ? AI : PLAYER;
|
||||
if (current_player_gui == PLAYER) {
|
||||
sprintf(status_message, "轮到黑子下棋");
|
||||
} else {
|
||||
sprintf(status_message, "轮到白子下棋");
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
sprintf(status_message, "该位置已有棋子，请选择其他位置");
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 绘制棋盘
|
||||
* @details 绘制15x15的五子棋棋盘，包括：
|
||||
* - 横竖交叉的网格线
|
||||
* - 天元点（棋盘中心的标记点）
|
||||
* - 四个星位（棋盘上的定位点）
|
||||
* @note 使用SDL3渲染器绘制线条和填充矩形
|
||||
* 棋盘线条颜色由GUI_COLOR_BOARD_LINE定义
|
||||
* 天元点和星位用黑色小矩形标记
|
||||
*/
|
||||
void draw_board() {
|
||||
SDL_Color line_color = GUI_COLOR_BOARD_LINE;
|
||||
SDL_SetRenderDrawColor(renderer, line_color.r, line_color.g, line_color.b, line_color.a);
|
||||
|
||||
// 绘制横线
|
||||
for (int i = 0; i < BOARD_SIZE; i++) {
|
||||
int y = BOARD_OFFSET_Y + i * CELL_SIZE;
|
||||
SDL_RenderLine(renderer,
|
||||
BOARD_OFFSET_X, y,
|
||||
BOARD_OFFSET_X + (BOARD_SIZE - 1) * CELL_SIZE, y);
|
||||
}
|
||||
|
||||
// 绘制竖线
|
||||
for (int j = 0; j < BOARD_SIZE; j++) {
|
||||
int x = BOARD_OFFSET_X + j * CELL_SIZE;
|
||||
SDL_RenderLine(renderer,
|
||||
x, BOARD_OFFSET_Y,
|
||||
x, BOARD_OFFSET_Y + (BOARD_SIZE - 1) * CELL_SIZE);
|
||||
}
|
||||
|
||||
// 绘制天元点和星位
|
||||
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
||||
int center = BOARD_SIZE / 2;
|
||||
|
||||
// 天元点
|
||||
int center_x = BOARD_OFFSET_X + center * CELL_SIZE;
|
||||
int center_y = BOARD_OFFSET_Y + center * CELL_SIZE;
|
||||
SDL_FRect center_rect = {center_x - 2, center_y - 2, 4, 4};
|
||||
SDL_RenderFillRect(renderer, ¢er_rect);
|
||||
|
||||
// 四个星位
|
||||
int star_offset = 3;
|
||||
int positions[][2] = {
|
||||
{center - star_offset, center - star_offset},
|
||||
{center + star_offset, center - star_offset},
|
||||
{center - star_offset, center + star_offset},
|
||||
{center + star_offset, center + star_offset}
|
||||
};
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
int x = BOARD_OFFSET_X + positions[i][1] * CELL_SIZE;
|
||||
int y = BOARD_OFFSET_Y + positions[i][0] * CELL_SIZE;
|
||||
SDL_FRect star_rect = {x - 1, y - 1, 2, 2};
|
||||
SDL_RenderFillRect(renderer, &star_rect);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 绘制棋子
|
||||
* @details 遍历整个棋盘数组，绘制所有已落下的棋子：
|
||||
* - 黑子：使用GUI_COLOR_BLACK_STONE颜色
|
||||
* - 白子：使用GUI_COLOR_WHITE_STONE颜色
|
||||
* - 每个棋子都有边框：使用GUI_COLOR_STONE_BORDER颜色
|
||||
* @note 棋子绘制为圆形，半径由STONE_RADIUS定义
|
||||
* 通过draw_circle函数实现圆形绘制
|
||||
* 棋子位置根据棋盘坐标和CELL_SIZE计算屏幕坐标
|
||||
*/
|
||||
void draw_stones() {
|
||||
for (int i = 0; i < BOARD_SIZE; i++) {
|
||||
for (int j = 0; j < BOARD_SIZE; j++) {
|
||||
if (board[i][j] != EMPTY) {
|
||||
int x = BOARD_OFFSET_X + j * CELL_SIZE;
|
||||
int y = BOARD_OFFSET_Y + i * CELL_SIZE;
|
||||
|
||||
// 设置棋子颜色
|
||||
SDL_Color stone_color, border_color;
|
||||
if (board[i][j] == PLAYER || board[i][j] == PLAYER1) {
|
||||
stone_color = (SDL_Color)GUI_COLOR_BLACK_STONE;
|
||||
} else {
|
||||
stone_color = (SDL_Color)GUI_COLOR_WHITE_STONE;
|
||||
}
|
||||
border_color = (SDL_Color)GUI_COLOR_STONE_BORDER;
|
||||
|
||||
// 绘制圆形棋子
|
||||
draw_circle(x, y, STONE_RADIUS, stone_color);
|
||||
draw_circle(x, y, STONE_RADIUS, border_color);
|
||||
|
||||
// 重新绘制内部
|
||||
draw_circle(x, y, STONE_RADIUS - 1, stone_color);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 绘制圆形
|
||||
* @param center_x 圆心X坐标
|
||||
* @param center_y 圆心Y坐标
|
||||
* @param radius 半径
|
||||
* @param color 颜色
|
||||
* @details 使用像素级绘制实现圆形：
|
||||
* - 遍历圆形外接矩形内的所有像素点
|
||||
* - 计算每个像素到圆心的距离
|
||||
* - 距离小于等于半径的像素点进行着色
|
||||
* @note 采用暴力算法，性能较低但实现简单
|
||||
* 适用于绘制棋子等小尺寸圆形
|
||||
* SDL3没有内置圆形绘制函数，需要自实现
|
||||
*/
|
||||
void draw_circle(int center_x, int center_y, int radius, SDL_Color color) {
|
||||
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
|
||||
|
||||
for (int w = 0; w < radius * 2; w++) {
|
||||
for (int h = 0; h < radius * 2; h++) {
|
||||
int dx = radius - w;
|
||||
int dy = radius - h;
|
||||
if ((dx*dx + dy*dy) <= (radius * radius)) {
|
||||
SDL_RenderPoint(renderer, center_x + dx, center_y + dy);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 绘制UI元素
|
||||
*/
|
||||
void draw_ui_elements() {
|
||||
// 绘制状态信息区域背景
|
||||
SDL_SetRenderDrawColor(renderer, 200, 200, 200, 255);
|
||||
SDL_FRect info_rect = {BOARD_OFFSET_X + BOARD_SIZE * CELL_SIZE + 20, BOARD_OFFSET_Y, 200, 100};
|
||||
SDL_RenderFillRect(renderer, &info_rect);
|
||||
|
||||
// 绘制边框
|
||||
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
||||
SDL_RenderRect(renderer, &info_rect);
|
||||
|
||||
// 这里可以添加文字渲染，但SDL3需要额外的字体库
|
||||
// 暂时用简单的图形表示当前玩家
|
||||
int indicator_x = info_rect.x + 20;
|
||||
int indicator_y = info_rect.y + 20;
|
||||
|
||||
if (!game_over) {
|
||||
if (current_player_gui == PLAYER) {
|
||||
// 黑子回合
|
||||
draw_circle(indicator_x, indicator_y, 10, (SDL_Color){0, 0, 0, 255});
|
||||
} else {
|
||||
// 白子回合
|
||||
draw_circle(indicator_x, indicator_y, 10, (SDL_Color){255, 255, 255, 255});
|
||||
// 绘制当前玩家指示器（简单的矩形代替圆形）
|
||||
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
||||
SDL_FRect indicator_rect = {indicator_x - 10, indicator_y - 10, 20, 20};
|
||||
SDL_RenderFillRect(renderer, &indicator_rect);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 屏幕坐标转棋盘坐标
|
||||
* @param screen_x 屏幕X坐标
|
||||
* @param screen_y 屏幕Y坐标
|
||||
* @param board_x 输出棋盘X坐标
|
||||
* @param board_y 输出棋盘Y坐标
|
||||
* @return 转换成功返回1，失败返回0
|
||||
* @details 坐标转换算法：
|
||||
* - 减去棋盘偏移量得到相对坐标
|
||||
* - 加上半个格子尺寸实现就近取整
|
||||
* - 除以格子尺寸得到棋盘坐标
|
||||
* - 检查坐标是否在有效范围内
|
||||
* @note 使用就近取整算法，点击格子中心附近都会定位到该格子
|
||||
* 坐标范围检查确保不会越界访问棋盘数组
|
||||
*/
|
||||
int screen_to_board(int screen_x, int screen_y, int* board_x, int* board_y) {
|
||||
int rel_x = screen_x - BOARD_OFFSET_X;
|
||||
int rel_y = screen_y - BOARD_OFFSET_Y;
|
||||
|
||||
*board_x = (rel_x + CELL_SIZE/2) / CELL_SIZE;
|
||||
*board_y = (rel_y + CELL_SIZE/2) / CELL_SIZE;
|
||||
|
||||
return (*board_x >= 0 && *board_x < BOARD_SIZE &&
|
||||
*board_y >= 0 && *board_y < BOARD_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示消息
|
||||
* @param message 要显示的消息
|
||||
* @details 消息显示功能：
|
||||
* - 将消息复制到全局状态消息缓冲区
|
||||
* - 同时在控制台输出消息内容
|
||||
* - 确保字符串安全复制，防止缓冲区溢出
|
||||
* @note 消息会存储在status_message全局变量中
|
||||
* 字符串长度限制为缓冲区大小减1
|
||||
* 消息可用于游戏状态提示和错误信息显示
|
||||
*/
|
||||
void show_message(const char* message) {
|
||||
strncpy(status_message, message, sizeof(status_message) - 1);
|
||||
status_message[sizeof(status_message) - 1] = '\0';
|
||||
printf("%s\n", message);
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
/**
|
||||
* @file init_board.c
|
||||
* @brief 初始化游戏棋盘源文件
|
||||
* @note 本文件定义了初始化游戏棋盘的相关函数。
|
||||
* 它负责设置游戏的初始状态，包括棋盘大小、玩家标识、游戏规则等。
|
||||
*/
|
||||
|
||||
#include "init_board.h"
|
||||
#include "gobang.h"
|
||||
#include "game_mode.h"
|
||||
#include "config.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief 初始化棋盘为全空状态并重置步数计数器
|
||||
* 清空棋盘数组并将所有位置设为EMPTY，同时将step_count重置为0
|
||||
*/
|
||||
void empty_board()
|
||||
{
|
||||
// 初始化棋盘状态为全空
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
for (int j = 0; j < BOARD_SIZE; j++)
|
||||
{
|
||||
board[i][j] = EMPTY;
|
||||
}
|
||||
}
|
||||
step_count = 0; // 重置步数计数器
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 打印当前棋盘状态
|
||||
* 以可读格式输出棋盘，包括行列号和棋子状态
|
||||
* 玩家棋子显示为'x'，AI棋子显示为'○'，空位显示为'·'
|
||||
*/
|
||||
void print_board()
|
||||
{
|
||||
// 打印列号（1-BOARD_SIZE显示）
|
||||
printf("\n ");
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
printf("%2d", i + 1);
|
||||
if (i + 1 == 9) // 处理列号9和10+的对齐
|
||||
{
|
||||
printf(" ");
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
// 逐行打印棋盘内容
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
printf("%2d ", i + 1); // 打印行号（1-BOARD_SIZE）
|
||||
for (int j = 0; j < BOARD_SIZE; j++)
|
||||
{
|
||||
if (board[i][j] == PLAYER)
|
||||
{
|
||||
printf("x "); // 玩家棋子
|
||||
}
|
||||
else if (board[i][j] == AI)
|
||||
{
|
||||
printf("○ "); // AI棋子(使用○显示)
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("· "); // 空位
|
||||
}
|
||||
}
|
||||
printf("\n"); // 每行结束换行
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 配置棋盘大小
|
||||
*
|
||||
* @param player1 玩家1
|
||||
* @param player2 玩家2
|
||||
*/
|
||||
void setup_board_size()
|
||||
{
|
||||
printf("通常棋盘大小分为休闲棋盘(13X13)、标准棋盘(15X15)和特殊棋盘(19X19)\n");
|
||||
char prompt[100];
|
||||
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_timer = get_integer_input("是否启用计时器 (1-是, 0-否): ", 0, 1);
|
||||
if (use_timer)
|
||||
{
|
||||
time_limit = get_integer_input("请输入每回合的时间限制 (1~60分钟): ", 1, 60) * 60;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 确定先手玩家
|
||||
*
|
||||
* @param player1
|
||||
* @param player2
|
||||
* @return int player1 or player2
|
||||
*/
|
||||
int determine_first_player(int player1, int player2)
|
||||
{
|
||||
char prompt[100];
|
||||
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)
|
||||
{
|
||||
return player1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return player2;
|
||||
}
|
||||
}
|
||||
+98
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* @file main.c
|
||||
* @brief 五子棋游戏主函数文件
|
||||
* @note 本文件包含了游戏的主循环、模式选择和游戏初始化等功能
|
||||
* @brief 将以下指令复制到powershell
|
||||
*
|
||||
* !控制台版本编译：
|
||||
* gcc -std=c17 -o gobang_console.exe *.c -lws2_32
|
||||
.\gobang_console.exe
|
||||
*
|
||||
* !图形化版本编译（需要SDL3）：
|
||||
* gcc -std=c17 -o gobang_gui.exe *.c -ID:\settings\SDL\SDL3-3.2.22\x86_64-w64-mingw32\include -LD:\settings\SDL\SDL3-3.2.22\x86_64-w64-mingw32\lib -lSDL3 -lws2_32
|
||||
copy "D:\settings\SDL\SDL3-3.2.22\x86_64-w64-mingw32\bin\SDL3.dll" .
|
||||
.\gobang_gui.exe
|
||||
*
|
||||
* @detail gcc 为编译器，添加了-lws2_32链接Windows网络库
|
||||
* @detail SDL3 的路径：D:\settings\SDL\SDL3-3.2.22\x86_64-w64-mingw32
|
||||
* @brief & "D:\Program Files (x86)\NSIS\makensis.exe" "installer\\installer.nsi"
|
||||
* @brief & "D:\Program Files (x86)\Inno Setup 6\iscc.exe" installer\\setup.iss
|
||||
*/
|
||||
|
||||
#include "game_mode.h"
|
||||
#include "ui.h"
|
||||
#include "config.h"
|
||||
#include <stdio.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#include <direct.h>
|
||||
#endif
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// 设置控制台编码为UTF-8
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul"); // 设置控制台编码为UTF-8
|
||||
SetConsoleOutputCP(65001); // 设置控制台输出编码
|
||||
SetConsoleCP(65001); // 设置控制台输入编码
|
||||
_mkdir("records");
|
||||
#endif
|
||||
|
||||
// 加载游戏配置
|
||||
load_game_config();
|
||||
|
||||
// 选择模式
|
||||
while (1)
|
||||
{
|
||||
clear_screen();
|
||||
display_main_menu();
|
||||
int mode = get_integer_input("请输入模式(0-8): ", 0, 8);
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
// 1. 人机对战
|
||||
case 1:
|
||||
run_ai_game();
|
||||
break;
|
||||
// 2. 玩家对战
|
||||
case 2:
|
||||
run_pvp_game();
|
||||
break;
|
||||
// 3. 网络对战
|
||||
case 3:
|
||||
run_network_game();
|
||||
break;
|
||||
// 4. 复盘模式
|
||||
case 4:
|
||||
run_review_mode();
|
||||
break;
|
||||
// 5. 配置管理
|
||||
case 5:
|
||||
config_management_menu();
|
||||
break;
|
||||
// 6. 游戏规则
|
||||
case 6:
|
||||
show_game_rules();
|
||||
break;
|
||||
// 7. 关于游戏
|
||||
case 7:
|
||||
show_about_game();
|
||||
break;
|
||||
// 8. 图形化界面
|
||||
case 8:
|
||||
run_gui_mode();
|
||||
break;
|
||||
// 0. 退出游戏
|
||||
case 0:
|
||||
save_game_config();
|
||||
printf("感谢使用五子棋游戏！\n");
|
||||
return 0;
|
||||
default:
|
||||
printf("无效的选择！\n");
|
||||
pause_for_input("按任意键继续...");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
+423
@@ -0,0 +1,423 @@
|
||||
/**
|
||||
* @file network.c
|
||||
* @author 刘航宇(3364451258@qq.com、15236416560@163.com、lhy3364451258@outlook.com)
|
||||
* @brief 五子棋网络对战模块实现
|
||||
*/
|
||||
|
||||
#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
|
||||
// Windows实现
|
||||
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);
|
||||
}
|
||||
+536
@@ -0,0 +1,536 @@
|
||||
/**
|
||||
* @file record.c
|
||||
* @brief 游戏复盘与记录源文件
|
||||
* @note 本文件定义了游戏复盘与记录相关的函数和数据结构。
|
||||
* 它负责管理游戏的历史记录、加载和保存游戏文件、计算游戏评分等功能。
|
||||
*/
|
||||
|
||||
#include "record.h"
|
||||
#include "game_mode.h"
|
||||
#include "gobang.h"
|
||||
#include "init_board.h"
|
||||
#include "ui.h"
|
||||
#include "config.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.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 复盘游戏全过程并展示评分
|
||||
* @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);
|
||||
|
||||
// 如果评分尚未计算，则计算评分
|
||||
if (!scores_calculated)
|
||||
{
|
||||
calculate_game_scores();
|
||||
}
|
||||
else
|
||||
{
|
||||
// 评分已从文件中加载，直接使用
|
||||
printf("从记录文件中加载评分数据\n");
|
||||
}
|
||||
|
||||
if (review_choice == 1)
|
||||
{
|
||||
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)); // 初始化为空棋盘
|
||||
|
||||
// 逐步重现游戏过程
|
||||
for (int i = 0; i < step_count; i++)
|
||||
{
|
||||
Step s = steps[i]; // 获取当前步骤
|
||||
temp_board[s.x][s.y] = s.player; // 在临时棋盘上落子
|
||||
|
||||
// 打印当前步骤信息
|
||||
// 根据游戏模式显示不同的标题和玩家信息
|
||||
if (game_mode == GAME_MODE_AI)
|
||||
{
|
||||
// 人机对战
|
||||
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.x + 1, s.y + 1);
|
||||
}
|
||||
else if (game_mode == GAME_MODE_PVP)
|
||||
{
|
||||
// 双人对战
|
||||
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.x + 1, s.y + 1);
|
||||
}
|
||||
else if (game_mode == GAME_MODE_NETWORK)
|
||||
{
|
||||
// 网络对战
|
||||
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.x + 1, s.y + 1);
|
||||
}
|
||||
|
||||
// 打印当前复盘棋盘
|
||||
printf(" ");
|
||||
for (int col = 0; col < BOARD_SIZE; col++)
|
||||
{
|
||||
printf("%2d", col + 1); // 列号
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
for (int row = 0; row < BOARD_SIZE; row++)
|
||||
{
|
||||
printf("%2d ", row + 1); // 行号
|
||||
for (int col = 0; col < BOARD_SIZE; col++)
|
||||
{
|
||||
if (temp_board[row][col] == PLAYER || temp_board[row][col] == PLAYER1)
|
||||
{
|
||||
printf("x ");
|
||||
}
|
||||
else if (temp_board[row][col] == AI || temp_board[row][col] == PLAYER2)
|
||||
{
|
||||
printf("○ ");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("· ");
|
||||
}
|
||||
}
|
||||
printf("\n"); // 行结束换行
|
||||
}
|
||||
|
||||
// 如果不是最后一步，等待用户按键继续
|
||||
if (i < step_count - 1)
|
||||
{
|
||||
printf("\n按Enter继续下一步...");
|
||||
while (getchar() != '\n')
|
||||
; // 等待回车
|
||||
}
|
||||
}
|
||||
|
||||
// 显示胜负结果（直接使用文件中的信息）
|
||||
printf("\n===== 对局结果 =====");
|
||||
if (strcmp(winner_info, "玩家获胜") == 0)
|
||||
{
|
||||
printf("\n? 恭喜！玩家获胜！\n");
|
||||
}
|
||||
else if (strcmp(winner_info, "AI获胜") == 0)
|
||||
{
|
||||
printf("\n? AI获胜！\n");
|
||||
}
|
||||
else if (strcmp(winner_info, "玩家1获胜") == 0)
|
||||
{
|
||||
printf("\n? 恭喜！玩家1(黑棋)获胜！\n");
|
||||
}
|
||||
else if (strcmp(winner_info, "玩家2获胜") == 0)
|
||||
{
|
||||
printf("\n? 恭喜！玩家2(白棋)获胜！\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n?? 对局平局或未完成\n");
|
||||
}
|
||||
|
||||
printf("\n复盘结束！按Enter查看评分...");
|
||||
getchar(); // 等待用户按键
|
||||
}
|
||||
|
||||
// 显示评分结果
|
||||
display_game_scores(game_mode);
|
||||
|
||||
getchar();
|
||||
}
|
||||
|
||||
/**
|
||||
* @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; // 最后的步骤权重是开始步骤的(1+TIME_WEIGHT_FACTOR)倍
|
||||
|
||||
if (steps[i].player == PLAYER || steps[i].player == PLAYER1)
|
||||
{
|
||||
player1_final_score += (int)(calculate_step_score(steps[i].x, steps[i].y, steps[i].player) * time_weight);
|
||||
}
|
||||
else
|
||||
{
|
||||
player2_final_score += (int)(calculate_step_score(steps[i].x, steps[i].y, steps[i].player) * time_weight);
|
||||
}
|
||||
}
|
||||
|
||||
// 胜负加权：获胜方获得额外的评分奖励
|
||||
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; // 获胜奖励
|
||||
}
|
||||
else
|
||||
{
|
||||
player2_final_score += WIN_BONUS; // 获胜奖励
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
scores_calculated = 1; // 标记评分已计算
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示游戏评分结果和MVP评选
|
||||
* @param game_mode 游戏模式(1-人机对战, 2-双人对战)
|
||||
*/
|
||||
void display_game_scores(int game_mode)
|
||||
{
|
||||
printf("\n===== 对局评分 =====\n");
|
||||
double sum_score = (long double)player1_final_score + (long double)player2_final_score;
|
||||
|
||||
if (sum_score > 0)
|
||||
{
|
||||
if (game_mode == GAME_MODE_AI)
|
||||
{
|
||||
printf("玩家得分: %d, 占比: %.2f%%\n",
|
||||
player1_final_score, (double)player1_final_score * 100.0 / sum_score);
|
||||
printf("AI得分: %d, 占比: %.2f%%\n",
|
||||
player2_final_score, (double)player2_final_score * 100.0 / sum_score);
|
||||
}
|
||||
else if (game_mode == GAME_MODE_PVP)
|
||||
{
|
||||
printf("玩家1(黑棋)得分: %d, 占比: %.2f%%\n",
|
||||
player1_final_score, (double)player1_final_score * 100.0 / sum_score);
|
||||
printf("玩家2(白棋)得分: %d, 占比: %.2f%%\n",
|
||||
player2_final_score, (double)player2_final_score * 100.0 / sum_score);
|
||||
}
|
||||
else if (game_mode == GAME_MODE_NETWORK)
|
||||
{
|
||||
printf("玩家1(黑棋)得分: %d, 占比: %.2f%%\n",
|
||||
player1_final_score, (double)player1_final_score * 100.0 / sum_score);
|
||||
printf("玩家2(白棋)得分: %d, 占比: %.2f%%\n",
|
||||
player2_final_score, (double)player2_final_score * 100.0 / sum_score);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (game_mode == GAME_MODE_AI)
|
||||
{
|
||||
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("注: 双方得分均为0，无法计算占比\n");
|
||||
}
|
||||
|
||||
// 评选MVP
|
||||
if (player1_final_score > player2_final_score)
|
||||
{
|
||||
printf("\nMVP: %s (领先 %d 分)\n", (game_mode == GAME_MODE_AI) ? "玩家" : "玩家1(黑棋)", player1_final_score - player2_final_score);
|
||||
}
|
||||
else if (player2_final_score > player1_final_score)
|
||||
{
|
||||
printf("\nMVP: %s (领先 %d 分)\n", (game_mode == GAME_MODE_AI) ? "AI" : "玩家2(白棋)", player2_final_score - player1_final_score);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n双方势均力敌！\n");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 处理游戏结束后的记录保存
|
||||
* @return int 保存状态码(0-成功, 1-目录创建失败, 2-文件打开失败, 3-文件写入失败)
|
||||
*/
|
||||
void handle_save_record(int game_mode)
|
||||
{
|
||||
printf("===== 游戏结束 =====\n");
|
||||
int save_choice = get_integer_input("是否保存游戏记录? (1-是, 0-否): ", 0, 1);
|
||||
|
||||
if (save_choice == 1)
|
||||
{
|
||||
time_t now = time(NULL);
|
||||
struct tm *t = localtime(&now);
|
||||
char filename[256];
|
||||
strftime(filename, sizeof(filename), "%Y%m%d_%H%M%S.csv", t);
|
||||
|
||||
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");
|
||||
break;
|
||||
case 1: // 目录创建失败
|
||||
printf("\n游戏记录保存失败: 无法创建 'records' 目录。\n");
|
||||
printf("请检查程序是否具有足够的写入权限或磁盘空间是否充足。\n");
|
||||
break;
|
||||
case 2: // 文件打开失败
|
||||
printf("\n游戏记录保存失败: 无法在路径 '%s' 创建文件。\n", filename);
|
||||
printf("请检查路径是否有效以及程序是否具有写入权限。\n");
|
||||
break;
|
||||
case 3: // 文件写入失败
|
||||
printf("\n游戏记录保存失败: 写入文件时发生错误。\n");
|
||||
printf("请检查磁盘空间是否已满。\n");
|
||||
break;
|
||||
default:
|
||||
printf("\n游戏记录保存失败: 发生未知错误。\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 将当前游戏记录保存到文件
|
||||
* @param filename 要保存的文件名
|
||||
* @return int 错误码:
|
||||
* 0: 成功
|
||||
* 1: 目录创建失败
|
||||
* 2: 文件打开失败
|
||||
* 3: 文件写入失败
|
||||
*/
|
||||
int save_game_to_file(const char *filename, int game_mode)
|
||||
{
|
||||
// 创建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");
|
||||
#else
|
||||
perror("创建目录失败");
|
||||
#endif
|
||||
return 1; // 目录创建失败
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 打开文件
|
||||
char fullpath[256];
|
||||
snprintf(fullpath, sizeof(fullpath), "records/%s", filename);
|
||||
FILE *file = fopen(fullpath, "w");
|
||||
if (!file)
|
||||
{
|
||||
return 2; // 文件打开失败
|
||||
}
|
||||
|
||||
// 判断胜负结果
|
||||
strcpy(winner_info, "平局或未完成");
|
||||
if (step_count > 0)
|
||||
{
|
||||
Step last_step = steps[step_count - 1];
|
||||
if (check_win(last_step.x, last_step.y, last_step.player))
|
||||
{
|
||||
if (game_mode == GAME_MODE_AI)
|
||||
{
|
||||
// 人机对战
|
||||
if (last_step.player == PLAYER)
|
||||
{
|
||||
strcpy(winner_info, "玩家获胜");
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy(winner_info, "AI获胜");
|
||||
}
|
||||
}
|
||||
else if (game_mode == GAME_MODE_PVP)
|
||||
{
|
||||
// 双人对战
|
||||
if (last_step.player == PLAYER1)
|
||||
{
|
||||
strcpy(winner_info, "玩家1获胜");
|
||||
}
|
||||
else
|
||||
{
|
||||
strcpy(winner_info, "玩家2获胜");
|
||||
}
|
||||
}
|
||||
else if (game_mode == GAME_MODE_NETWORK)
|
||||
{
|
||||
// 网络对战
|
||||
if (last_step.player == PLAYER1)
|
||||
{
|
||||
strcpy(winner_info, "玩家1获胜");
|
||||
}
|
||||
else
|
||||
{
|
||||
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)
|
||||
{
|
||||
fclose(file);
|
||||
return 3; // 文件写入失败
|
||||
}
|
||||
|
||||
// 写入CSV表头
|
||||
if (fprintf(file, "步数,玩家,行坐标,列坐标\n") < 0)
|
||||
{
|
||||
fclose(file);
|
||||
return 3; // 文件写入失败
|
||||
}
|
||||
|
||||
// 写入所有落子步骤（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; // 文件写入失败
|
||||
}
|
||||
}
|
||||
|
||||
if (fclose(file) != 0)
|
||||
{
|
||||
return 3; // 文件关闭/写入失败
|
||||
}
|
||||
|
||||
return 0; // 成功
|
||||
}
|
||||
|
||||
/**
|
||||
* @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");
|
||||
if (!file)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// 跳过CSV文件头部行
|
||||
char buffer[256];
|
||||
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, "未知");
|
||||
}
|
||||
else if (read_count != 5)
|
||||
{
|
||||
// 文件格式错误
|
||||
fclose(file);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (game_mode != GAME_MODE_AI && game_mode != GAME_MODE_PVP && game_mode != GAME_MODE_NETWORK)
|
||||
{
|
||||
fclose(file);
|
||||
return 0; // 无效的游戏模式
|
||||
}
|
||||
if (size < 5 || size > MAX_BOARD_SIZE)
|
||||
{
|
||||
fclose(file);
|
||||
return false;
|
||||
}
|
||||
|
||||
// 设置评分已计算标志
|
||||
scores_calculated = 1;
|
||||
|
||||
// 跳过空行和表头行
|
||||
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; // 用于存储步数，但不使用
|
||||
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坐标
|
||||
steps[step_count].x--;
|
||||
steps[step_count].y--;
|
||||
step_count++;
|
||||
}
|
||||
|
||||
fclose(file);
|
||||
return game_mode;
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
/**
|
||||
* @file ui.c
|
||||
* @brief
|
||||
* @note 本文件定义了用户界面相关的函数和数据结构。
|
||||
* 它负责处理用户输入、显示游戏界面、提示信息等与用户交互的功能。
|
||||
*/
|
||||
|
||||
#include "ui.h"
|
||||
#include "gobang.h"
|
||||
#include "config.h"
|
||||
#include "globals.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#include <conio.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief 显示游戏主菜单
|
||||
*/
|
||||
void display_main_menu()
|
||||
{
|
||||
printf("===== 五子棋游戏 =====\n");
|
||||
printf("1. AI模式\n");
|
||||
printf("2. 玩家比赛\n");
|
||||
printf("3. 网络对战\n");
|
||||
printf("4. 复盘模式\n");
|
||||
printf("5. 游戏设置\n");
|
||||
printf("6. 游戏规则\n");
|
||||
printf("7. 关于游戏\n");
|
||||
printf("8. 图形化界面\n");
|
||||
printf("0. 退出游戏\n");
|
||||
printf("=====================\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示棋盘
|
||||
*/
|
||||
void display_board()
|
||||
{
|
||||
printf("\n ");
|
||||
// 打印列号
|
||||
for (int j = 0; j < BOARD_SIZE; j++)
|
||||
{
|
||||
printf("%2d", j);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
// 打印棋盘内容
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
printf("%2d", i); // 打印行号
|
||||
for (int j = 0; j < BOARD_SIZE; j++)
|
||||
{
|
||||
if (board[i][j] == EMPTY)
|
||||
{
|
||||
printf(" ·"); // 空位用点表示
|
||||
}
|
||||
else if (board[i][j] == PLAYER || board[i][j] == PLAYER1)
|
||||
{
|
||||
printf(" ●"); // 玩家1用实心圆表示
|
||||
}
|
||||
else
|
||||
{
|
||||
printf(" ○"); // 玩家2/AI用空心圆表示
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示游戏状态信息
|
||||
* @param current_player 当前玩家
|
||||
* @param step_count 当前步数
|
||||
*/
|
||||
void display_game_status(int current_player, int step_count)
|
||||
{
|
||||
printf("当前步数: %d\n", step_count);
|
||||
if (current_player == PLAYER || current_player == PLAYER1)
|
||||
{
|
||||
printf("当前玩家: ●\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("当前玩家: ○\n");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示获胜信息
|
||||
* @param winner 获胜者
|
||||
*/
|
||||
void display_winner(int winner)
|
||||
{
|
||||
printf("\n游戏结束！\n");
|
||||
if (winner == PLAYER)
|
||||
{
|
||||
printf("玩家获胜！\n");
|
||||
}
|
||||
else if (winner == AI)
|
||||
{
|
||||
printf("AI获胜！\n");
|
||||
}
|
||||
else if (winner == PLAYER1)
|
||||
{
|
||||
printf("玩家1获胜！\n");
|
||||
}
|
||||
else if (winner == PLAYER2)
|
||||
{
|
||||
printf("玩家2获胜！\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("平局！\n");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示游戏设置菜单
|
||||
*/
|
||||
void display_settings_menu()
|
||||
{
|
||||
printf("\n===== 游戏设置 =====\n");
|
||||
printf("1. 棋盘大小设置\n");
|
||||
printf("2. 禁手规则设置\n");
|
||||
printf("3. 计时器设置\n");
|
||||
printf("4. 网络配置设置\n");
|
||||
printf("5. AI难度设置\n");
|
||||
printf("0. 返回主菜单\n");
|
||||
printf("==================\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 清屏函数
|
||||
*/
|
||||
void clear_screen()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("cls");
|
||||
#else
|
||||
system("clear");
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 暂停等待用户输入
|
||||
* @param prompt 提示信息
|
||||
*/
|
||||
void pause_for_input(const char* prompt)
|
||||
{
|
||||
printf("%s", prompt);
|
||||
#ifdef _WIN32
|
||||
_getch();
|
||||
#else
|
||||
getchar();
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示游戏规则
|
||||
*/
|
||||
void display_game_rules()
|
||||
{
|
||||
printf("\n===== 五子棋游戏规则 =====\n");
|
||||
printf("1. 🎮 游戏目标：\n");
|
||||
printf(" 在棋盘上连成五个同色棋子（横、竖、斜均可）\n\n");
|
||||
printf("2. 🔄 游戏流程：\n");
|
||||
printf(" - ⚫ 黑棋先行，双方轮流落子\n");
|
||||
printf(" - 📍 输入坐标格式：行号 列号（如：7 7）\n");
|
||||
printf(" - ✨ 棋子落在棋盘交叉点上\n\n");
|
||||
printf("3. 🏆 胜负判定：\n");
|
||||
printf(" - 🎉 率先连成五子者获胜\n");
|
||||
printf(" - 🤝 棋盘下满无人获胜则为平局\n\n");
|
||||
printf("4. 🚫 禁手规则（可选）：\n");
|
||||
printf(" - ❌ 三三禁手：同时形成两个活三\n");
|
||||
printf(" - ❌ 四四禁手：同时形成两个冲四\n");
|
||||
printf(" - ❌ 长连禁手：连成六子或以上\n\n");
|
||||
printf("5. 🛠️ 特殊功能：\n");
|
||||
printf(" - ↩️ 悔棋：输入 'R' 或 'r' 可悔棋\n");
|
||||
printf(" - 💾 保存：游戏结束后可保存对局记录\n");
|
||||
printf(" - 📖 复盘：可加载历史对局进行复盘\n");
|
||||
printf("============================\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief 显示关于信息
|
||||
*/
|
||||
void display_about()
|
||||
{
|
||||
printf("\n===== 关于五子棋游戏 =====\n");
|
||||
printf("🎮 游戏名称：五子棋人机对战\n");
|
||||
printf("📦 版本：7.0\n");
|
||||
printf("👨💻 开发者：刘航宇\n");
|
||||
printf("📧 联系邮箱：3364451258@qq.com\n");
|
||||
printf("🌐 项目主页：https://github.com/LHY0125/Gobang-Game\n\n");
|
||||
printf("✨ 主要特性：\n");
|
||||
printf(" 🤖 智能AI对战（支持多种难度）\n");
|
||||
printf(" 👥 双人对战模式\n");
|
||||
printf(" 🌐 网络对战（局域网/互联网）\n");
|
||||
printf(" 📝 对局记录与复盘\n");
|
||||
printf(" 🚫 禁手规则支持\n");
|
||||
printf(" ⏱️ 计时器功能\n");
|
||||
printf(" 📏 自定义棋盘大小\n");
|
||||
printf(" 📊 评分系统\n\n");
|
||||
printf("🙏 感谢使用！\n");
|
||||
printf("========================\n");
|
||||
}
|
||||
Reference in New Issue
Block a user