五子棋

lymbwx

1. import pygame
   
2. import random
   
3. import sys
   
4. import os
   
5. 
   
6. # ===================== 基础配置 =====================
   
7. pygame.init()
   
8. pygame.mixer.init()
   
9. 
   
10. GRID_SIZE = 40
    
11. BOARD_LINE = 15
    
12. BOARD_WIDTH = GRID_SIZE * (BOARD_LINE - 1)
    
13. PADDING = 30
    
14. WINDOW_W = BOARD_WIDTH + PADDING * 2
    
15. WINDOW_H = BOARD_WIDTH + PADDING * 2 + 60
    
16. 
    
17. # 颜色
    
18. WHITE = (255, 255, 255)
    
19. BLACK = (0, 0, 0)
    
20. BOARD_COLOR = (220, 179, 92)
    
21. RED = (200, 0, 0)
    
22. BLUE = (0, 0, 200)
    
23. GRAY = (180, 180, 180)
    
24. HOVER_COLOR = (150, 150, 150)
    
25. 
    
26. # 窗口 & 字体
    
27. screen = pygame.display.set_mode((WINDOW_W, WINDOW_H))
    
28. pygame.display.set_caption("五子棋 | 双人/人机对战")
    
29. 
    
30. def get_chinese_font(size=24):
    
31.     font_path = "C:/Windows/Fonts/simhei.ttf"
    
32.     if os.path.exists(font_path):
    
33.         return pygame.font.Font(font_path, size)
    
34.     return pygame.font.Font(None, size)
    
35. 
    
36. font = get_chinese_font(24)
    
37. big_font = get_chinese_font(48)
    
38. 
    
39. # 音乐音效（找不到文件自动跳过）
    
40. place_sound = win_sound = lose_sound = None
    
41. try:
    
42.     pygame.mixer.music.load("anything/bg_music.mp3")
    
43.     pygame.mixer.music.set_volume(0.3)
    
44.     pygame.mixer.music.play(-1)
    
45. except:
    
46.     pass
    
47. try:
    
48.     place_sound = pygame.mixer.Sound("anything/place.wav")
    
49.     win_sound = pygame.mixer.Sound("anything/win.wav")
    
50.     lose_sound = pygame.mixer.Sound("anything/lose.wav")
    
51. except:
    
52.     pass
    
53. 
    
54. # 游戏状态
    
55. board = [[0] * (BOARD_LINE - 1) for _ in range(BOARD_LINE - 1)]
    
56. current_player = 1
    
57. game_mode = 0
    
58. game_over = False
    
59. winner = 0
    
60. 
    
61. # 按钮区域
    
62. btn_1_rect = pygame.Rect(50, WINDOW_H - 50, 150, 40)
    
63. btn_2_rect = pygame.Rect(250, WINDOW_H - 50, 150, 40)
    
64. btn_reset_rect = pygame.Rect(450, WINDOW_H - 50, 150, 40)
    
65. 
    
66. # 四个方向
    
67. DIRS = [(1, 0), (0, 1), (1, 1), (1, -1)]
    
68. 
    
69. # ===================== 绘制函数 =====================
    
70. def draw_board():
    
71.     screen.fill(BOARD_COLOR)
    
72.     for i in range(BOARD_LINE):
    
73.         pygame.draw.line(screen, BLACK,
    
74.                          (PADDING, PADDING + i * GRID_SIZE),
    
75.                          (PADDING + BOARD_WIDTH, PADDING + i * GRID_SIZE), 1)
    
76.         pygame.draw.line(screen, BLACK,
    
77.                          (PADDING + i * GRID_SIZE, PADDING),
    
78.                          (PADDING + i * GRID_SIZE, PADDING + BOARD_WIDTH), 1)
    
79.     pos = [3, 7, 11]
    
80.     for x in pos:
    
81.         for y in pos:
    
82.             cx = PADDING + x * GRID_SIZE
    
83.             cy = PADDING + y * GRID_SIZE
    
84.             pygame.draw.circle(screen, BLACK, (cx, cy), 4)
    
85. 
    
86. def draw_pieces():
    
87.     for x in range(BOARD_LINE - 1):
    
88.         for y in range(BOARD_LINE - 1):
    
89.             val = board[x][y]
    
90.             if val == 0:
    
91.                 continue
    
92.             cx = PADDING + x * GRID_SIZE
    
93.             cy = PADDING + y * GRID_SIZE
    
94.             radius = GRID_SIZE // 2 - 2
    
95.             if val == 1:
    
96.                 pygame.draw.circle(screen, BLACK, (cx, cy), radius)
    
97.             else:
    
98.                 pygame.draw.circle(screen, WHITE, (cx, cy), radius)
    
99.                 pygame.draw.circle(screen, BLACK, (cx, cy), radius, 1)
    
100. 
     
101. def draw_buttons():
     
102.     mp = pygame.mouse.get_pos()
     
103.     # 双人
     
104.     c = HOVER_COLOR if btn_1_rect.collidepoint(mp) else GRAY
     
105.     pygame.draw.rect(screen, c, btn_1_rect)
     
106.     pygame.draw.rect(screen, BLACK, btn_1_rect, 2)
     
107.     t = font.render("双人对战", True, BLACK)
     
108.     screen.blit(t, (btn_1_rect.x + 30, btn_1_rect.y + 8))
     
109.     # 人机
     
110.     c = HOVER_COLOR if btn_2_rect.collidepoint(mp) else GRAY
     
111.     pygame.draw.rect(screen, c, btn_2_rect)
     
112.     pygame.draw.rect(screen, BLACK, btn_2_rect, 2)
     
113.     t = font.render("人机对战", True, BLACK)
     
114.     screen.blit(t, (btn_2_rect.x + 30, btn_2_rect.y + 8))
     
115.     # 重置
     
116.     c = HOVER_COLOR if btn_reset_rect.collidepoint(mp) else GRAY
     
117.     pygame.draw.rect(screen, c, btn_reset_rect)
     
118.     pygame.draw.rect(screen, BLACK, btn_reset_rect, 2)
     
119.     t = font.render("重置游戏", True, BLACK)
     
120.     screen.blit(t, (btn_reset_rect.x + 30, btn_reset_rect.y + 8))
     
121. 
     
122. def draw_win_popup():
     
123.     if not game_over:
     
124.         return
     
125.     overlay = pygame.Surface((WINDOW_W, WINDOW_H), pygame.SRCALPHA)
     
126.     overlay.fill((0, 0, 0, 180))
     
127.     screen.blit(overlay, (0, 0))
     
128.     rect = pygame.Rect(WINDOW_W//2-150, WINDOW_H//2-80, 300, 160)
     
129.     pygame.draw.rect(screen, WHITE, rect)
     
130.     pygame.draw.rect(screen, BLACK, rect, 3)
     
131.     if winner == 1:
     
132.         txt = big_font.render("黑棋获胜！", True, BLACK)
     
133.     elif winner == 2:
     
134.         txt = big_font.render("白棋获胜！", True, BLACK)
     
135.     else:
     
136.         txt = big_font.render("平局！", True, BLACK)
     
137.     screen.blit(txt, (rect.centerx - txt.get_width()//2, rect.y + 30))
     
138.     tip = font.render("点击任意位置继续", True, BLACK)
     
139.     screen.blit(tip, (rect.centerx - tip.get_width()//2, rect.y + 100))
     
140. 
     
141. # ===================== 逻辑 & 增强AI =====================
     
142. def get_mouse_pos(pos):
     
143.     x, y = pos
     
144.     xi = round((x - PADDING) / GRID_SIZE)
     
145.     yi = round((y - PADDING) / GRID_SIZE)
     
146.     if 0 <= xi < BOARD_LINE-1 and 0 <= yi < BOARD_LINE-1:
     
147.         return xi, yi
     
148.     return -1, -1
     
149. 
     
150. def is_win(x, y, player):
     
151.     for dx, dy in DIRS:
     
152.         cnt = 1
     
153.         nx, ny = x+dx, y+dy
     
154.         while 0<=nx<BOARD_LINE-1 and 0<=ny<BOARD_LINE-1 and board[nx][ny]==player:
     
155.             cnt +=1
     
156.             nx += dx
     
157.             ny += dy
     
158.         nx, ny = x-dx, y-dy
     
159.         while 0<=nx<BOARD_LINE-1 and 0<=ny<BOARD_LINE-1 and board[nx][ny]==player:
     
160.             cnt +=1
     
161.             nx -= dx
     
162.             ny -= dy
     
163.         if cnt >=5:
     
164.             return True
     
165.     return False
     
166. 
     
167. # 评估单个点位分数（核心AI算法）
     
168. def eval_point(x, y, player):
     
169.     score = 0
     
170.     enemy = 1 if player == 2 else 2
     
171.     for dx, dy in DIRS:
     
172.         # 向一侧延伸
     
173.         p1, e1, b1 = 0, 0, 0
     
174.         nx, ny = x+dx, y+dy
     
175.         while 0<=nx<BOARD_LINE-1 and 0<=ny<BOARD_LINE-1:
     
176.             if board[nx][ny] == player:
     
177.                 p1 +=1
     
178.             elif board[nx][ny] == enemy:
     
179.                 e1 +=1
     
180.                 break
     
181.             else:
     
182.                 b1 +=1
     
183.                 break
     
184.             nx += dx
     
185.             ny += dy
     
186.         # 另一侧延伸
     
187.         p2, e2, b2 = 0, 0, 0
     
188.         nx, ny = x-dx, y-dy
     
189.         while 0<=nx<BOARD_LINE-1 and 0<=ny<BOARD_LINE-1:
     
190.             if board[nx][ny] == player:
     
191.                 p2 +=1
     
192.             elif board[nx][ny] == enemy:
     
193.                 e2 +=1
     
194.                 break
     
195.             else:
     
196.                 b2 +=1
     
197.                 break
     
198.             nx -= dx
     
199.             ny -= dy
     
200.         total_p = p1 + p2
     
201.         total_e = e1 + e2
     
202. 
     
203.         # 计分规则（五子棋棋型权重）
     
204.         if total_p >=4:
     
205.             score += 100000   # 五连，必胜
     
206.         elif total_p ==3:
     
207.             if e1==0 and e2==0:
     
208.                 score += 10000  # 活四
     
209.             elif e1==0 or e2==0:
     
210.                 score += 5000   # 冲四
     
211.         elif total_p ==2:
     
212.             if e1==0 and e2==0:
     
213.                 score += 1000   # 活三
     
214.             elif e1==0 or e2==0:
     
215.                 score += 500    # 眠三
     
216.         elif total_p ==1:
     
217.             if e1==0 and e2==0:
     
218.                 score += 100    # 活二
     
219.             else:
     
220.                 score += 50
     
221.     # 靠近棋盘中心加分（优先占天元/星位）
     
222.     cx = (BOARD_LINE-2) // 2
     
223.     cy = (BOARD_LINE-2) // 2
     
224.     dis = abs(x-cx) + abs(y-cy)
     
225.     score += (20 - dis) * 2
     
226.     return score
     
227. 
     
228. # 强化AI：全局选最优点
     
229. def ai_play():
     
230.     best_score = -1
     
231.     best_pos = None
     
232.     # 遍历所有空位
     
233.     for x in range(BOARD_LINE-1):
     
234.         for y in range(BOARD_LINE-1):
     
235.             if board[x][y] != 0:
     
236.                 continue
     
237.             # 1. AI自己进攻分数
     
238.             board[x][y] = 2
     
239.             s1 = eval_point(x, y, 2)
     
240.             # 2. 防守：玩家在此落子的分数（必须堵）
     
241.             s2 = eval_point(x, y, 1)
     
242.             total = s1 + s2 * 1.2  # 防守权重略高
     
243.             board[x][y] = 0
     
244. 
     
245.             if total > best_score:
     
246.                 best_score = total
     
247.                 best_pos = (x, y)
     
248.     if best_pos:
     
249.         x, y = best_pos
     
250.         board[x][y] = 2
     
251.         if place_sound:
     
252.             place_sound.play()
     
253. 
     
254. def reset_game():
     
255.     global board, current_player, game_over, winner
     
256.     board = [[0]*(BOARD_LINE-1) for _ in range(BOARD_LINE-1)]
     
257.     current_player = 1
     
258.     game_over = False
     
259.     winner = 0
     
260. 
     
261. # ===================== 主循环 =====================
     
262. def main():
     
263.     global current_player, game_mode, game_over, winner
     
264.     clock = pygame.time.Clock()
     
265.     running = True
     
266. 
     
267.     while running:
     
268.         clock.tick(60)
     
269.         draw_board()
     
270.         draw_pieces()
     
271.         draw_buttons()
     
272.         draw_win_popup()
     
273. 
     
274.         for event in pygame.event.get():
     
275.             if event.type == pygame.QUIT:
     
276.                 running = False
     
277. 
     
278.             # 胜负弹窗点击重置
     
279.             if game_over and event.type == pygame.MOUSEBUTTONDOWN:
     
280.                 reset_game()
     
281.                 continue
     
282. 
     
283.             # 按钮点击
     
284.             if event.type == pygame.MOUSEBUTTONDOWN:
     
285.                 mx, my = pygame.mouse.get_pos()
     
286.                 if btn_1_rect.collidepoint((mx, my)):
     
287.                     game_mode = 1
     
288.                     reset_game()
     
289.                 elif btn_2_rect.collidepoint((mx, my)):
     
290.                     game_mode = 2
     
291.                     reset_game()
     
292.                 elif btn_reset_rect.collidepoint((mx, my)):
     
293.                     reset_game()
     
294. 
     
295.             # R键重置
     
296.             if event.type == pygame.KEYDOWN:
     
297.                 if event.key == pygame.K_r:
     
298.                     reset_game()
     
299. 
     
300.             # 棋盘落子
     
301.             if event.type == pygame.MOUSEBUTTONDOWN and not game_over and game_mode != 0:
     
302.                 mx, my = pygame.mouse.get_pos()
     
303.                 x, y = get_mouse_pos((mx, my))
     
304.                 if x == -1 or y == -1 or board[x][y] != 0:
     
305.                     continue
     
306. 
     
307.                 if game_mode == 1:
     
308.                     # 双人模式
     
309.                     board[x][y] = current_player
     
310.                     if place_sound:
     
311.                         place_sound.play()
     
312.                     if is_win(x, y, current_player):
     
313.                         game_over = True
     
314.                         winner = current_player
     
315.                         if winner == 1 and win_sound:
     
316.                             win_sound.play()
     
317.                         elif winner == 2 and lose_sound:
     
318.                             lose_sound.play()
     
319.                     current_player = 2 if current_player == 1 else 1
     
320.                 else:
     
321.                     # 人机模式
     
322.                     if current_player == 1:
     
323.                         board[x][y] = 1
     
324.                         if place_sound:
     
325.                             place_sound.play()
     
326.                         if is_win(x, y, 1):
     
327.                             game_over = True
     
328.                             winner = 1
     
329.                             if win_sound:
     
330.                                 win_sound.play()
     
331.                         else:
     
332.                             # AI落子
     
333.                             ai_play()
     
334.                             # 检测AI是否获胜
     
335.                             win_flag = False
     
336.                             for i in range(BOARD_LINE-1):
     
337.                                 for j in range(BOARD_LINE-1):
     
338.                                     if board[i][j] == 2 and is_win(i, j, 2):
     
339.                                         game_over = True
     
340.                                         winner = 2
     
341.                                         win_flag = True
     
342.                                         if lose_sound:
     
343.                                             lose_sound.play()
     
344.                                         break
     
345.                                 if win_flag:
     
346.                                     break
     
347. 
     
348.         pygame.display.update()
     
349. 
     
350.     pygame.quit()
     
351.     sys.exit()
     
352. 
     
353. if __name__ == "__main__":
     
354.     main()

复制代码

FishC

以下是针对你提供的五子棋代码的几个关键问题和改进建议，按照 BBCode 格式整理，请对照检查：

• board初始化错误：第15行的写法不正确，应该使用嵌套列表推导式。当前写法会导致语法错误。
  
  1. # 正确的初始化方式
     
  2. board = [[0] * (BOARD_LINE - 1) for _ in range(BOARD_LINE - 1)]

  复制代码
  
  
• 缺少方向定义：第39行 DIRS = 不完整，必须补充四个方向的偏移值，用于胜负判断和AI。
  
  1. DIRS = [(1,0), (0,1), (1,1), (1,-1)]

  复制代码
  
  
• 绘制棋子时的索引错误：第33行写法有误，应使用二维索引 board[x][y] 而非 board[x]y。
  
  1. # 正确写法
     
  2. val = board[x][y]

  复制代码
  
  
• 游戏胜负判断功能缺失：代码中没有实现检测五子连珠的逻辑，即使满足胜利条件也不会触发。需要在每次落子后调用检查函数。
  
• 鼠标点击处理未完成：get_mouse_pos 函数虽然定义了，但没有被调用。主循环中需要使用鼠标位置来判断落子点。
  
• AI对战功能为空白：虽然写了“人机对战”按钮，但没有任何AI算法代码。建议先实现一个简单的随机AI或基于评分的贪心AI。
  

此外，建议在代码开头加入 pygame.display.set_mode 时使用 pygame.RESIZABLE 标志，方便调试窗口大小；音乐和音效路径（anything/）若不存在会导致异常，建议用 try-except 处理并友好提示。

你可以根据以上建议逐步修正代码，完成后即可实现一个可玩的双人对战五子棋程序。如果需要进一步的AI教学或完整代码示例，请说明具体需求，我会继续协助你。

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