Python 一步一步教你用pyglet制作汉诺塔游戏（终篇）

目录

汉诺塔游戏

完整游戏

演示回放

完整代码

汉诺塔游戏

汉诺塔（Tower of Hanoi），是一个源于印度古老传说的益智玩具。这个传说讲述了大梵天创造世界的时候，他做了三根金刚石柱子，并在其中一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门将这些圆盘从下面开始按大小顺序重新摆放在另一根柱子上，并规定在小圆盘上不能放大圆盘，同时在三根柱子之间一次只能移动一个圆盘。当盘子的数量增加时，移动步骤的数量会呈指数级增长，圆盘数为n时，总步骤数steps为2^n - 1。

n = 64， steps = 2^64 - 1 = 18446744073709551616 ≈ 1.845 x 10^19

汉诺塔问题是一个递归问题，也可以使用非递归法来解决，例如使用栈来模拟递归过程。这个问题不仅是一个数学和逻辑问题，也是一个很好的教学工具，可以用来教授递归、算法和逻辑思考等概念。同时，汉诺塔游戏也具有一定的娱乐性，人们可以通过解决不同规模的汉诺塔问题来挑战自己的智力和耐心。

本篇接着上期讲下去，前2篇的链接地址：

Python 一步一步教你用pyglet制作汉诺塔游戏（续）-CSDN博客

Python 一步一步教你用pyglet制作汉诺塔游戏-CSDN博客

完整游戏

前2期代码的基础上，添加了完整的提示功能，一个汉诺塔游戏作品终于完工了，效果如下：

信息提示功能都放在了鼠标事件中：

@window.event
def on_mouse_press(x, y, dx, dy):
    global xy, hanns, gamecompleted
    if not hanns.success():
        pole = hanns.on_mouse_over(x, y)
        if pole is not None:
            xy.append(pole)
            if len(xy)==1:
                hanns.setdiskcolor(xy[0], (255,0,0))
                if not hanns.array[pole]:
                    hanns.setdiskcolor(xy[0])
                    xy.pop()
                    return
        if len(xy)==2:
            if xy[0]!=xy[1]:
                info = hanns.move(*xy)
                hanns.setdiskcolor(xy[0])
                if info is False:
                    info1.text = '起始圆盘大于目标位置的圆盘'
                elif info is None:
                    info1.text = '所选起始位置的塔架不能为空'
                else:
                    info1.text = f'{hanns.order-hanns.array[xy[1]][-1]}号圆盘从{xy[0]+1}号塔架移动到{xy[1]+1}号塔架'
            hanns.setdiskcolor(xy[0])
            xy.clear()
            info2.text = f'当前层数：{hanns.order}\t最佳步数：{2**hanns.order-1}\t当前步数：{hanns.steps}'
        if hanns.success():
            if hanns.order<24:
                info1.text = f'恭喜您完成 {hanns.order} 层汉诺塔！任意点击层数加一！'
            else:
                info1.text = f'太棒了！您已完成 {hanns.order} 层汉诺塔，游戏结束！'
                gamecompleted = True
                return
    elif not gamecompleted:
        hanns = Hann(window.width/2, 120, hanns.order+1)
        info1.text = f' {hanns.order} 层汉诺塔，游戏开始！'
        info2.text = f'当前层数：{hanns.order}\t最佳步数：{2**hanns.order-1}\t当前步数：{hanns.steps}'

Hann 类中增加一个改色的方法，用于标注被点击的要移动的源塔架：

  def setdiskcolor(self, n, color=Color[0]):
        self.disk[n].cir1.color = color
        self.disk[n].cir2.color = color
        self.disk[n].rect.color = color

完整代码： 

1. import pyglet
3. window = pyglet.window.Window(800, 500, caption='汉诺塔')
4. pyglet.gl.glClearColor(1, 1, 1, 1)
5. batch = pyglet.graphics.Batch()
7. Color = (182,128,18),(25,65,160),(56,170,210),(16,188,78),(20,240,20),(240,240,20),(255,128,20),(240,20,20),(245,60,138)
9. class Disk:
10. def __init__(self, x, y, color=(0,0,0), width=200, height=20):
11. self.cir1 = pyglet.shapes.Circle(x+width/2-height/2, y, radius=height/2, color=color, batch=batch)
12. self.cir2 = pyglet.shapes.Circle(x-width/2+height/2, y, radius=height/2, color=color, batch=batch)
13. self.rect = pyglet.shapes.Rectangle(x-width/2+height/2, y-height/2, width-height, height, color=color, batch=batch)
14. def move(self, dx, dy):
15. self.cir1.x += dx; self.cir1.y += dy
16. self.cir2.x += dx; self.cir2.y += dy
17. self.rect.x += dx; self.rect.y += dy
19. class Hann:
20. def __init__(self, x, y, order=2, space=250, thickness=20, width=200, height=300):
21. assert(order>1)
22. self.pole = [pyglet.shapes.Line(x-i*space, y, x-i*space, y+height, width=thickness, color=Color[0], batch=batch) for i in range(-1,2)]
23. self.disk = [Disk(x+i*space, y, color=Color[0], width=width+thickness, height=thickness) for i in range(-1,2)]
24. self.x, self.y = x, y
25. self.order = order
26. self.space = space
27. self.thickness = thickness
28. self.width = width
29. self.poleheight = height
30. self.beadheight = (height-thickness*2)/order
31. self.step = (width-thickness)/(order+1)
32. self.steps = 0
33. self.macro = []
34. coordinates = [(self.x-space, self.y+(i+1)*self.beadheight-(self.beadheight-thickness)/2) for i in range(order)]
35. self.beads = [Disk(*xy, Color[i%8+1], width=self.width-i*self.step, height=self.beadheight) for i,xy in enumerate(coordinates)]
36. self.array = [[*range(order)], [], []]
37. def move(self, pole1, pole2):
38. if self.array[pole1]:
39. bead = self.array[pole1].pop()
40. if self.array[pole2] and bead1]:
41. self.array[pole1].append(bead)
42. return False
43. else:
44. return None
45. self.beads[bead].move((pole2-pole1)*self.space, (len(self.array[pole2])-len(self.array[pole1]))*self.beadheight)
46. self.array[pole2].append(bead)
47. self.steps += 1
48. self.macro.append((pole1, pole2))
49. return True
50. def setdiskcolor(self, n, color=Color[0]):
51. self.disk[n].cir1.color = color
52. self.disk[n].cir2.color = color
53. self.disk[n].rect.color = color
54. def on_mouse_over(self, x, y):
55. for i in range(-1,2):
56. if hanns.x-hanns.width/2 < x-i*hanns.space < hanns.x+hanns.width/2 and hanns.y-hanns.thickness/2 < y < hanns.y+hanns.poleheight:
57. return i+1
58. def success(self):
59. return len(self.array[2]) == self.order
61. @window.event
62. def on_draw():
63. window.clear()
64. batch.draw()
66. @window.event
67. def on_mouse_press(x, y, dx, dy):
68. global xy, hanns, gamecompleted
69. if not hanns.success():
70. pole = hanns.on_mouse_over(x, y)
71. if pole is not None:
72. xy.append(pole)
73. if len(xy)==1:
74. hanns.setdiskcolor(xy[0], (255,0,0))
75. if not hanns.array[pole]:
76. hanns.setdiskcolor(xy[0])
77. xy.pop()
78. return
79. if len(xy)==2:
80. if xy[0]!=xy[1]:
81. info = hanns.move(*xy)
82. hanns.setdiskcolor(xy[0])
83. if info is False:
84. info1.text = '起始圆盘大于目标位置的圆盘'
85. elif info is None:
86. info1.text = '所选起始位置的塔架不能为空'
87. else:
88. info1.text = f'{hanns.order-hanns.array[xy[1]][-1]}号圆盘从{xy[0]+1}号塔架移动到{xy[1]+1}号塔架'
89. hanns.setdiskcolor(xy[0])
90. xy.clear()
91. info2.text = f'当前层数：{hanns.order}\t最佳步数：{2**hanns.order-1}\t当前步数：{hanns.steps}'
92. if hanns.success():
93. if hanns.order<24:
94. info1.text = f'恭喜您完成 {hanns.order} 层汉诺塔！任意点击层数加一！'
95. else:
96. info1.text = f'太棒了！您已完成 {hanns.order} 层汉诺塔，游戏结束！'
97. gamecompleted = True
98. return
99. elif not gamecompleted:
100. hanns = Hann(window.width/2, 120, hanns.order+1)
101. info1.text = f' {hanns.order} 层汉诺塔，游戏开始！'
102. info2.text = f'当前层数：{hanns.order}\t最佳步数：{2**hanns.order-1}\t当前步数：{hanns.steps}'
104. xy = []
105. order = 2
106. hanns = Hann(window.width/2, 120, order)
107. info1 = pyglet.text.Label('操作方法：鼠标先后点击起始和目标位置就能移动圆盘', font_size=21, color=(0,0,0,255), x=window.width/2, y=50, anchor_x='center', batch=batch)
108. info2 = pyglet.text.Label(f'当前层数：{order}\t最佳步数：{2**order-1}\t当前步数：0', font_size=18, color=(0,0,0,255), x=80, y=450, batch=batch)
109. gamecompleted = False
111. pyglet.app.run()

演示回放

优化代码，布局稍作调整，并加入帮助、演示和回放等功能。演示和回放的区别：演示功能是提供如何移动的教学帮助；回放功能则是展示用户自己的移动过程。

运行效果如下：

完整代码

1. import pyglet
2. from pyglet.window import key
4. Width, Height = 800, 500
5. window = pyglet.window.Window(Width, Height, caption='Tower of Hanoi')
6. screen = pyglet.canvas.Display().get_default_screen()
7. window.set_location((screen.width-Width)//2, (screen.height-Height)//2)
8. pyglet.gl.glClearColor(0.78, 0.88, 0.98, 1)
9. batch = pyglet.graphics.Batch()
10. group = pyglet.graphics.Group()
12. Color = (182,128,18),(25,65,160),(56,170,210),(16,188,78),(20,240,20),(240,240,20),(255,128,20),(240,20,20),(245,60,138)
14. class Disk:
15. def __init__(self, x, y, color=(0,0,0), width=200, height=20):
16. self.cir1 = pyglet.shapes.Circle(x+width/2-height/2, y, radius=height/2, color=color, batch=batch)
17. self.cir2 = pyglet.shapes.Circle(x-width/2+height/2, y, radius=height/2, color=color, batch=batch)
18. self.rect = pyglet.shapes.Rectangle(x-width/2+height/2, y-height/2, width-height, height, color=color, batch=batch)
19. def move(self, dx, dy):
20. self.cir1.x += dx; self.cir1.y += dy
21. self.cir2.x += dx; self.cir2.y += dy
22. self.rect.x += dx; self.rect.y += dy
24. class Hann:
25. def __init__(self, order=2, x=window.width/2, y=110, space=250, thickness=20, width=200, height=300):
26. assert(order>1)
27. self.pole = [pyglet.shapes.Line(x+i*space, y, x+i*space, y+height, width=thickness, color=Color[0], batch=batch) for i in range(-1,2)]
28. self.disk = [Disk(x+i*space, y, color=Color[0], width=width+thickness, height=thickness) for i in range(-1,2)]
29. self.x, self.y = x, y
30. self.order = order
31. self.ordermax = 24
32. self.space = space
33. self.thickness = thickness
34. self.width = width
35. self.poleheight = height
36. self.beadheight = (height-thickness*2)/order
37. self.step = (width-thickness)/(order+1)
38. self.steps = 0
39. self.macro = []
40. self.posxy = []
41. self.click = False
42. self.ctrlz = False
43. self.playback = False
44. coordinates = [(self.x-space, self.y+(i+1)*self.beadheight-(self.beadheight-thickness)/2) for i in range(order)]
45. self.beads = [Disk(*pos, Color[i%8+1], width=self.width-i*self.step, height=self.beadheight) for i,pos in enumerate(coordinates)]
46. self.array = [[*range(order)], [], []]
47. self.arraymacro = []
48. def move(self, pole1, pole2):
49. if self.array[pole1]:
50. bead = self.array[pole1].pop()
51. if self.array[pole2] and bead1]:
52. self.array[pole1].append(bead)
53. return False
54. else:
55. return None
56. self.beads[bead].move((pole2-pole1)*self.space, (len(self.array[pole2])-len(self.array[pole1]))*self.beadheight)
57. self.array[pole2].append(bead)
58. self.steps += 1
59. self.click = True
60. self.macro.append((pole1, pole2))
61. self.arraymacro.append([array[:] for array in self.array])
62. return True
63. def set_color(self, n, color=Color[0]):
64. self.click = color==Color[0]
65. self.disk[n].cir1.color = color
66. self.disk[n].cir2.color = color
67. self.disk[n].rect.color = color
68. self.pole[n].color = color
69. def on_mouse_over(self, x, y):
70. for i in range(-1,2):
71. if hanns.x-hanns.width/2 < x-i*hanns.space < hanns.x+hanns.width/2 and hanns.y-hanns.thickness/2 < y < hanns.y+hanns.poleheight:
72. return i+1
73. def success(self):
74. return len(self.array[2]) == self.order
76. def hanoi(n, start=0, mid=1, end=2, moves=None):
77. if moves is None:
78. moves = []
79. if n == 1:
80. moves.append((start, end))
81. else:
82. hanoi(n-1, start, end, mid, moves)
83. moves.append((start, end))
84. hanoi(n-1, mid, start, end, moves)
85. return moves
87. def hanoimacro(n, start=0, mid=1, end=2, moves=None):
88. global macro, array
89. if moves is None:
90. moves = []
91. array = [[*range(n)],[],[]]
92. macro = [[[*range(n)],[],[]]]
93. if n == 1:
94. moves.append((start, end))
95. array[end].append(array[start].pop())
96. macro.append([disk[:] for disk in array])
97. else:
98. hanoimacro(n-1, start, end, mid, moves)
99. moves.append((start, end))
100. array[end].append(array[start].pop())
101. macro.append([disk[:] for disk in array])
102. hanoimacro(n-1, mid, start, end, moves)
103. return macro
105. @window.event
106. def on_draw():
107. window.clear()
108. batch.draw()
110. @window.event
111. def on_mouse_press(x, y, dx, dy):
112. global hanns, gamestarting, gamecompleted
113. if not gamestarting:
114. gamestarting = True
115. show_message(False)
116. return
117. elif hanns.playback:
118. return
119. if not hanns.success():
120. pole = hanns.on_mouse_over(x, y)
121. if pole is not None:
122. hanns.posxy.append(pole)
123. if len(hanns.posxy)==1:
124. hanns.set_color(hanns.posxy[0], (200,150,0))
125. if not hanns.array[pole]:
126. hanns.set_color(hanns.posxy[0])
127. hanns.posxy.pop()
128. return
129. if len(hanns.posxy)==2:
130. if hanns.posxy[0]!=hanns.posxy[1]:
131. info = hanns.move(*hanns.posxy)
132. hanns.set_color(hanns.posxy[0])
133. if info:
134. info1.text = information(3)
135. else:
136. info1.text = information(6)
137. hanns.set_color(hanns.posxy[0])
138. hanns.posxy.clear()
139. info2.text = information()
140. if hanns.success():
141. if hanns.order<24:
142. info1.text = information(4)
143. else:
144. info1.text = information(5)
145. gamecompleted = True
146. return
147. elif not gamecompleted:
148. hanns = Hann(hanns.order+1)
149. info1.text = information(0)
150. info2.text = information(2)
152. @window.event
153. def on_key_press(symbol, modifiers):
154. global hanns, macro, gamestarting
155. def show_how(event):
156. if macro:
157. hanns.move(*macro.pop(0))
158. info2.text = information()
159. else:
160. info1.text = info1.text.replace('中......', '完成！')
161. hanns.playback = False
162. pyglet.clock.unschedule(show_how)
163. if not gamestarting:
164. gamestarting = True
165. show_message(False)
166. return
167. if hanns.playback:
168. if symbol in (key.B, key.BREAK) and modifiers & key.MOD_CTRL:
169. macro.clear()
170. info1.text = info1.text.replace('中......', '终止，')+'游戏继续！'
171. return
172. if hanns.macro and hanns.click and not hanns.success() and symbol==key.Z and modifiers & key.MOD_CTRL:
173. hanns.ctrlz = not hanns.ctrlz
174. hanns.posxy = hanns.macro.pop()[::-1]
175. info = hanns.move(*hanns.posxy)
176. hanns.steps -= 2*hanns.ctrlz
177. hanns.posxy = []
178. elif symbol == key.H and modifiers & key.MOD_CTRL:
179. gamestarting = False
180. show_message(True)
181. elif symbol == key.R and modifiers & key.MOD_CTRL:
182. if hanns.steps:
183. hanns = Hann(hanns.order)
184. info1.text = information(0)
185. elif symbol == key.N and modifiers & (key.MOD_CTRL | key.MOD_SHIFT) and modifiers & key.MOD_SHIFT:
186. if hanns.order>2:
187. hanns = Hann(hanns.order-1)
188. info1.text = information(0)
189. else:
190. info1.text = information(7)
191. elif symbol == key.N and modifiers & key.MOD_CTRL and not modifiers & key.MOD_SHIFT:
192. if hanns.order<24:
193. hanns = Hann(hanns.order+1)
194. info1.text = information(0)
195. else:
196. info1.text = information(8)
197. elif symbol in (key.S, key.P) and modifiers & key.MOD_CTRL:
198. macro = hanns.macro
199. hanns = Hann(hanns.order)
200. hanns.playback = True
201. if symbol==key.S:
202. task = '演示中......'
203. macro = hanoi(hanns.order)
204. elif symbol==key.P:
205. task = '回放中......'
206. info1.text = f'{hanns.order} 层汉诺塔{task}'
207. pyglet.clock.schedule_interval(show_how, 9/(hanns.order**2+9))
208. info2.text = information()
210. def show_message(visible=True):
211. box1.visible = box2.visible = html.visible = visible
212. info1.text = information(0)
214. def messagebox():
215. global box1, box2, html
216. rect = 150, 90, 500, 330
217. box1 = pyglet.shapes.Rectangle(*rect, color=(255,255,255,200), batch=batch, group=group)
218. box2 = pyglet.shapes.Box(*rect, color=(255,0,0,255), thickness=3, batch=batch, group=group)
219. html = pyglet.text.HTMLLabel(text=hypertext, multiline=True, width=Width//2, x=Width//2, y=240, batch=batch, group=group)
220. html.anchor_x = html.anchor_y = 'center'
222. def information(info=2):
223. if info==0:
224. return f'{hanns.order} 层汉诺塔，游戏开始！'
225. elif info==1:
226. return '点击任意键开始......'
227. elif info==2:
228. return f'当前层数：{hanns.order:<12}最佳步数：{2**hanns.order-1:<12}当前步数：{hanns.steps:>9}'
229. elif info==3:
230. return f'{hanns.order-hanns.array[hanns.posxy[1]][-1]}号圆盘从{hanns.posxy[0]+1}号塔架移动到{hanns.posxy[1]+1}号塔架'
231. elif info==4:
232. return f'恭喜您完成 {hanns.order} 层汉诺塔！任意点击层数加一！'
233. elif info==5:
234. return f'太棒了！您已完成 {hanns.order} 层汉诺塔，游戏全部通关！'
235. elif info==6:
236. return '起始圆盘大于目标位置的圆盘'
237. elif info==7:
238. return f'程序设置的最小层数是 2'
239. elif info==8:
240. return f'程序设置的最大层数是 {hanns.ordermax}'
242. hanns = Hann(order=2)
243. hypertext = '''汉诺塔 Tower of Hanoi
     
     
244. 汉诺塔是一个源于印度的古老传说的益智玩具。这个传说
     讲述了大梵天创造世界的时候做了三根金刚石柱子，并在
     
245. 一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大
     梵天命令婆罗门将这些圆盘按照大小顺序重新摆放到另一
     
246. 根柱子上(左边搬到右边，中间临时存放)，规定大圆盘不
     能放在小圆盘上，且一次只能移动一个圆盘。
     
247. 
     操作方法：先后点击塔架，就能移动塔架上的圆盘
     
     
248. Ctrl+Z　取消操作　　　　Ctrl+R　重新开始
     Ctrl+S　自动演示　　　　Ctrl+P　操作回放
     
249. Ctrl+B　终止操作　　　　Ctrl+H　帮助消息
     Ctrl+N　增减层数（同时按Shift键为减）
     '''
250. info1 = pyglet.text.Label(information(1), font_size=21, color=(0,0,0,255), x=400, y=40, anchor_x='center', batch=batch)
251. info2 = pyglet.text.Label(information(2), font_size=16, font_name='宋体', color=(0,0,0,255), x=70, y=450, batch=batch)
252. gamestarting, gamecompleted = False, False
253. messagebox()
254. pyglet.app.run()

其中记录移动的宏暂未用到，进一步开发会用到：

def hanoimacro(n, start=0, mid=1, end=2, moves=None):
    global macro, array
    if moves is None:
        moves = []
        array = [[*range(n)],[],[]]
        macro = [[[*range(n)],[],[]]]
    if n == 1:
        moves.append((start, end))
        array[end].append(array[start].pop())
        macro.append([disk[:] for disk in array])
    else:
        hanoimacro(n-1, start, end, mid, moves)
        moves.append((start, end))
        array[end].append(array[start].pop())
        macro.append([disk[:] for disk in array])
        hanoimacro(n-1, mid, start, end, moves)
    return macro

完