围棋qingGo_0_0

qingGo_0_0需求:

1，设计一个9路棋盘，对弈双方轮流落子
2，已落子的点不能再落子
3，棋盘上没有空点时，统计双方棋子数量，多的一方赢

设计:

1,使用QipanModel类建立棋盘模型

 1 class QipanModel():
 2     def __init__(self,n=9):
 3         self.n = n #棋盘路数,默认9路棋盘
 4         #棋盘点位,从(1,1)开始,(9,9)结束
 5         #用字典表示,例"1_1":0,  0空,1黑,-1白,初始所有点为空
 6         self.dot = {f'{i}_{j}':0 for i in range(1,self.n+1) for j in range(1,self.n+1)}
 7         #棋子数量,黑子白子初始为0
 8         self.black_num = 0
 9         self.white_num = 0
10         
11     #更改点位状态,(x,y)是要更改的点位
12     def update_dot_status(self,x:int,y:int,color:str):
13         if color == 'black':
14             self.dot[f'{x}_{y}'] = 1
15             self.black_num+=1
16         elif color == "white":
17             self.dot[f'{x}_{y}'] = -1
18             self.white_num+=1
19             
20     #查看点位状态
21     def select_dot_status(self,x,y):
22         print(f'点({x},{y})为{self.dot[f"{x}_{y}"]}')
23         
24     #获取所有空的点位
25     def empty_dot(self):
26         return [k for k in self.dot if self.dot[k] == 0]

QipanModel

2,用继承Tk类的QipanView实现界面

 1 from tkinter import *
 2 
 3 class QipanView(Tk):
 4     def __init__(self,n=9):
 5         print("qingGo棋盘开始绘制!!!")
 6         Tk.__init__(self)  ###父类必须初始化
 7         self.n = n  #9路棋盘
 8         self.title("围棋qingGo_0_0")
 9 
10 
11         # 创建画布
12         self.canvas = Canvas(self, width=600, height=500, bg='red')
13         self.canvas.pack()
14         # 画棋盘
15         self.size = 40  #围棋每小格的长度,每小格长度(单位是像素)
16         # 画外框线
17         # 起点start_dot(sx,sy) 终点end_dot(ex,ey)
18         sx = self.canvas.winfo_x() + 20
19         sy = self.canvas.winfo_y() + 20
20         ex = sx + self.size * (self.n - 1)
21         ey = sy + self.size * (self.n - 1)
22         self.canvas.create_rectangle(sx, sy, ex, ey, fill='')
23         # 画竖线
24         # 外框线画好因此只需画n-2条线
25         # 竖线起点每条线x递增size,y不变
26         for i in range(1, self.n - 1):
27             self.canvas.create_line(sx + self.size * i, sy, sx + self.size * i, ey)
28         # 画横线,每条线y递增size,x不变
29         for i in range(1, self.n - 1):
30             self.canvas.create_line(sx, sy + self.size * i, ex, sy + self.size * i)
31             self.wm_attributes('-topmost', 1)  # 确保窗口在最上层
32 
33         print("qingGo棋盘绘制完成!!!")
34 
35 
36     # x,y是坐标,从1开始,(1,1)开始,(9,9)结束,棋手落子时,传入坐标点,棋手颜色
37     def luozi(self, x: int, y: int,color='black'):
38         # sx,sy是绘制棋盘外框线时左上角的坐标
39         sx = self.canvas.winfo_x() + 20
40         sy = self.canvas.winfo_y() + 20
41         # 棋子左上角和右下角的坐标分别如下,加2减2为了让棋子小一点
42         x1 = sx + (x - 1) * self.size - self.size / 2 + 2
43         y1 = sy + (y - 1) * self.size - self.size / 2 + 2
44         x2 = sx + (x - 1) * self.size + self.size / 2 - 2
45         y2 = sy + (y - 1) * self.size + self.size / 2 - 2
46         self.canvas.create_oval(x1, y1, x2, y2, fill=color)  # 画棋子
47         self.update() #更新画布,不然画不了

QipanView

3,创建棋手类,用于作为对弈双方的抽象

 1 import random
 2 from qingGo.qingGo0_0.caipan import Caipan
 3 from qingGo.qingGo0_0.qipan_model import QipanModel
 4 from qingGo.qingGo0_0.qipan_view import QipanView
 5 
 6 class Qishou():
 7     def __init__(self,color='black'):
 8         self.color = color
 9         print(self.color+"方就位!")
10 
11     #下棋
12     def xiaqi(self, qipan_model:QipanModel, qing_view:QipanView, caipan:Caipan):
13         # 获取空点
14         empty_dot = qipan_model.empty_dot()
15         l = len(empty_dot)
16         if l == 0:
17             print("棋盘满了!请裁判判定胜负!!!")
18             caipan.who_win(qipan_model)
19             return "棋盘满了!"
20 
21         #用随机函数,选择一个点
22         dot = empty_dot[random.randint(0,l-1)]
23         x = int(dot[0])
24         y = int(dot[2])
25         #更改棋盘中点状态
26         qipan_model.update_dot_status(x, y, color=self.color)
27         #落子,界面展示
28         qing_view.luozi(x,y,color=self.color)
29         #落子后裁判报位置
30         caipan.luozi_place(x, y, self.color)

Qishou

4,裁判类,棋手落子后播报位置,判断胜负

 1 from qingGo.qingGo0_0.qipan_model import QipanModel
 2 class Caipan():
 3     def __init__(self):
 4         print("裁判上场!")
 5 
 6     #棋手下棋后裁判报位置
 7     def luozi_place(self,x,y,color):
 8         print(f"{color} 落子在({x},{y})")
 9     # 判断胜负
10     def who_win(self,qipan_model:QipanModel):
11         print(f"黑子:{qipan_model.black_num},白子:{qipan_model.white_num}")
12         if qipan_model.black_num>qipan_model.white_num:
13             print("黑方获得胜利!")
14         else:
15             print("白方获得胜利!")

Caipan

5,创建run.py实现功能

 1 import random
 2 import time
 3 
 4 from qingGo.qingGo0_0.caipan import Caipan
 5 from qingGo.qingGo0_0.qipan_model import QipanModel
 6 from qingGo.qingGo0_0.qipan_view import QipanView
 7 from qingGo.qingGo0_0.qishou import Qishou
 8 
 9 if __name__ == '__main__':
10     #绘制棋盘
11     qv = QipanView()
12 
13     #初始化模型
14     qm = QipanModel()
15     #白方上场
16     w = Qishou("white")
17     #黑方上场
18     b = Qishou("black")
19     #裁判上场
20     cp = Caipan()
21 
22     #下棋次数为9*9,加1是为了看棋盘满了后的效果
23     i = qm.n**2+1
24     while i>0:
25         if i%2 == 1:
26             w.xiaqi(qm, qv,cp)
27         else:
28             b.xiaqi(qm, qv,cp)
29         i-=1
30         time.sleep(0.05)
31 
32     # 画画功能
33     qv.mainloop()

run.py

 

效果图:

 

简单的目录结构,其中的Pictures文件夹是其他项目的,与此无关

 总结:

    忽略美观程度,可以看到,效果已经有了,毕竟是初代程序,等后续升级.

    至此,我们可以得出结论,在这个版本中,想要赢的胜利,只需要先下棋就行了,毕竟需求没有提到要吃子

 

 

 

 

 

 

 

 

原文链接：https://www.cnblogs.com/qingGo/p/17322464.html