C_code/C语言/课上代码练习/五子棋/README.md

# 五子棋人机对战AI项目

## 项目简介
这是一个基于C语言实现的高级五子棋人机对战系统，采用α-β剪枝的极小极大算法实现AI决策，支持自定义棋盘大小和完整的游戏复盘功能。

> **🎯 更完善的版本推荐**：如果您想体验功能更加完整的五子棋系统，可以查看我的升级版项目 [Gobang-Game](https://github.com/LHY0125/Gobang-Game.git)，该版本新增了SDL3图形化界面、网络对战功能、多种游戏模式、智能评分系统等现代化特性，提供更丰富的游戏体验。

## 核心功能
- 支持5x5到25x25的棋盘尺寸
- 玩家(X)与AI(○)对战模式
- AI采用α-β剪枝优化的极小极大算法
- 详细的棋型评估系统（活四、冲四、活三等）
- 完整的游戏复盘功能
- 清晰的棋盘界面显示

## 技术特点
1. **AI算法**：
   - 使用α-β剪枝优化的极小极大算法
   - 搜索深度可调（当前设置为3层）
   - 优先处理威胁位置（如阻止玩家形成活四）

2. **评估系统**：
   - 考虑四个方向的棋型评估
   - 区分活棋、眠棋和死棋
   - 位置奖励（中心位置价值更高）

3. **游戏流程**：
   - 完整的胜负判定
   - 平局检测
   - 详细的复盘系统

## 编译运行
1. 编译程序：
   ```bash
   gcc "五子棋 copy 3.c" -o gobang -lm
   ```

2. 运行游戏：
   ```bash
   ./gobang
   ```

## 使用说明
1. 启动后输入棋盘尺寸（5-25，默认15）
2. 游戏进行：
   - 玩家输入坐标格式：行 列（如"8 8"）
   - AI会自动计算最佳落子位置
3. 游戏结束：
   - 显示胜负结果
   - 可选择查看完整复盘

## 核心函数说明

### 1. ai_move() - AI决策函数
**功能**：决定AI的最佳落子位置  
**算法**：
1. 优先检查是否需要阻止玩家形成活四/冲四
2. 使用α-β剪枝优化的极小极大算法搜索最佳位置
3. 考虑已有棋子附近2格范围内的位置
   
**参数**：无  
**返回值**：无（直接修改棋盘状态）

### 2. evaluate_pos() - 棋型评估函数
**功能**：评估特定位置对当前玩家的价值  
**评分标准**：
- 活四: 100000分
- 冲四: 10000分 
- 活三: 5000分
- 眠三: 1000分
- 活二: 500分
- 眠二: 100分
- 
**参数**：
- x,y: 待评估位置坐标
- player: 当前玩家标识
**返回值**：评估分数（越高越好）

### 3. dfs() - 深度优先搜索
**功能**：实现带α-β剪枝的极小极大算法  
**特点**：
- 搜索深度：3层
- 使用α-β剪枝优化搜索效率
- 评估函数差值作为叶节点值
**参数**：
- x,y: 当前落子位置
- player: 当前玩家
- depth: 剩余搜索深度
- alpha,beta: 剪枝参数
- is_maximizing: 是否最大化玩家

### 4. count_specific_direction() - 方向分析
**功能**：计算特定方向上的连续棋子情况  
**返回结构**：
- continuous_chess: 连续棋子数
- check_start/check_end: 两端是否开放
**应用**：用于判断棋型（活棋/眠棋）

### 5. check_win() - 胜负判断
**功能**：检查落子后是否形成五连珠  
**逻辑**：检查四个方向是否存在≥5的连续同色棋子

## 程序流程图

```
开始
│
├─> 初始化棋盘
│    │
│    └─> 设置默认大小(15x15)
│
├─> 游戏主循环
│    │
│    ├─> [玩家回合]
│    │    ├─> 显示棋盘
│    │    ├─> 获取玩家输入坐标
│    │    └─> 落子并检查胜负
│    │
│    ├─> [AI回合]
│    │    ├─> AI计算最佳落子(α-β剪枝)
│    │    └─> 落子并检查胜负
│    │
│    └─> 检查平局条件
│
├─> 游戏结束处理
│    ├─> 显示胜负结果
│    └─> 询问是否复盘
│         ├─> 是: 显示完整复盘
│         └─> 否: 退出游戏
│
└─> 程序结束
```

## 关键代码实现

### 1. AI决策核心算法
```c
// α-β剪枝极小极大算法实现
int dfs(int x, int y, int player, int depth, int alpha, int beta, int is_maximizing)
{
    if (depth == 0 || check_win(x, y))
    {
        return evaluate_pos(x, y, player) - evaluate_pos(x, y, 3 - player);
    }
    
    if (is_maximizing)
    {
        int max_eval = INT_MIN;
        for (每个可能位置)
        {
            int eval = dfs(x, y, player, depth-1, alpha, beta, 0);
            max_eval = max(max_eval, eval);
            alpha = max(alpha, eval);
            // α剪枝
            if (beta <= alpha)
            {
               break;  
            }
        }
        return max_eval;
    } 
    else
    {
        int min_eval = INT_MAX;
        for (每个可能位置)
        {
            int eval = dfs(x, y, player, depth-1, alpha, beta, 1);
            min_eval = min(min_eval, eval);
            beta = min(beta, eval);
            // β剪枝
            if (beta <= alpha)
            {
                break;
            }  
        }
        return min_eval;
    }
}
```

### 2. 棋型评估函数
```c
// 评估特定位置的棋型价值
int evaluate_pos(int x, int y, int player)
{
    int score = 0;
    for (四个方向)
    {
        ChessPattern pattern =count_specific_direction(x, y, dir);
        
        if (pattern.continuous_chess >= 5)
        {
            return 1000000; // 五连珠
        }    
        
        // 活棋
        if (pattern.check_start && pattern.check_end)
        {   
            if (pattern.continuous_chess == 4) 
                score += 100000; // 活四
            else if (pattern.continuous_chess == 3)
                score += 5000; // 活三
            else if (pattern.continuous_chess == 2)
                score += 500; // 活二
        } 
        // 眠棋
        else if (pattern.check_start || pattern.check_end)
        {   
            if (pattern.continuous_chess == 4)
                score += 10000; // 冲四
            else if (pattern.continuous_chess == 3)
                score += 1000; // 眠三
            else if (pattern.continuous_chess == 2)
                score += 100; // 眠二
        }
    }
    return score;
}
```

### 3. 胜负判断逻辑
```c
// 检查是否形成五连珠
int check_win(int x, int y)
{
    for (四个方向)
    {
        int count = 1;
        // 正向检查
        for (int i = 1; i < 5; i++)
        {
            if (棋盘边界检查 || 棋子不连续)
            { 
                break;
            }
            count++;
        }
        // 反向检查
        for (int i = 1; i < 5; i++)
        {
            if (棋盘边界检查 || 棋子不连续)
            {
                break;
            } 
            count++;
        }
        // 五连珠
        if (count >= 5)
        {
            return 1;
        }
    }
    return 0;
}
```

## 项目结构
- `五子棋 copy 3.c` - 主程序文件（当前使用版本）
- 其他`五子棋 copy*.c`文件为开发过程中的不同版本

## 注意事项
1. 编译时需要链接数学库（-lm）
2. 确保输入坐标在棋盘范围内
3. AI思考时间随棋盘大小和搜索深度增加

## 详细技术实现说明

### 1. 主函数(main)执行流程
1. **初始化阶段**：
   - 提示用户输入棋盘尺寸(5-25)，默认15x15
   - 初始化棋盘状态(全空)
   - 打印初始空棋盘

2. **游戏主循环**：
   - **玩家回合**：
     * 提示玩家输入坐标(行列格式)
     * 验证坐标有效性(是否在棋盘范围内且为空位)
     * 在棋盘放置玩家棋子(X)
     * 检查是否形成五连珠(玩家胜利)
   - **AI回合**：
     * 调用ai_move()计算最佳落子位置
     * 在棋盘放置AI棋子(○)
     * 检查是否形成五连珠(AI胜利)
   - **平局检查**：
     * 当棋盘已满且无胜负时判定平局

3. **游戏结束处理**：
   - 显示最终胜负结果
   - 提供复盘功能(逐步展示整个对局过程)

### 2. AI决策系统(ai_move)
**防御策略**：
1. 优先检查玩家可能形成的威胁棋型：
   - 活四(必须立即阻挡)
   - 冲四(一端被堵的四连珠)
   - 活三(两端开放的三连珠)

**进攻策略**：
1. 使用α-β剪枝优化的极小极大算法：
   - 搜索深度：3层
   - 评估函数：evaluate_pos()差值
   - 剪枝条件：alpha ≥ beta时终止搜索

2. 搜索优化：
   - 仅考虑已有棋子周围2格范围内的空位
   - 中心位置奖励(棋盘中心区域价值更高)
   - 对称位置剪枝(减少重复计算)

### 3. 棋型评估系统(evaluate_pos)
**评分标准详细说明**：
1. **活棋(两端开放)**：
   - 活四：100000分(必胜)
   - 活三：5000分(高威胁)
   - 活二：500分(潜在威胁)

2. **眠棋(一端开放)**：
   - 冲四：10000分(次高威胁)
   - 眠三：1000分(中等威胁)
   - 眠二：100分(低威胁)

3. **死棋(两端封闭)**：
   - 无威胁价值，仅基础分

4. **位置奖励**：
   - 中心区域：额外加分(50*(BOARD_SIZE-距离))
   - 边角区域：基础分

**评估过程**：
1. 四个方向(水平、垂直、对角线)分别评估
2. 综合最高分方向和所有方向加权分
3. 考虑当前玩家和对手的分数差值

### 4. 胜负判断(check_win)
**实现细节**：
1. 四个方向检查：
   - 水平(→)
   - 垂直(↓) 
   - 主对角线(↘)
   - 副对角线(↙)

2. 检查逻辑：
   - 从当前位置向两个方向延伸
   - 统计连续同色棋子数
   - 任一方向≥5即判定胜利

3. 优化措施：
   - 边界检查避免数组越界
   - 提前终止(发现5连立即返回)

### 5. 复盘系统(review_process)
**实现机制**：
1. 数据结构：
   - 使用steps数组记录每一步落子
   - 包含玩家类型、坐标信息

2. 回放过程：
   - 逐步重建棋盘状态
   - 显示每一步的落子位置
   - 支持暂停/继续控制

3. 可视化：
   - 清晰的棋盘显示
   - 回合计数和玩家标识
   - 坐标转换(0-base转1-base)

### 6. 方向分析(count_specific_direction)
**算法细节**：
1. 输入参数：
   - 起始坐标(x,y)
   - 方向向量(dx,dy)
   - 玩家标识

2. 分析过程：
   - 正向延伸(统计连续棋子)
   - 反向延伸(统计连续棋子)
   - 检查两端开放状态

3. 输出结构：
   - 连续棋子数
   - 起点开放状态
   - 终点开放状态

**应用场景**：
1. 胜负判断
2. 棋型评估
3. 威胁检测