五子棋人机对战（easyx）

pyzyd

用easyx做了一个五子棋人机对战，本来想在寒假改进一下ai的算法，但是看不懂剪枝算法（或者我比较懒），就没改了，现在ai的算力只能战胜一些小白，直接展示作品。


有能力的人可以尝试改进


github代码地址

成品下载链接：
FIVE_CHESS_boxed.zip (1.6 MB, 下载次数: 0, 售价: 1 鱼币)

昨天 22:39 上传

点击文件名下载附件

FishC

以下是使用EasyX图形库实现的五子棋人机对战示例代码。该示例包含一个简单的AI算法，基于评分表选择落子位置，适合初学者理解。代码已去除外部链接，并遵循Discuz! BBCode格式要求。

1. 
   
2. #include <graphics.h>
   
3. #include <conio.h>
   
4. #include <time.h>
   
5. 
   
6. #define GRID_SIZE 40  // 格子大小
   
7. #define BOARD_SIZE 15 // 棋盘大小
   
8. 
   
9. int board[BOARD_SIZE][BOARD_SIZE] = {0}; // 0:空, 1:玩家, 2:AI
   
10. bool isPlayerTurn = true; // 玩家先手
    
11. 
    
12. // 绘制棋盘
    
13. void drawBoard() {
    
14.     setbkcolor(RGB(255, 205, 150)); // 设置背景色为浅橙色
    
15.     cleardevice();
    
16.     setlinecolor(BLACK);
    
17.     for (int i = 0; i < BOARD_SIZE; i++) {
    
18.         // 画横线
    
19.         line(GRID_SIZE, GRID_SIZE + i * GRID_SIZE, GRID_SIZE * BOARD_SIZE, GRID_SIZE + i * GRID_SIZE);
    
20.         // 画竖线
    
21.         line(GRID_SIZE + i * GRID_SIZE, GRID_SIZE, GRID_SIZE + i * GRID_SIZE, GRID_SIZE * BOARD_SIZE);
    
22.     }
    
23.     // 画棋盘上的五个小黑点（天元和四星）
    
24.     int dots[5][2] = {{3, 3}, {3, 11}, {7, 7}, {11, 3}, {11, 11}};
    
25.     setfillcolor(BLACK);
    
26.     for (int i = 0; i < 5; i++) {
    
27.         int x = GRID_SIZE + dots[i][0] * GRID_SIZE;
    
28.         int y = GRID_SIZE + dots[i][1] * GRID_SIZE;
    
29.         solidcircle(x, y, 5);
    
30.     }
    
31. }
    
32. 
    
33. // 绘制棋子
    
34. void drawPiece(int x, int y, int player) {
    
35.     if (player == 1) {
    
36.         setfillcolor(BLACK);
    
37.     } else if (player == 2) {
    
38.         setfillcolor(WHITE);
    
39.     } else {
    
40.         return;
    
41.     }
    
42.     int centerX = GRID_SIZE + x * GRID_SIZE;
    
43.     int centerY = GRID_SIZE + y * GRID_SIZE;
    
44.     solidcircle(centerX, centerY, GRID_SIZE / 2 - 2);
    
45. }
    
46. 
    
47. // 判断胜负
    
48. int checkWin(int x, int y) {
    
49.     int directions[4][2] = {{1, 0}, {0, 1}, {1, 1}, {1, -1}};
    
50.     for (int i = 0; i < 4; i++) {
    
51.         int count = 1;
    
52.         int dx = directions[i][0];
    
53.         int dy = directions[i][1];
    
54.         // 正向检查
    
55.         for (int step = 1; step <= 4; step++) {
    
56.             int nx = x + dx * step;
    
57.             int ny = y + dy * step;
    
58.             if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE || board[nx][ny] != board[x][y]) {
    
59.                 break;
    
60.             }
    
61.             count++;
    
62.         }
    
63.         // 反向检查
    
64.         for (int step = 1; step <= 4; step++) {
    
65.             int nx = x - dx * step;
    
66.             int ny = y - dy * step;
    
67.             if (nx < 0 || nx >= BOARD_SIZE || ny < 0 || ny >= BOARD_SIZE || board[nx][ny] != board[x][y]) {
    
68.                 break;
    
69.             }
    
70.             count++;
    
71.         }
    
72.         if (count >= 5) {
    
73.             return board[x][y];
    
74.         }
    
75.     }
    
76.     return 0;
    
77. }
    
78. 
    
79. // 简单AI：基于评分表选择位置
    
80. void aiMove() {
    
81.     int bestScore = -1;
    
82.     int bestX = -1, bestY = -1;
    
83.     for (int x = 0; x < BOARD_SIZE; x++) {
    
84.         for (int y = 0; y < BOARD_SIZE; y++) {
    
85.             if (board[x][y] == 0) {
    
86.                 // 简单评分：优先选择靠近中心的位置
    
87.                 int score = 0;
    
88.                 int center = BOARD_SIZE / 2;
    
89.                 score -= abs(x - center) + abs(y - center); // 距离中心越近，分数越高（负值越小）
    
90.                 // 如果该位置周围有棋子，增加分数
    
91.                 for (int dx = -1; dx <= 1; dx++) {
    
92.                     for (int dy = -1; dy <= 1; dy++) {
    
93.                         int nx = x + dx;
    
94.                         int ny = y + dy;
    
95.                         if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE) {
    
96.                             if (board[nx][ny] == 2) {
    
97.                                 score += 10; // AI自己的棋子
    
98.                             } else if (board[nx][ny] == 1) {
    
99.                                 score += 5;  // 玩家的棋子
    
100.                             }
     
101.                         }
     
102.                     }
     
103.                 }
     
104.                 if (score > bestScore) {
     
105.                     bestScore = score;
     
106.                     bestX = x;
     
107.                     bestY = y;
     
108.                 }
     
109.             }
     
110.         }
     
111.     }
     
112.     if (bestX != -1 && bestY != -1) {
     
113.         board[bestX][bestY] = 2;
     
114.         drawPiece(bestX, bestY, 2);
     
115.     }
     
116. }
     
117. 
     
118. int main() {
     
119.     initgraph(GRID_SIZE * (BOARD_SIZE + 1), GRID_SIZE * (BOARD_SIZE + 1));
     
120.     drawBoard();
     
121.     settextstyle(20, 0, _T("宋体"));
     
122.     settextcolor(BLACK);
     
123.     outtextxy(10, 10, _T("玩家执黑先手，AI执白后手"));
     
124. 
     
125.     while (true) {
     
126.         if (isPlayerTurn) {
     
127.             MOUSEMSG msg = GetMouseMsg();
     
128.             if (msg.uMsg == WM_LBUTTONDOWN) {
     
129.                 int x = (msg.x - GRID_SIZE / 2) / GRID_SIZE;
     
130.                 int y = (msg.y - GRID_SIZE / 2) / GRID_SIZE;
     
131.                 if (x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == 0) {
     
132.                     board[x][y] = 1;
     
133.                     drawPiece(x, y, 1);
     
134.                     if (checkWin(x, y) == 1) {
     
135.                         MessageBox(GetHWnd(), _T("玩家获胜！"), _T("游戏结束"), MB_OK);
     
136.                         break;
     
137.                     }
     
138.                     isPlayerTurn = false;
     
139.                 }
     
140.             }
     
141.         } else {
     
142.             // AI下棋
     
143.             aiMove();
     
144.             // 检查AI是否获胜
     
145.             for (int x = 0; x < BOARD_SIZE; x++) {
     
146.                 for (int y = 0; y < BOARD_SIZE; y++) {
     
147.                     if (board[x][y] == 2 && checkWin(x, y) == 2) {
     
148.                         drawBoard(); // 重绘棋盘以显示所有棋子
     
149.                         for (int i = 0; i < BOARD_SIZE; i++) {
     
150.                             for (int j = 0; j < BOARD_SIZE; j++) {
     
151.                                 if (board[i][j] != 0) {
     
152.                                     drawPiece(i, j, board[i][j]);
     
153.                                 }
     
154.                             }
     
155.                         }
     
156.                         MessageBox(GetHWnd(), _T("AI获胜！"), _T("游戏结束"), MB_OK);
     
157.                         closegraph();
     
158.                         return 0;
     
159.                     }
     
160.                 }
     
161.             }
     
162.             isPlayerTurn = true;
     
163.         }
     
164.         // 检查平局（棋盘已满）
     
165.         bool isFull = true;
     
166.         for (int x = 0; x < BOARD_SIZE; x++) {
     
167.             for (int y = 0; y < BOARD_SIZE; y++) {
     
168.                 if (board[x][y] == 0) {
     
169.                     isFull = false;
     
170.                     break;
     
171.                 }
     
172.             }
     
173.             if (!isFull) break;
     
174.         }
     
175.         if (isFull) {
     
176.             MessageBox(GetHWnd(), _T("平局！"), _T("游戏结束"), MB_OK);
     
177.             break;
     
178.         }
     
179.     }
     
180.     closegraph();
     
181.     return 0;
     
182. }
     

复制代码

使用说明：
1. 确保已安装 EasyX 图形库（建议使用Visual Studio开发环境）。
2. 创建一个Win32控制台应用程序项目，将上述代码复制到主文件中。
3. 编译运行即可。

注意事项：
- 该AI算法较为简单，仅基于距离中心和相邻棋子进行评分，因此棋力有限。
- 如需改进AI，可考虑实现 Minimax 算法配合 Alpha-Beta剪枝，或使用模式评分表（如冲四、活三等棋形评分）。
- 代码中已去除所有外部链接，确保符合要求。

希望这个示例能帮助你理解五子棋人机对战的基本实现。如果需要进一步优化AI，建议学习博弈树搜索相关算法。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。