python

过默

象棋棋盘，怎么用python代码写？棋子怎么移动

FishC

中国象棋的Python实现主要分为棋盘表示和棋子移动两大部分。下面是一个简洁易懂的入门框架，你可以在此基础上扩展完整规则。

• **棋盘表示**：通常用10行9列的二维列表（list），每个元素存储棋子对象或空值（如None）。
• **棋子类**：每个棋子有颜色、类型、当前位置。类型包括“车、马、象、士、将、炮、兵”。
• **移动函数**：根据棋子类型，判断目标位置是否合法（走法规则+不能吃己方棋子）。
  

下面是一个简化的代码示例（仅展示核心结构，未实现所有走法）：

1. 
   
2. class ChessPiece:
   
3.     def __init__(self, color, piece_type):
   
4.         self.color = color        # 'red' or 'black'
   
5.         self.piece_type = piece_type
   
6. 
   
7. board = [[None for _ in range(9)] for _ in range(10)]
   
8. 
   
9. # 初始化示例（红方车在左下角）
   
10. board[9][0] = ChessPiece('red', 'rook')
    
11. 
    
12. def move_piece(from_row, from_col, to_row, to_col):
    
13.     piece = board[from_row][from_col]
    
14.     if piece is None:
    
15.         return False
    
16.     # 检查目标位置是否合法（此处以“车”为例：只能直线移动）
    
17.     if piece.piece_type == 'rook':
    
18.         if from_row == to_row:  # 横向移动
    
19.             step = 1 if to_col > from_col else -1
    
20.             for col in range(from_col + step, to_col, step):
    
21.                 if board[from_row][col] is not None:
    
22.                     return False  # 有阻挡
    
23.         elif from_col == to_col:  # 纵向移动
    
24.             step = 1 if to_row > from_row else -1
    
25.             for row in range(from_row + step, to_row, step):
    
26.                 if board[row][from_col] is not None:
    
27.                     return False
    
28.         else:
    
29.             return False  # 不沿直线，非法
    
30.         # 不能吃己方棋子
    
31.         target = board[to_row][to_col]
    
32.         if target is not None and target.color == piece.color:
    
33.             return False
    
34.         # 执行移动
    
35.         board[to_row][to_col] = piece
    
36.         board[from_row][from_col] = None
    
37.         return True
    
38.     # 其他棋子走法类似，需要分别实现
    
39.     return False
    

复制代码

如果你希望有图形界面，可以使用pygame或tkinter绘制棋盘和棋子，但核心逻辑与上述相同。记住，完整的象棋程序需要为每种棋子（车、马、象、士、将、炮、兵）实现各自的移动规则和特殊限制（如马脚、象眼、炮架、老将对面等）。

建议从控制台版本开始练习，逐步添加规则判断。

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

过默

FishC 发表于 2026-7-15 08:13
中国象棋的Python实现主要分为棋盘表示和棋子移动两大部分。下面是一个简洁易懂的入门框架，你可以在此基础 ...

**棋盘表示**：通常用10行9列的二维列表（list），每个元素存储棋子对象或空值（如None）。
怎么使用pygame或tkinter绘制棋盘棋子？

FishC

过默 发表于 2026-07-15 08:15
FishC 发表于 2026-7-15 08:13
中国象棋的Python实现 ...

使用 pygame 或 tkinter 绘制中国象棋棋盘和棋子，本质是两步：画出 9×10 的网格线，然后在交点贴上棋子（圆形或图片）。下面给出两种方案的核心思路和精简代码（仅展示绘图部分，不含游戏逻辑）。

---

**一、用 tkinter 绘制（无需额外安装）**

**1. 创建画布，设置坐标**

棋盘每个格子宽高设为 SIZE = 60 像素，棋子半径为 R = 25。左上角起始点 (padding, padding)。

**2. 画竖线和横线（注意河界留空）**

1. 
   
2. import tkinter as tk
   
3. 
   
4. root = tk.Tk()
   
5. canvas = tk.Canvas(root, width=700, height=750, bg='white')
   
6. canvas.pack()
   
7. 
   
8. SIZE = 60
   
9. R = 25
   
10. padding = 30
    
11. 
    
12. # 画横线：10行（0-9）
    
13. for row in range(10):
    
14.     y = padding + row * SIZE
    
15.     canvas.create_line(padding, y, padding + 8*SIZE, y, width=2)
    
16. 
    
17. # 画竖线：9列（0-8），但中间河界（第4、5行之间）不画竖线
    
18. for col in range(9):
    
19.     x = padding + col * SIZE
    
20.     # 上半棋盘（行0-4）
    
21.     canvas.create_line(x, padding, x, padding + 4*SIZE, width=2)
    
22.     # 下半棋盘（行5-9）
    
23.     canvas.create_line(x, padding + 5*SIZE, x, padding + 9*SIZE, width=2)
    
24. 
    
25. # 画交叉点装饰（可选）
    
26. for row in range(10):
    
27.     for col in range(9):
    
28.         cx = padding + col * SIZE
    
29.         cy = padding + row * SIZE
    
30.         # 在边框线端点添加小圆点（仅内部交叉点可省略）
    
31.         if (col==0 or col==8) and (row==0 or row==9):
    
32.             canvas.create_oval(cx-3, cy-3, cx+3, cy+3, fill='black')
    
33. root.mainloop()
    

复制代码

**3. 画棋子**

1. 
   
2. # 在 (col, row) 处画一个红方“车”
   
3. def draw_piece(canvas, col, row, color, text):
   
4.     x = padding + col * SIZE
   
5.     y = padding + row * SIZE
   
6.     canvas.create_oval(x-R, y-R, x+R, y+R, fill=color, outline='black', width=2)
   
7.     canvas.create_text(x, y, text=text, font=('Arial', 20, 'bold'), fill='white' if color=='red' else 'black')
   
8. 
   
9. # 示例：红车在(0,9)位置
   
10. draw_piece(canvas, 0, 9, 'red', '车')
    
11. root.mainloop()
    

复制代码

---

**二、用 pygame 绘制（更灵活、适合游戏循环）**

**1. 初始化并定义颜色**

1. 
   
2. import pygame
   
3. pygame.init()
   
4. SIZE = 60
   
5. R = 25
   
6. WIDTH = 700
   
7. HEIGHT = 750
   
8. screen = pygame.display.set_mode((WIDTH, HEIGHT))
   
9. pygame.display.set_caption('中国象棋')
   

复制代码

**2. 绘制棋盘（先画背景色，再画线）**

1. 
   
2. screen.fill((220, 180, 140))  # 木色背景
   
3. padding = 30
   
4. 
   
5. # 画横线
   
6. for row in range(10):
   
7.     start = (padding, padding + row * SIZE)
   
8.     end = (padding + 8 * SIZE, padding + row * SIZE)
   
9.     pygame.draw.line(screen, (0,0,0), start, end, 2)
   
10. 
    
11. # 画竖线（分上下半棋盘）
    
12. for col in range(9):
    
13.     x = padding + col * SIZE
    
14.     top_start = (x, padding)
    
15.     top_end = (x, padding + 4 * SIZE)
    
16.     bot_start = (x, padding + 5 * SIZE)
    
17.     bot_end = (x, padding + 9 * SIZE)
    
18.     pygame.draw.line(screen, (0,0,0), top_start, top_end, 2)
    
19.     pygame.draw.line(screen, (0,0,0), bot_start, bot_end, 2)
    
20. 
    
21. # 添加交叉点装饰（可选，用圆点）
    
22. for row in range(10):
    
23.     for col in range(9):
    
24.         if (col==0 or col==8) and (row==0 or row==9):
    
25.             cx = padding + col * SIZE
    
26.             cy = padding + row * SIZE
    
27.             pygame.draw.circle(screen, (0,0,0), (cx, cy), 3)
    
28. pygame.display.flip()
    

复制代码

**3. 画棋子函数**

1. 
   
2. def draw_piece(screen, col, row, color, text, font):
   
3.     x = padding + col * SIZE
   
4.     y = padding + row * SIZE
   
5.     pygame.draw.circle(screen, (0,0,0), (x, y), R, 2)  # 边框
   
6.     pygame.draw.circle(screen, color, (x, y), R-2)     # 填充
   
7.     text_surface = font.render(text, True, (0,0,0))
   
8.     text_rect = text_surface.get_rect(center=(x, y))
   
9.     screen.blit(text_surface, text_rect)
   
10. 
    
11. font = pygame.font.SysFont('simhei', 24)
    
12. draw_piece(screen, 0, 9, (200,50,50), '车', font)
    
13. pygame.display.flip()
    

复制代码

---

**要点总结**：  
- tkinter 适合静态应用和简单交互，pygame 更适合游戏循环、实时动画。  
- 棋子坐标（col, row）对应 0≤col≤8，0≤row≤9。  
- 绘制时注意“河界”（第4、5行之间）不画竖线，只保留边框。  
- 棋子颜色建议红方用红色圆、黑方用黑色圆，文字用对比色。

你可以复制上述代码运行查看效果，再结合之前给出的棋子移动逻辑，即可做出一个简易象棋程序。动手试试吧！

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

过默

FishC 发表于 2026-7-15 08:15
使用 pygame 或 tkinter 绘制中国象棋棋盘和棋子，本质是两步：画出 9×10 的网格线，然后在交点贴上棋 ...

# 示例：红车在(0,9)位置
draw_piece(canvas, 0, 9, 'red', '车')
draw_piece(canvas,0, 7,'red','马')
马位置不对

FishC

过默 发表于 2026-07-15 08:24
FishC 发表于 2026-7-15 08:15
使用 pygame 或 tkint ...

抱歉，我给的示例代码中 `draw_piece(canvas, 0, 7, 'red', '马')` 确实不是象棋的标准初始位置。标准红方马应在 **(1, 9)** 和 **(7, 9)** 两处，黑方马则在 **(1, 0)** 和 **(7, 0)**。

代码中的坐标参数 `(col, row)` 遵循：
- **col**（列）: 0（最左边）到 8（最右边）
- **row**（行）: 0（最上边，黑方底线）到 9（最下边，红方底线）

如果你想初始化一个标准布局，可以这样写：

1. # 红方（row=9 为底线）
   
2. draw_piece(canvas, 0, 9, 'red', '车')   # 左车
   
3. draw_piece(canvas, 1, 9, 'red', '马')   # 左马（正确位置）
   
4. draw_piece(canvas, 2, 9, 'red', '象')   # 左相
   
5. draw_piece(canvas, 3, 9, 'red', '士')   # 左士
   
6. draw_piece(canvas, 4, 9, 'red', '将')   # 帅
   
7. draw_piece(canvas, 5, 9, 'red', '士')   # 右士
   
8. draw_piece(canvas, 6, 9, 'red', '象')   # 右相
   
9. draw_piece(canvas, 7, 9, 'red', '马')   # 右马
   
10. draw_piece(canvas, 8, 9, 'red', '车')   # 右车
    
11. draw_piece(canvas, 1, 7, 'red', '炮')   # 左炮
    
12. draw_piece(canvas, 7, 7, 'red', '炮')   # 右炮
    
13. for col in range(0, 9, 2):             # 兵在 (0,6), (2,6), (4,6), (6,6), (8,6)
    
14.     draw_piece(canvas, col, 6, 'red', '兵')
    
15. 
    
16. # 黑方（row=0 为底线）
    
17. draw_piece(canvas, 0, 0, 'black', '車')
    
18. draw_piece(canvas, 1, 0, 'black', '馬')
    
19. draw_piece(canvas, 2, 0, 'black', '象')
    
20. draw_piece(canvas, 3, 0, 'black', '士')
    
21. draw_piece(canvas, 4, 0, 'black', '将')
    
22. draw_piece(canvas, 5, 0, 'black', '士')
    
23. draw_piece(canvas, 6, 0, 'black', '象')
    
24. draw_piece(canvas, 7, 0, 'black', '馬')
    
25. draw_piece(canvas, 8, 0, 'black', '車')
    
26. draw_piece(canvas, 1, 2, 'black', '炮')
    
27. draw_piece(canvas, 7, 2, 'black', '炮')
    
28. for col in range(0, 9, 2):
    
29.     draw_piece(canvas, col, 3, 'black', '卒')

复制代码

注意：棋盘最下面一行（row=9）是红方，最上面一行（row=0）是黑方。按照这个布局运行，就能看到标准的象棋开局画面了。

感谢你的细心指出，祝你编程愉快！

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

过默

FishC 发表于 2026-7-15 08:25
抱歉，我给的示例代码中 `draw_piece(canvas, 0, 7, 'red', '马')` 确实不是象棋的标准初始位置。标准 ...

# 黑方（row=0 为底线）
draw_piece(canvas, 0, 0, 'black', '車')
draw_piece(canvas, 1, 0, 'black', '馬')
draw_piece(canvas, 2, 0, 'black', '象')
draw_piece(canvas, 3, 0, 'black', '士')
draw_piece(canvas, 4, 0, 'black', '将')
draw_piece(canvas, 5, 0, 'black', '士')
draw_piece(canvas, 6, 0, 'black', '象')
draw_piece(canvas, 7, 0, 'black', '馬')
draw_piece(canvas, 8, 0, 'black', '車')
draw_piece(canvas, 1, 2, 'black', '炮')
draw_piece(canvas, 7, 2, 'black', '炮')
for col in range(0, 9, 2):
    draw_piece(canvas, col, 3, 'black', '卒')

黑没字

FishC

过默 发表于 2026-07-15 08:27
FishC 发表于 2026-7-15 08:25
抱歉，我给的示例代码 ...

你说得对，“黑没字”是因为黑方棋子文字的颜色与背景相同，导致看不见。在之前给出的 `draw_piece` 函数中，文字颜色是这样设置的：

1. canvas.create_text(x, y, text=text, font=('Arial', 20, 'bold'), fill='white' if color=='red' else 'black')

复制代码

当 `color` 为 `'red'` 时文字白色，在红色圆上看得见；但 `color` 为 `'black'` 时文字黑色，而圆背景也是黑色，于是文字完全消失。

**修正方法**：无论红方还是黑方，文字颜色都设为白色（或浅色）。修改后：

1. canvas.create_text(x, y, text=text, font=('Arial', 20, 'bold'), fill='white')

复制代码

完整修正的 `draw_piece` 函数：

1. def draw_piece(canvas, col, row, color, text):
   
2.     x = padding + col * SIZE
   
3.     y = padding + row * SIZE
   
4.     # 画黑色边框
   
5.     canvas.create_oval(x-R, y-R, x+R, y+R, outline='black', width=2)
   
6.     # 画填充色（红或黑）
   
7.     canvas.create_oval(x-R, y-R, x+R, y+R, fill=color)
   
8.     # 文字始终用白色
   
9.     canvas.create_text(x, y, text=text, font=('Arial', 20, 'bold'), fill='white')

复制代码

这样黑方棋子上的“車、馬、象……”就能清晰显示白色文字了。如果仍显示乱码（方块），请确保系统支持中文字体，可将 `font` 改为 `('SimHei', 20, 'bold')` 等中文字体名称。

另外，建议将红黑两色用明度较高的红色（如 `'#CC0000'`）和黑色，文字白色对比度最佳。快去试试修改后的代码吧！

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

过默

FishC 发表于 2026-7-15 08:27
你说得对，“黑没字”是因为黑方棋子文字的颜色与背景相同，导致看不见。在之前给出的 `draw_piece` 函 ...

棋子怎么移动，怎么人机对战

FishC

过默 发表于 2026-07-15 08:29
FishC 发表于 2026-7-15 08:27
你说得对，“黑没字” ...

以下是针对“棋子移动”和“人机对战”的简易实现思路，搭配 `pygame` 或 `tkinter` 均可。代码示例以 `pygame` 为例，你可以直接套用之前的绘图框架。

---

## 一、棋子移动：鼠标点击交互

### 1. 坐标映射（棋盘格 → 像素）
假设已定义 `padding`（起始偏移）和 `SIZE`（格子边长），点击像素 `(px, py)` 转棋盘行列：

1. 
   
2. def pos_to_board(px, py):
   
3.     col = round((px - padding) / SIZE)
   
4.     row = round((py - padding) / SIZE)
   
5.     if 0 <= col <= 8 and 0 <= row <= 9:
   
6.         return col, row
   
7.     return None
   

复制代码

### 2. 选中与移动流程
- **选中阶段**：记录玩家点击的格子坐标，若该格有己方棋子，则高亮并进入移动阶段。
- **移动阶段**：玩家再点击一个格子，程序调用 `is_legal_move(piece, from_pos, to_pos)` 判断是否合法。合法则执行移动并切换走棋方。

1. 
   
2. selected = None  # (col, row)
   
3. turn = 'red'     # 当前走棋方
   
4. 
   
5. while running:
   
6.     for event in pygame.event.get():
   
7.         if event.type == pygame.MOUSEBUTTONDOWN:
   
8.             pos = pos_to_board(*event.pos)
   
9.             if pos is None:
   
10.                 continue
    
11.             if selected is None:
    
12.                 # 检查该格是否有己方棋子
    
13.                 piece = board[pos[1]][pos[0]]
    
14.                 if piece and piece.color == turn:
    
15.                     selected = pos
    
16.             else:
    
17.                 # 尝试移动
    
18.                 from_pos = selected
    
19.                 to_pos = pos
    
20.                 piece = board[from_pos[1]][from_pos[0]]
    
21.                 if is_legal_move(piece, from_pos, to_pos):
    
22.                     # 执行移动
    
23.                     board[to_pos[1]][to_pos[0]] = piece
    
24.                     board[from_pos[1]][from_pos[0]] = None
    
25.                     # 切换走棋方
    
26.                     turn = 'black' if turn == 'red' else 'red'
    
27.                 selected = None  # 清除选中
    

复制代码

### 3. 合法走法判断（示例：车、马）
你需要为每种棋子实现规则函数。下面给出车的走法（无阻挡）和马的走法（无蹩脚）：

1. 
   
2. def is_legal_move(piece, from_pos, to_pos):
   
3.     fx, fy = from_pos
   
4.     tx, ty = to_pos
   
5.     if fx == tx and fy == ty:
   
6.         return False
   
7.     # 不能吃己方棋子
   
8.     target = board[ty][tx]
   
9.     if target and target.color == piece.color:
   
10.         return False
    
11. 
    
12.     if piece.piece_type == 'rook':  # 车
    
13.         if fx != tx and fy != ty:
    
14.             return False
    
15.         step_col = (tx - fx) // abs(tx - fx) if fx != tx else 0
    
16.         step_row = (ty - fy) // abs(ty - fy) if fy != ty else 0
    
17.         cx, cy = fx + step_col, fy + step_row
    
18.         while (cx, cy) != (tx, ty):
    
19.             if board[cy][cx] is not None:
    
20.                 return False
    
21.             cx += step_col
    
22.             cy += step_row
    
23.         return True
    
24. 
    
25.     if piece.piece_type == 'knight':  # 马
    
26.         dx, dy = tx - fx, ty - fy
    
27.         if (abs(dx), abs(dy)) not in [(1,2), (2,1)]:
    
28.             return False
    
29.         # 蹩脚检查
    
30.         if abs(dx) == 2:
    
31.             leg = (fx + dx//2, fy)
    
32.         else:
    
33.             leg = (fx, fy + dy//2)
    
34.         if board[leg[1]][leg[0]] is not None:
    
35.             return False
    
36.         return True
    
37.     # 其他棋子类似……
    
38.     return False
    

复制代码

---

## 二、人机对战：简单AI

### 1. 随机走法（最易实现）
让计算机从所有己方棋子中随机选一个，再从该棋子的所有合法走法中随机选一个。

1. 
   
2. import random
   
3. 
   
4. def computer_move(board, color):
   
5.     pieces = []
   
6.     for row in range(10):
   
7.         for col in range(9):
   
8.             if board[row][col] and board[row][col].color == color:
   
9.                 pieces.append((col, row))
   
10.     random.shuffle(pieces)
    
11.     for col, row in pieces:
    
12.         piece = board[row][col]
    
13.         # 生成所有合法目标格（这里用暴力遍历全盘）
    
14.         candidates = []
    
15.         for tcol in range(9):
    
16.             for trow in range(10):
    
17.                 if is_legal_move(piece, (col,row), (tcol,trow)):
    
18.                     candidates.append((tcol, trow))
    
19.         if candidates:
    
20.             target = random.choice(candidates)
    
21.             return (col, row), target
    
22.     return None
    

复制代码

在主循环中，一旦检测到 `turn` 为电脑方，就调用 `computer_move` 并执行移动。注意加上延时，让玩家看到电脑的选择。

### 2. 简单贪心走法（吃子优先）
在 `candidates` 中优先选择能吃掉对方棋子的格子。

1. 
   
2. def computer_move(board, color):
   
3.     pieces = ...  # 同上
   
4.     best_move = None
   
5.     for col, row in pieces:
   
6.         piece = board[row][col]
   
7.         for tcol in range(9):
   
8.             for trow in range(10):
   
9.                 if is_legal_move(piece, (col,row), (tcol,trow)):
   
10.                     target = board[trow][tcol]
    
11.                     # 如果目标有对方棋子，则优先选择
    
12.                     if target and target.color != color:
    
13.                         return (col,row), (tcol,trow)  # 立即返回吃子走法
    
14.                     # 否则记录一个普通走法
    
15.                     if best_move is None:
    
16.                         best_move = ((col,row), (tcol,trow))
    
17.     return best_move  # 没有吃子就走第一个合法走法
    

复制代码

### 3. 更进一步的思路（可选）
- **走法评估函数**：给每种棋子赋值（将=1000, 车=9, 马=4, 炮=4.5, …），然后选择己方棋子价值总和最大的走法。
- **极小极大搜索**：一至两层搜索即可，配合Alpha-Beta剪枝。但对初学者较复杂，建议先从贪心开始。

---

## 三、完整运行框架（pygame）

将以上代码整合进之前绘图的 `while` 循环中，注意在电脑走棋前加一小段延时 pygame.time.delay(500) 让玩家看到思考过程。每次移动后重绘棋盘棋子并调用 pygame.display.flip()。

**注意**：`board` 推荐使用二维列表，每个格子存储 ChessPiece 对象或 `None`。`ChessPiece` 类可简单定义为：

1. 
   
2. class ChessPiece:
   
3.     def __init__(self, color, piece_type):
   
4.         self.color = color
   
5.         self.piece_type = piece_type
   

复制代码

---

开始动手时，不必一次性实现所有棋子的规则。先只让车、马、兵可以移动，再逐步添加。祝你编程顺利，下出自己的象棋AI！

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

过默

FishC 发表于 2026-7-15 08:29
以下是针对“棋子移动”和“人机对战”的简易实现思路，搭配 `pygame` 或 `tkinter` 均可。代码示例以  ...

Traceback (most recent call last):
  File "C:/Program Files/Python38/hueizhi.py", line 87, in <module>
    while running:
NameError: name 'running' is not defined

FishC

过默 发表于 2026-07-15 08:32
FishC 发表于 2026-7-15 08:29
以下是针对“棋子移动 ...

你的代码报错是因为没有定义 `running` 变量。通常在 Pygame 主循环前要初始化这个变量，比如：

running = True

之后在循环体内可以设置退出条件。下面是一个完整的 Pygame 主循环骨架，包含鼠标点击获取棋盘坐标的逻辑，你可以参照补全：

import pygame
import sys

pygame.init()
screen = pygame.display.set_mode((700, 750))
pygame.display.set_caption('中国象棋')

# 定义常量（请与我之前代码一致）
SIZE = 60
R = 25
padding = 30

# 主循环开关
running = True
selected_piece = None   # 选中的棋子对象（行、列、棋子信息）

# ---------- 定义你的棋盘数据 board 和棋子类等 ----------
# 这里省略，用你之前写的 board 列表和 draw_board 等函数

clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.MOUSEBUTTONDOWN:
            # 获取鼠标点击位置
            px, py = event.pos
            col = round((px - padding) / SIZE)
            row = round((py - padding) / SIZE)
            # 检查是否在棋盘范围内
            if 0 <= col <= 8 and 0 <= row <= 9:
                # 处理选子或走子逻辑（调用你之前写的移动函数）
                # 例如：如果 selected_piece 为空，则选中当前位置的棋子；否则尝试走子
                pass

    # 绘制棋盘和棋子（你的绘图函数）
    # draw_board(screen)   # 画网格线
    # for each piece in board: draw_piece(screen, ...)

    pygame.display.flip()
    clock.tick(30)

pygame.quit()
sys.exit()

请务必在 `while running` 之前添加 `running = True`，错误即可解决。如果还有其他未定义变量（如 `board`、`draw_board` 等），需要根据你的代码一并补全。动手试一下吧！

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

过默

FishC 发表于 2026-7-15 08:32
你的代码报错是因为没有定义 `running` 变量。通常在 Pygame 主循环前要初始化这个变量，比如：

run ...

1. 
   
2. import tkinter as tk
   
3. 
   
4. root = tk.Tk()
   
5. canvas = tk.Canvas(root, width=700, height=750, bg='white')
   
6. canvas.pack()
   
7. 
   
8. SIZE = 60
   
9. R = 25
   
10. padding = 30
    
11. 
    
12. # 画横线：10行（0-9）
    
13. for row in range(10):
    
14.     y = padding + row * SIZE
    
15.     canvas.create_line(padding, y, padding + 8*SIZE, y, width=2)
    
16. 
    
17. # 画竖线：9列（0-8），但中间河界（第4、5行之间）不画竖线
    
18. for col in range(9):
    
19.     x = padding + col * SIZE
    
20.     # 上半棋盘（行0-4）
    
21.     canvas.create_line(x, padding, x, padding + 4*SIZE, width=2)
    
22.     # 下半棋盘（行5-9）
    
23.     canvas.create_line(x, padding + 5*SIZE, x, padding + 9*SIZE, width=2)
    
24. 
    
25. # 画交叉点装饰（可选）
    
26. for row in range(10):
    
27.     for col in range(9):
    
28.         cx = padding + col * SIZE
    
29.         cy = padding + row * SIZE
    
30.         # 在边框线端点添加小圆点（仅内部交叉点可省略）
    
31.         if (col==0 or col==8) and (row==0 or row==9):
    
32.             canvas.create_oval(cx-3, cy-3, cx+3, cy+3, fill='black')
    
33. 
    
34. # 在 (col, row) 处画一个红方“车”
    
35. def draw_piece(canvas, col, row, color, text):
    
36.     x = padding + col * SIZE
    
37.     y = padding + row * SIZE
    
38.     # 画黑色边框
    
39.     canvas.create_oval(x-R, y-R, x+R, y+R, outline='black', width=2)
    
40.     # 画填充色（红或黑）
    
41.     canvas.create_oval(x-R, y-R, x+R, y+R, fill=color)
    
42.     # 文字始终用白色
    
43.     canvas.create_text(x, y, text=text, font=('Arial', 20, 'bold'), fill='white')
    
44. 
    
45. # 红方（row=9 为底线）
    
46. draw_piece(canvas, 0, 9, 'red', '车')   # 左车
    
47. draw_piece(canvas, 1, 9, 'red', '马')   # 左马（正确位置）
    
48. draw_piece(canvas, 2, 9, 'red', '象')   # 左相
    
49. draw_piece(canvas, 3, 9, 'red', '士')   # 左士
    
50. draw_piece(canvas, 4, 9, 'red', '将')   # 帅
    
51. draw_piece(canvas, 5, 9, 'red', '士')   # 右士
    
52. draw_piece(canvas, 6, 9, 'red', '象')   # 右相
    
53. draw_piece(canvas, 7, 9, 'red', '马')   # 右马
    
54. draw_piece(canvas, 8, 9, 'red', '车')   # 右车
    
55. draw_piece(canvas, 1, 7, 'red', '炮')   # 左炮
    
56. draw_piece(canvas, 7, 7, 'red', '炮')   # 右炮
    
57. for col in range(0, 9, 2):             # 兵在 (0,6), (2,6), (4,6), (6,6), (8,6)
    
58.     draw_piece(canvas, col, 6, 'red', '兵')
    
59. 
    
60. # 黑方（row=0 为底线）
    
61. draw_piece(canvas, 0, 0, 'black', '車')
    
62. draw_piece(canvas, 1, 0, 'black', '馬')
    
63. draw_piece(canvas, 2, 0, 'black', '象')
    
64. draw_piece(canvas, 3, 0, 'black', '士')
    
65. draw_piece(canvas, 4, 0, 'black', '将')
    
66. draw_piece(canvas, 5, 0, 'black', '士')
    
67. draw_piece(canvas, 6, 0, 'black', '象')
    
68. draw_piece(canvas, 7, 0, 'black', '馬')
    
69. draw_piece(canvas, 8, 0, 'black', '車')
    
70. draw_piece(canvas, 1, 2, 'black', '炮')
    
71. draw_piece(canvas, 7, 2, 'black', '炮')
    
72. for col in range(0, 9, 2):
    
73.     draw_piece(canvas, col, 3, 'black', '卒')
    
74. 
    
75. 
    
76. def pos_to_board(px, py):
    
77.     col = round((px - padding) / SIZE)
    
78.     row = round((py - padding) / SIZE)
    
79.     if 0 <= col <= 8 and 0 <= row <= 9:
    
80.         return col, row
    
81.     return None
    
82. 
    
83. 
    
84. selected = None  # (col, row)
    
85. turn = 'red'     # 当前走棋方
    
86. 
    
87. while running:
    
88.     for event in pygame.event.get():
    
89.         if event.type == pygame.MOUSEBUTTONDOWN:
    
90.             pos = pos_to_board(*event.pos)
    
91.             if pos is None:
    
92.                 continue
    
93.             if selected is None:
    
94.                 # 检查该格是否有己方棋子
    
95.                 piece = board[pos[1]][pos[0]]
    
96.                 if piece and piece.color == turn:
    
97.                     selected = pos
    
98.             else:
    
99.                 # 尝试移动
    
100.                 from_pos = selected
     
101.                 to_pos = pos
     
102.                 piece = board[from_pos[1]][from_pos[0]]
     
103.                 if is_legal_move(piece, from_pos, to_pos):
     
104.                     # 执行移动
     
105.                     board[to_pos[1]][to_pos[0]] = piece
     
106.                     board[from_pos[1]][from_pos[0]] = None
     
107.                     # 切换走棋方
     
108.                     turn = 'black' if turn == 'red' else 'red'
     
109.                 selected = None  # 清除选中
     
110. running = True
     
111. root.mainloop()
     

复制代码

怎么移动？

FishC

过默 发表于 2026-07-15 08:34
FishC 发表于 2026-7-15 08:32
你的代码报错是因为没 ...

首先恭喜你已经用 `tkinter` 画出了棋盘和棋子。要实现“棋子移动”和“人机对战”，需要做三件事：

1. **用数据结构存储棋盘**：一个二维列表，记录每个交叉点上的棋子（颜色、类型）。  
2. **鼠标点击交互**：点击选中棋子，再次点击目标位置进行移动。  
3. **AI （人机对战）**：最简单的办法是让电脑随机选择一个合法走法。

下面提供可直接追加到你现有代码中的实现。请将你前面的全部代码复制，然后在最后（`root.mainloop()` 之前）添加下面的内容。

---

## 1. 棋盘数据结构（替换你目前的绘制，改为动态更新）

首先定义一个 `board` 列表，`board[row][col]` 存储 `None` 或一个字典 `{'color':'red'/'black', 'type':'车'/'马'/...}`。同时写一个函数 `redraw_all()` 根据 `board` 重绘所有棋子。

在你原来的画线代码之后、画棋子之前，加入：


# ---------- 棋盘数据结构 ----------
board = [ [None]*9 for _ in range(10) ]   # 10行9列

# 棋子初始模板（与你的 draw_piece 参数一致）
init_red = [(0,9,'车'),(1,9,'马'),(2,9,'象'),(3,9,'士'),(4,9,'将'),
            (5,9,'士'),(6,9,'象'),(7,9,'马'),(8,9,'车'),
            (1,7,'炮'),(7,7,'炮')]
for col in range(0,9,2):
    init_red.append((col,6,'兵'))

init_black = [(0,0,'車'),(1,0,'馬'),(2,0,'象'),(3,0,'士'),(4,0,'将'),
              (5,0,'士'),(6,0,'象'),(7,0,'馬'),(8,0,'車'),
              (1,2,'炮'),(7,2,'炮')]
for col in range(0,9,2):
    init_black.append((col,3,'卒'))

for col, row, piece_type in init_red:
    board[row][col] = {'color':'red', 'type':piece_type}
for col, row, piece_type in init_black:
    board[row][col] = {'color':'black', 'type':piece_type}

# 重绘所有棋子（清除旧图并重新画）
def redraw_all():
    canvas.delete('piece')   # 删除所有标签为'piece'的图形
    for row in range(10):
        for col in range(9):
            piece = board[row][col]
            if piece:
                color = 'red' if piece['color']=='red' else 'black'
                text = piece['type']
                draw_piece(canvas, col, row, color, text, tag='piece')

# 修改 draw_piece 函数，增加一个 tag 参数以便删除
def draw_piece(canvas, col, row, color, text, tag=None):
    x = padding + col * SIZE
    y = padding + row * SIZE
    canvas.create_oval(x-R, y-R, x+R, y+R, outline='black', width=2, tags=tag)
    canvas.create_oval(x-R, y-R, x+R, y+R, fill=color, tags=tag)
    canvas.create_text(x, y, text=text, font=('Arial', 20, 'bold'), fill='white', tags=tag)

# 调用一次重绘，替代下面原来的一大串 draw_piece 调用
redraw_all()


（注释：请删除你原来所有 `draw_piece` 的调用，只保留 `redraw_all()` 即可。）

---

## 2. 鼠标点击处理（选棋+移动）

在 `redraw_all` 之后、`root.mainloop()` 之前，添加：


selected = None   # 存储 (row, col) 选中的棋子

def on_click(event):
    global selected
    px, py = event.x, event.y
    col = round((px - padding) / SIZE)
    row = round((py - padding) / SIZE)
    if not (0 <= col <= 8 and 0 <= row <= 9):
        return

    # 如果没有选中任何棋子
    if selected is None:
        # 检查该位置是否有棋子，且是红方（或根据玩家颜色）
        piece = board[row][col]
        if piece and piece['color'] == 'red':   # 假设玩家执红
            selected = (row, col)
            # 可以给选中棋子加个高亮（简单起见不做了）
    else:
        # 已经选中了一个棋子，准备移动
        from_row, from_col = selected
        to_row, to_col = row, col
        # 简单的移动：仅检查是否在棋盘内、目标是否为空或敌方（不验证走法规则）
        if (from_row, from_col) == (to_row, to_col):
            selected = None   # 点击同一位置取消选中
            return
        # 检查目标是否是己方棋子
        target = board[to_row][to_col]
        if target and target['color'] == 'red':
            selected = (to_row, to_col)   # 重新选中
            return
        # 执行移动（不考虑规则，只演示）
        board[to_row][to_col] = board[from_row][from_col]
        board[from_row][from_col] = None
        selected = None
        # 重绘
        redraw_all()
        # 移动后轮到电脑（黑方），启动电脑走棋
        root.after(500, computer_move)   # 延迟0.5秒让玩家看到局面

canvas.bind('<Button-1>', on_click)


---

## 3. 简单的人机对战（电脑随机走合法步）

最简单的 AI 是列举所有黑方棋子的所有可能走法（不考虑规则），随机选择一个。这里只演示“移动到空位或吃红方”但不检查走法规则，真实规则代码较长，你可以逐步完善。


import random

def computer_move():
    # 收集所有黑方棋子
    black_pieces = []
    for r in range(10):
        for c in range(9):
            p = board[r][c]
            if p and p['color'] == 'black':
                black_pieces.append((r, c))
    # 寻找所有合法目标（不考虑走法规则，只允许移动到空位或红方）
    moves = []
    for r, c in black_pieces:
        # 简单：尝试周围八个方向（实际应依棋子类型）
        # 这里仅演示移动到相邻四个方向（上下左右）
        for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:
            nr, nc = r+dr, c+dc
            if 0 <= nr <= 9 and 0 <= nc <= 8:
                target = board[nr][nc]
                if target is None or target['color'] == 'red':
                    moves.append((r, c, nr, nc))
        # 还可以加入对角线（象走日等，但此处省略）
    if moves:
        fr, fc, tr, tc = random.choice(moves)
        board[tr][tc] = board[fr][fc]
        board[fr][fc] = None
        redraw_all()
    # 若无可行移动，则玩家胜，但这里不处理


最后启动 tkinter 主循环：

root.mainloop()


---

**完整运行流程**  
- 运行后显示标准开局。  
- 点击红方棋子（选中），再点击一个空位或黑方棋子，红方移动（无规则检查）。  
- 移动后黑方自动随机走一步（约0.5秒后）。  
- 周而复始。  

你可以在此基础上逐步添加上“马脚”“蹩马腿”“炮隔子打”“将帅对面”等真实规则，并将电脑 AI 改为更智能的搜索算法（如极小化极大搜索）。  

动手试试吧！如果还有问题，请贴出具体报错内容。

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

过默

Traceback (most recent call last):
  File "C:/Program Files/Python38/hueizhi.py", line 88, in <module>
    for event in pygame.event.get():
NameError: name 'pygame' is not defined

FishC

过默 发表于 2026-07-15 08:43
Traceback (most recent call last):
  File "C:/Pro ...

看起来你混淆了两个库：你当前的代码是基于 `tkinter` 的，但错误信息显示你试图运行 `pygame` 的代码（`pygame.event.get()`）。这两个库不能混用。

请检查你在 `hueizhi.py` 中到底用了哪一套代码。如果你确实是用 `tkinter` 画棋盘（就像上一段你贴出的完整代码那样），那么你只需要继续用 `tkinter` 的交互方式，不要导入 `pygame`。

下面我专门针对你这段 **tkinter 代码**，提供完整的棋子移动和人机对战实现。你只需将以下内容追加到你的 `hueizhi.py` 末尾（`root.mainloop()` 之前）即可。

**首先，在你原来的代码中找到最后一行 `root.mainloop()`，把它注释掉或删除，然后替换为下面的完整程序。**（当然你也可以在之前插入，但要确保数据结构定义好。）

---

### 完整 tkinter 人机对战代码（可直接替换你的文件末尾）

1. import tkinter as tk
   
2. import random
   
3. 
   
4. root = tk.Tk()
   
5. root.title('中国象棋 - 人机对战')
   
6. canvas = tk.Canvas(root, width=700, height=750, bg='white')
   
7. canvas.pack()
   
8. 
   
9. SIZE = 60
   
10. R = 25
    
11. padding = 30
    
12. 
    
13. # ----- 画棋盘（你的原代码）-----
    
14. for row in range(10):
    
15.     y = padding + row * SIZE
    
16.     canvas.create_line(padding, y, padding + 8*SIZE, y, width=2)
    
17. for col in range(9):
    
18.     x = padding + col * SIZE
    
19.     canvas.create_line(x, padding, x, padding + 4*SIZE, width=2)
    
20.     canvas.create_line(x, padding + 5*SIZE, x, padding + 9*SIZE, width=2)
    
21. for row in range(10):
    
22.     for col in range(9):
    
23.         cx = padding + col * SIZE
    
24.         cy = padding + row * SIZE
    
25.         if (col==0 or col==8) and (row==0 or row==9):
    
26.             canvas.create_oval(cx-3, cy-3, cx+3, cy+3, fill='black')
    
27. 
    
28. # ----- 数据结构 -----
    
29. board = [ [None]*9 for _ in range(10) ]
    
30. 
    
31. def set_piece(col, row, color, ptype):
    
32.     board[ row ][ col ] = {'color':color, 'type':ptype}
    
33. 
    
34. # 初始化红方
    
35. red_pieces = [
    
36.     (0,9,'车'), (1,9,'马'), (2,9,'象'), (3,9,'士'), (4,9,'将'),
    
37.     (5,9,'士'), (6,9,'象'), (7,9,'马'), (8,9,'车'),
    
38.     (1,7,'炮'), (7,7,'炮')
    
39. ]
    
40. for col in range(0,9,2):
    
41.     red_pieces.append((col,6,'兵'))
    
42. for col,row,pt in red_pieces:
    
43.     set_piece(col, row, 'red', pt)
    
44. 
    
45. # 初始化黑方
    
46. black_pieces = [
    
47.     (0,0,'車'), (1,0,'馬'), (2,0,'象'), (3,0,'士'), (4,0,'将'),
    
48.     (5,0,'士'), (6,0,'象'), (7,0,'馬'), (8,0,'車'),
    
49.     (1,2,'炮'), (7,2,'炮')
    
50. ]
    
51. for col in range(0,9,2):
    
52.     black_pieces.append((col,3,'卒'))
    
53. for col,row,pt in black_pieces:
    
54.     set_piece(col, row, 'black', pt)
    
55. 
    
56. # ----- 画棋子函数（带tag）-----
    
57. def draw_one_piece(col, row, color, text, tag='piece'):
    
58.     x = padding + col * SIZE
    
59.     y = padding + row * SIZE
    
60.     canvas.create_oval(x-R, y-R, x+R, y+R, outline='black', width=2, tags=tag)
    
61.     canvas.create_oval(x-R, y-R, x+R, y+R, fill=color, tags=tag)
    
62.     canvas.create_text(x, y, text=text, font=('Arial',20,'bold'), fill='white', tags=tag)
    
63. 
    
64. def redraw_all():
    
65.     canvas.delete('piece')
    
66.     for row in range(10):
    
67.         for col in range(9):
    
68.             piece = board[row][col]
    
69.             if piece:
    
70.                 color = piece['color']
    
71.                 text = piece['type']
    
72.                 draw_one_piece(col, row, 'red' if color=='red' else 'black', text, tag='piece')
    
73. 
    
74. redraw_all()
    
75. 
    
76. # ----- 鼠标交互 -------------------------------------------------
    
77. selected = None   # (col, row) 当前选中的棋子
    
78. 
    
79. def pos_to_board(px, py):
    
80.     col = round((px - padding) / SIZE)
    
81.     row = round((py - padding) / SIZE)
    
82.     if 0 <= col <= 8 and 0 <= row <= 9:
    
83.         return col, row
    
84.     return None
    
85. 
    
86. # ---------- 简单走法判断（仅供演示，只实现车、马、炮、兵的部分规则）--------
    
87. def is_legal_move(piece, from_col, from_row, to_col, to_row):
    
88.     # 这里仅示意，真正完整的走法规则很长。以下只判断“不走出棋盘、不吃己方”
    
89.     if not (0 <= to_col <= 8 and 0 <= to_row <= 9):
    
90.         return False
    
91.     target = board[to_row][to_col]
    
92.     if target and target['color'] == piece['color']:
    
93.         return False
    
94.     # 实际你应判断具体棋子类型走法，此处直接返回 True 以演示交互
    
95.     return True
    
96. 
    
97. def move_piece(from_col, from_row, to_col, to_row):
    
98.     piece = board[from_row][from_col]
    
99.     if not piece:
    
100.         return False
     
101.     if is_legal_move(piece, from_col, from_row, to_col, to_row):
     
102.         board[to_row][to_col] = piece
     
103.         board[from_row][from_col] = None
     
104.         redraw_all()
     
105.         return True
     
106.     return False
     
107. 
     
108. def ai_move():
     
109.     # 随机选择一个黑方棋子，随机走一步（不考虑合法性，仅演示）
     
110.     black_pieces = []
     
111.     for row in range(10):
     
112.         for col in range(9):
     
113.             p = board[row][col]
     
114.             if p and p['color'] == 'black':
     
115.                 black_pieces.append((col, row))
     
116.     if not black_pieces:
     
117.         return
     
118.     piece_pos = random.choice(black_pieces)
     
119.     col, row = piece_pos
     
120.     # 随机选择一个相邻位置（包括原地？不要原地）
     
121.     dirs = [ (-1,0),(1,0),(0,-1),(0,1) ]
     
122.     random.shuffle(dirs)
     
123.     for dc, dr in dirs:
     
124.         new_col = col + dc
     
125.         new_row = row + dr
     
126.         if 0 <= new_col <= 8 and 0 <= new_row <= 9:
     
127.             target = board[new_row][new_col]
     
128.             if not target or target['color'] != 'black':
     
129.                 # 执行移动
     
130.                 board[new_row][new_col] = board[row][col]
     
131.                 board[row][col] = None
     
132.                 redraw_all()
     
133.                 return True
     
134.     return False
     
135. 
     
136. def on_click(event):
     
137.     global selected
     
138.     pos = pos_to_board(event.x, event.y)
     
139.     if not pos:
     
140.         return
     
141.     col, row = pos
     
142.     piece = board[row][col]
     
143.     if selected is None:
     
144.         # 第一次点击：选中己方棋子（红方）
     
145.         if piece and piece['color'] == 'red':
     
146.             selected = (col, row)
     
147.             # 高亮选中（可选）
     
148.             canvas.create_rectangle(
     
149.                 padding + col*SIZE - 5, padding + row*SIZE - 5,
     
150.                 padding + col*SIZE + 5, padding + row*SIZE + 5,
     
151.                 outline='yellow', width=3, tags='highlight')
     
152.     else:
     
153.         # 第二次点击：尝试移动
     
154.         from_col, from_row = selected
     
155.         if move_piece(from_col, from_row, col, row):
     
156.             # 移动成功，轮到AI
     
157.             canvas.delete('highlight')
     
158.             selected = None
     
159.             ai_move()
     
160.         else:
     
161.             # 移动失败，取消选择
     
162.             canvas.delete('highlight')
     
163.             selected = None
     
164. 
     
165. canvas.bind('<Button-1>', on_click)
     
166. 
     
167. root.mainloop()

复制代码

---

### 说明

1. **此代码完全基于你原来的 tkinter 棋盘**，无需安装额外库。  
2. **点击红方棋子（第一次点击）** 会选中它（出现黄色小框），再点击目标位置即可移动。移动后 AI 自动走一步黑方。  
3. **AI 非常弱**：它只是随机选择一个黑方棋子，然后向随机方向移动一步（不会吃子）。你可以在此基础上实现真正的 AI（如极小极大搜索）。  
4. **走法合法性**：目前只判断了“不出棋盘、不吃己方”，没有实现具体棋子规则（车直线、马蹩脚等）。你需要根据棋子类型补充 `is_legal_move` 函数，但核心交互架构已经完整。

如果你希望用 `pygame` 版本，请在提问时明确说明。不过既然你已经写好了 tkinter 的绘制代码，建议继续用 tkinter 完成，因为两者切换会带来额外工作量。

现在请将你原有的 `pygame` 相关代码全部删除，只保留上面这段完整的 tkinter 代码并运行。祝你成功！

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

过默

棋子吃完了没赢

FishC

过默 发表于 2026-07-15 08:46
棋子吃完了没赢

你的代码中缺少“胜利判定”，所以即使吃掉所有棋子，游戏也不会停止。根据你描述的“棋子吃完了没赢”，有两种常见情况：  

- **简化规则**：一方所有棋子被吃光即获胜（不含将/帅）。  
- **标准规则**：将/帅被将死才获胜。  

我建议你先用“简化规则”测试，因为实现最简单。请在鼠标点击移动成功后，添加如下检查：  

1.   
   
2. # 在 on_click 函数移动成功后，添加胜利判断  
   
3. def check_winner():  
   
4.     red_exists = False  
   
5.     black_exists = False  
   
6.     for row in range(10):  
   
7.         for col in range(9):  
   
8.             piece = board[row][col]  
   
9.             if piece:  
   
10.                 if piece['color'] == 'red':  
    
11.                     red_exists = True  
    
12.                 else:  
    
13.                     black_exists = True  
    
14.     if not red_exists:  
    
15.         print("黑方获胜！")  
    
16.         canvas.create_text(350, 375, text="黑方胜利！", font=('Arial', 30, 'bold'), fill='black', tags='message')  
    
17.         return 'black'  
    
18.     elif not black_exists:  
    
19.         print("红方获胜！")  
    
20.         canvas.create_text(350, 375, text="红方胜利！", font=('Arial', 30, 'bold'), fill='red', tags='message')  
    
21.         return 'red'  
    
22.     return None  
    

复制代码

然后在 `move_piece` 成功移动后（即在 `board[target_row][target_col] = piece` 和 `board[start_row][start_col] = None` 之后），调用 `check_winner()`。如果返回非空，则禁用鼠标点击（例如设置一个全局标志 `game_over = True`，在 `on_click` 开头判断并直接返回）。  

完整的 `move_piece` 修改示例（加入胜利检查）：  

1.   
   
2. def move_piece(start_col, start_row, target_col, target_row):  
   
3.     global selected, game_over  
   
4.     if game_over:  
   
5.         return False  
   
6.     # ...（之前的移动合法性检查代码）  
   
7.     # 假设已经判断合法，执行移动  
   
8.     piece = board[start_row][start_col]  
   
9.     board[target_row][target_col] = piece  
   
10.     board[start_row][start_col] = None  
    
11.     redraw_all()  
    
12.     winner = check_winner()  
    
13.     if winner:  
    
14.         game_over = True  
    
15.         # 可选：2秒后关闭窗口  
    
16.         root.after(2000, root.quit)  
    
17.     return True  
    

复制代码

别忘了在最开始定义 `game_over = False`。这样当一方棋子被吃光后，棋盘中央会显示胜利文字，游戏结束。  

如果你希望实现“将死”判定（标准规则），则需要额外编写将军检测和逃生判断，这比较复杂。建议先从“吃光胜利”开始，确认移动逻辑无误后，再逐步完善。

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

过默

FishC 发表于 2026-7-15 08:46
你的代码中缺少“胜利判定”，所以即使吃掉所有棋子，游戏也不会停止。根据你描述的“棋子吃完了没赢” ...

Exception in Tkinter callback
Traceback (most recent call last):
  File "C:\Program Files\Python38\lib\tkinter\__init__.py", line 1892, in __call__
    return self.func(*args)
  File "C:/Program Files/Python38/hueizhi.py", line 196, in on_click
    if move_piece(from_col, from_row, col, row):
  File "C:/Program Files/Python38/hueizhi.py", line 161, in move_piece
    if game_over:
NameError: name 'game_over' is not defined

FishC

过默 发表于 2026-07-15 08:49
FishC 发表于 2026-7-15 08:46
你的代码中缺少“胜利 ...

你遇到的错误是因为在 `move_piece` 函数里使用了 `game_over` 变量，但你没有在程序开头定义它。请在代码最前（`import` 之后，所有函数定义之前）加上这一行：

game_over = False

另外，你的 `on_click` 函数中引用了 `selected`、`from_col`、`from_row` 等变量，需要确保它们也已被定义。如果你之前的代码中已经定义了 `selected = None`，那就没问题。但如果未定义，还需加上：

selected = None

完整的修正步骤如下：

1. 找到你代码的开头部分，在 `import tkinter` 和 `import random` 之后，添加：
   game_over = False
   selected = None

2. 确保 `move_piece` 函数内部正确使用了这些全局变量。例如，在 `move_piece` 函数的第一行添加 `global game_over`（如果要对 `game_over` 赋值）。但如果你只是在开头判断 `if game_over:` 而不修改它，可以不加 global。但为了安全，建议在函数内部访问全局变量时声明 `global game_over, selected`（如果需要修改 selected）。

3. 检查你的 `move_piece` 函数是否正确地调用了 `board`、`redraw_all` 等。如果依然报错，很可能是因为 `board` 变量作用域问题（函数内未声明 global）。请确认你的 `board` 是在全局定义的列表，并且在 `move_piece` 中要修改它，必须写 `global board`。

下面是一个安全的结构示例（仅展示修正部分，请根据你的实际代码位置插入）：

import tkinter as tk
import random

# ... 定义常量 SIZE, R, padding ...
# ... 画棋盘的代码 ...
board = [ *9 for _ in range(10) ]   # 全局棋盘数据
game_over = False                   # 添加这一行
selected = None                     # 添加这一行

def draw_one_piece(col, row, color, text, tag='piece'):
    # ... 你的绘图代码 ...

def redraw_all():
    # ... 重绘所有棋子 ...

def move_piece(from_col, from_row, target_col, target_row):
    global board, game_over   # 告诉 Python 要修改这两个全局变量
    if game_over:
        return False
    # ... 移动合法性判断 ...
    # 假设合法，执行移动
    board = board   # 复制引用
    board = None
    redraw_all()
    # 检查胜负
    winner = check_winner()  # 假设你有这个函数
    if winner:
        game_over = True
        canvas.create_text(350, 375, text=winner+'方胜利！', ...)
    return True

def on_click(event):
    global selected, game_over
    if game_over:
        return
    # ... 你的点击处理逻辑，确保用了 selected, from_col, from_row ...

# 然后绑定 canvas.bind('<Button-1>', on_click)
root.mainloop()

请对照你的代码，加入 `game_over` 和 `selected` 的全局定义，并在需要修改它们的函数内添加 `global` 声明。这样就不会再出现 `NameError` 了。

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