围棋qingGo_0_0

树仔

qingGo_0_0需求:

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

复制代码

设计:

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

复制代码

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

复制代码

QipanModel

1. <br>2,用继承Tk类的QipanView实现界面

复制代码

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

复制代码

QipanView

1. <br>3,创建棋手类,用于作为对弈双方的抽象

复制代码

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

复制代码

Qishou

1. <br>4,裁判类,棋手落子后播报位置,判断胜负

复制代码

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

复制代码

Caipan

1. <br>5,创建run.py实现功能

复制代码

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

复制代码

run.py 
效果图:

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

 总结:
    忽略美观程度,可以看到,效果已经有了,毕竟是初代程序,等后续升级.
    至此,我们可以得出结论,在这个版本中,想要赢的胜利,只需要先下棋就行了,毕竟需求没有提到要吃子
 
 
 
 
 
 
 
 
[code][/code]
来源:https://www.cnblogs.com/qingGo/p/17322464.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！