资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/Python怎么实现迷宫？生成代码是什么

Python怎么实现迷宫？生成代码是什么

89542767 / 680人阅读


　　小编写这篇文章的主要目的，是给大家去做一个相关的介绍，介绍一下关于其怎么才能够实现python迷宫，那么，我们要使用的话，就要去生成代码了，那么，具体的代码有吗？下面就给大家做一个解答。


　　作为一项古老的智力游戏，千百年来迷宫都散发着迷人的魅力。但是，手工设计迷宫费时又耗（脑）力，于是，我们有必要制作一个程序：迷宫生成器……


　　好吧，我编不下去了。但是，从上面的文字中，我们可以看出，我们此次的主题是：用Python实现一个迷宫生成器。


　　首先展示一下效果图：

01.png

　　我们先分析一下所需的库：


　　既然是生成器，每次生成的迷宫一模一样显然是说不过去的。因此，我们不可避免地要使用随机数（Random库）。迷宫一定是要绘制的，所以需要有一个GUI库或绘图库，这里我使用Pygame（Tkinter或Turtle其实都可以做到，但毕竟Pygame比较顺手）。与Pygame搭配，Sys似乎也是需要的（用于退出程序，但其实不使用似乎也无伤大雅）。然后是Tkinter.filedialog，主要用于询问保存路径（生成的迷宫总得保存吧）。当然，用Time加一个计时器似乎是锦上添花。


　　于是，就有：


</>复制代码 
  1. 　　#coding:utf-8
  2. 　　import contextlib
  3. 　　with contextlib.redirect_stdout(None):
  4. 　　import pygame
  5. 　　import random
  6. 　　import sys
  7. 　　import time
  8. 　　from tkinter.filedialog import*


　　这里要说明的是，由于导入Pygame时会输出版本信息等很多内容（这很影响美感），我们需要使用Contextlib阻止它输出。


　　接下来，我们需要询问一些参数：


</>复制代码 
  1. 　　a=int(input("列数："))
  2. 　　b=int(input("行数："))
  3. 　　l=int(input("大小："))
  4. 　　saveit=input("是否保存：")


　　然后，就要运行生成迷宫的程序了。同时，我们有必要计录一下时间（相当于开启计时器）：


</>复制代码 
  1. 　　print("生成中...")
  2. 　　e=time.time()


　　然后就是正式生成迷宫。在介绍这部分代码之前，我们需要了解一下算法：


　　第一步，生成一个由迷宫单元（白格）和墙（黑格）组成的网格。一行中迷宫单元的数量为迷宫的列数，一列找迷宫单元的数量为迷宫的行数。令左上角的迷宫单元为起点，右下角的迷宫单元为终点，打破起点左边与终点右边的墙，如图所示：

02.png

　　第二步，访问各迷宫单元。将起点标记为当前迷宫单元，当存在未被访问的迷宫单元（凡是曾经成为过当前迷宫单元的迷宫单元，都视为已访问）时，重复执行：


　　将周围的未被访问的迷宫单元加入表格；


　　如果表格中有迷宫单元：


　　将当前迷宫单元入栈（可以理解为将其加入一个叫做栈的表格）；


　　从表格中随机选择一个迷宫单元；


　　打破当前迷宫单元与选择的迷宫单元之间的墙；


　　将选择的迷宫单元标记为当前迷宫单元；


　　如果表格中没有迷宫单元：


　　栈顶迷宫单元出栈（可以理解为将栈中的最后一个元素获取并删除）；


　　将出栈的迷宫单元设为当前迷宫单元；


　　在循环结束以后，就会出现像文章开头效果图一样的结果。


　　接下来，我们就要将文字化的算法转化为Python的代码。


　　首先，程序是不认识图片的，它认识的是数据。所以我们需要设置一个二维列表，以此来用一串数据表示当前的图像。当然，我们可以顺便将第一步的设置一起完成：


</>复制代码 
  1. 　　alist=[]
  2. 　　aa=0
  3. 　　need=[]
  4. 　　for j in range(2*a+1):
  5. 　　if aa==0:
  6. 　　aa=1
  7. 　　alistone=[]
  8. 　　for i in range(2*b+1):
  9. 　　alistone.append(1)
  10. 　　alist.append(alistone)
  11. 　　else:
  12. 　　aa=0
  13. 　　alistone=[]
  14. 　　bb=0
  15. 　　for i in range(2*b+1):
  16. 　　if bb==0:
  17. 　　bb=1
  18. 　　alistone.append(1)
  19. 　　else:
  20. 　　bb=0
  21. 　　need.append((j,i))
  22. 　　alistone.append(0)
  23. 　　alist.append(alistone)
  24. 　　alist[0][1]=0
  25. 　　alist[-1][-2]=0


　　可以看到，除此以外我们还建立了一个列表need，里面存储了所有的迷宫单元。它的作用就是判断迷宫单元是否被访问，每次访问都会将迷宫单元从表格中删除，当表格中没有迷宫单元时，就说明所有迷宫单元都被访问了。


</>复制代码 
  1. 　　x=1
  2. 　　y=1
  3. 　　need.remove((1,1))
  4. 　　listing=[]
  5. 　　while len(need)&gt;0:
  6. 　　aroundit=[]
  7. 　　try:
  8. 　　if x-2&lt;0:
  9. 　　print(1+"1")
  10. 　　alist[x-2][y]=0
  11. 　　if(x-2,y)in need:
  12. 　　aroundit.append("alist[x-1][y],x=(0,x-2)")
  13. 　　except:
  14. 　　while False:
  15. 　　print()
  16. 　　try:
  17. 　　alist[x+2][y]=0
  18. 　　if(x+2,y)in need:
  19. 　　aroundit.append("alist[x+1][y],x=(0,x+2)")
  20. 　　except:
  21. 　　while False:
  22. 　　print()
  23. 　　try:
  24. 　　alist[x][y+2]=0
  25. 　　if(x,y+2)in need:
  26. 　　aroundit.append("alist[x][y+1],y=(0,y+2)")
  27. 　　except:
  28. 　　while False:
  29. 　　print()
  30. 　　try:
  31. 　　if y-2&lt;0:
  32. 　　print(1+"1")
  33. 　　alist[x][y-2]=0
  34. 　　if(x,y-2)in need:
  35. 　　aroundit.append("alist[x][y-1],y=(0,y-2)")
  36. 　　except:
  37. 　　while False:
  38. 　　print()
  39. 　　if len(aroundit)&gt;0:
  40. 　　listing.append((x,y))
  41. 　　exec(random.choice(aroundit))
  42. 　　need.remove((x,y))
  43. 　　else:
  44. 　　x,y=listing[-1]
  45. 　　listing.pop()


　　而这些内容，就是第二步。其算法我已经解释过，唯一一个微小的不同是，在此处我们并没有在列表中加入相邻迷宫单元的坐标，而是将其对应的破墙和标记为当前迷宫单元的代码以字符串的形式存储在表格中，并在随机选择出某个迷宫单元所对应的字符串后，使用exec将其转换为代码并运行（这可以节省一些代码）。

</>复制代码 
  1. 　　print("完成！用时{}秒".format(time.time()-e))


　　打印完生成迷宫的用时后，我们需要将表格中的数据转化为图像了。当然，在此之前，我们要先确定图片保存的位置。


</>复制代码 
  1. 　　if saveit=="1":
  2. 　　ccc=askdirectory()
  3. 　　h=""
  4. 　　bbbbb=1
  5. 　　while True:
  6. 　　try:
  7. 　　open("{}/{}×{}迷宫{}.png".format(ccc,a,b,h),"r")
  8. 　　h="({})".format(bbbbb)
  9. 　　except:
  10. 　　break
  11. 　　bbbbb+=1

　　由于使用时有可能选择不保存图片，因此要先判断你的选择是保存还是不保存。这里字符“1”表示保存（输入其他，自然就是不保存了）。然后我们需要让你选择保存路径（askdirectory()询问的是文件路径，不需要选择文件名）。然后，我们要确定文件名称：“a×b迷宫.png”。这里需要判断指定路径是否存在此名称的文件，如果存在，则我们需要在后面加上序号。总而言之，通过这串代码，我们已经将迷宫的路径+文件名确定了。


</>复制代码 
  1. 　　pygame.init()
  2. 　　icon=pygame.image.load("迷宫.png")
  3. 　　pygame.display.set_icon(icon)
  4. 　　screen=pygame.display.Info()
  5. 　　screen=pygame.display.set_mode((l*(2*a+1),l*(2*b+1)))
  6. 　　pygame.display.set_caption('迷宫')
  7. 　　screen.fill("white")
  8. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  9. 　　c.fill(color='white')
  10. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  11. 　　d.fill(color='black')
  12. 　　for i in range(2*a+1):
  13. 　　for j in range(2*b+1):
  14. 　　if alist<i>[j]==0:
  15. 　　screen.blit(c,(i*l,j*l))
  16. 　　elif alist<i>[j]==1:
  17. 　　screen.blit(d,(i*l,j*l))
  18. 　　pygame.display.flip()
  19. 　　if saveit=="1":
  20. 　　pygame.image.save(screen,"{}/{}×{}迷宫{}.png".format(ccc,a,b,h))
  21. 　　while True:
  22. 　　for event in pygame.event.get():
  23. 　　if event.type==pygame.QUIT:
  24. 　　pygame.quit()
  25. 　　sys.exit()


　　代码中使用的图片“迷宫.png”（名称不太对，下载以后要重新命名一下）：

04.png

　　这里主要是Pygame的基本设置，并将表格内容图像化。每一个数字代表一个方块，而数字的值则决定了方块的颜色，数字在表格中的位置决定了方块的位置。就这样，我们呢将表格完全转化成了图像。当然，我们还需要用pygame.image.save()函数将图像保存为图片文件。


　　这样，这个生成器似乎完成了。


　　它运行良好，但当迷宫比较复杂时，暴露出一个问题（下图是100×100的迷宫）：

05.png

　　由于正确路径过于曲折，在复杂度较高时，这个迷宫的难度会变得极高！


　　难度高，在某方面上讲，的确是好事。但当你向你的朋友们展示这个迷宫时，如果你自己也无法得出正确的路径，这不是很扫兴吗？


　　因此，一个寻路算法变得非常有必要。


　　寻路算法的大体思路：


　　在生成的迷宫中，白格为路，黑格为墙。将起点设置为当前位置，重复执行直到终点成为当前位置：


　　将当前位置标记为正确路径；


　　将周围未标记的路加入一个表格；


　　如果表格不空：


　　将当前位置入栈；


　　从表格中随机选择一条路，并将其设为当前位置；


　　如果表格是空的：


　　栈顶的路出栈；


　　将其设为当前位置；


　　通过这个算法，我们可以试出正确的路径（如图）：

06.png

　　代码的实现：


</>复制代码 
  1. 　　x2=0
  2. 　　y2=1
  3. 　　listing2=[]
  4. 　　while not(alist[-1][-2]==2):
  5. 　　alist[x2][y2]=3
  6. 　　around2=[]
  7. 　　try:
  8. 　　if x2-1&lt;0:
  9. 　　print(1+"1")
  10. 　　if alist[x2-1][y2]==0:
  11. 　　around2.append("x2=x2-1")
  12. 　　except:
  13. 　　while False:
  14. 　　print()
  15. 　　try:
  16. 　　if alist[x2+1][y2]==0:
  17. 　　around2.append("x2=x2+1")
  18. 　　except:
  19. 　　while False:
  20. 　　print()
  21. 　　try:
  22. 　　if alist[x2][y2+1]==0:
  23. 　　around2.append("y2=y2+1")
  24. 　　except:
  25. 　　while False:
  26. 　　print()
  27. 　　try:
  28. 　　if y2-1&lt;0:
  29. 　　print(1+"1")
  30. 　　if alist[x2][y2-1]==0:
  31. 　　around2.append("y2=y2-1")
  32. 　　except:
  33. 　　while False:
  34. 　　print()
  35. 　　if len(around2)&gt;0:
  36. 　　listing2.append((x2,y2))
  37. 　　exec(random.choice(around2))
  38. 　　else:
  39. 　　alist[x2][y2]=2
  40. 　　x2,y2=listing2[-1]
  41. 　　listing2.pop()
  42. 　　alist[-1][-2]=3
  43. 　　for i in range(len(alist)):
  44. 　　for j in range(len(alist[0])):
  45. 　　if alist<i>[j]==2:
  46. 　　alist<i>[j]=0

　　同时，图像绘制的过程也要作出一些改动，以显示正确路径：


</>复制代码 
  1. 　　if saveit=="1":
  2. 　　ccc=askdirectory()
  3. 　　h=""
  4. 　　bbbbb=1
  5. 　　while True:
  6. 　　try:
  7. 　　open("{}/{}×{}迷宫{}.png".format(ccc,a,b,h),"r")
  8. 　　open("{}/{}×{}迷宫（正确线路）{}.png".format(ccc,a,b,h),"r")
  9. 　　h="({})".format(bbbbb)
  10. 　　except:
  11. 　　break
  12. 　　bbbbb+=1
  13. 　　pygame.init()
  14. 　　icon=pygame.image.load("迷宫.png")
  15. 　　pygame.display.set_icon(icon)
  16. 　　screen=pygame.display.Info()
  17. 　　screen=pygame.display.set_mode((l*(2*a+1),l*(2*b+1)))
  18. 　　pygame.display.set_caption('迷宫')
  19. 　　screen.fill("white")
  20. 　　if saveit=="1":
  21. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  22. 　　c.fill(color='white')
  23. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  24. 　　d.fill(color='black')
  25. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  26. 　　f.fill(color='white')
  27. 　　for i in range(2*a+1):
  28. 　　for j in range(2*b+1):
  29. 　　if alist<i>[j]==0:
  30. 　　screen.blit(c,(i*l,j*l))
  31. 　　elif alist<i>[j]==1:
  32. 　　screen.blit(d,(i*l,j*l))
  33. 　　else:
  34. 　　screen.blit(f,(i*l,j*l))
  35. 　　pygame.image.save(screen,"{}/{}×{}迷宫{}.png".format(ccc,a,b,h))
  36. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  37. 　　c.fill(color='white')
  38. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  39. 　　d.fill(color='black')
  40. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  41. 　　f.fill(color='red')
  42. 　　for i in range(2*a+1):
  43. 　　for j in range(2*b+1):
  44. 　　if alist<i>[j]==0:
  45. 　　screen.blit(c,(i*l,j*l))
  46. 　　elif alist<i>[j]==1:
  47. 　　screen.blit(d,(i*l,j*l))
  48. 　　else:
  49. 　　screen.blit(f,(i*l,j*l))
  50. 　　pygame.image.save(screen,"{}/{}×{}迷宫（正确线路）{}.png".format(ccc,a,b,h))
  51. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  52. 　　c.fill(color='white')
  53. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  54. 　　d.fill(color='black')
  55. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  56. 　　f.fill(color='white')
  57. 　　for i in range(2*a+1):
  58. 　　for j in range(2*b+1):
  59. 　　if alist<i>[j]==0:
  60. 　　screen.blit(c,(i*l,j*l))
  61. 　　elif alist<i>[j]==1:
  62. 　　screen.blit(d,(i*l,j*l))
  63. 　　else:
  64. 　　screen.blit(f,(i*l,j*l))
  65. 　　pygame.display.flip()
  66. 　　aaaaaaa=0
  67. 　　while True:
  68. 　　for event in pygame.event.get():
  69. 　　if event.type==pygame.QUIT:
  70. 　　pygame.quit()
  71. 　　sys.exit()
  72. 　　if event.type==pygame.MOUSEBUTTONDOWN:
  73. 　　if aaaaaaa==1:
  74. 　　aaaaaaa=0
  75. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  76. 　　c.fill(color='white')
  77. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  78. 　　d.fill(color='black')
  79. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  80. 　　f.fill(color='white')
  81. 　　for i in range(2*a+1):
  82. 　　for j in range(2*b+1):
  83. 　　if alist<i>[j]==0:
  84. 　　screen.blit(c,(i*l,j*l))
  85. 　　elif alist<i>[j]==1:
  86. 　　screen.blit(d,(i*l,j*l))
  87. 　　else:
  88. 　　screen.blit(f,(i*l,j*l))
  89. 　　pygame.display.flip()
  90. 　　else:
  91. 　　aaaaaaa=1
  92. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  93. 　　c.fill(color='white')
  94. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  95. 　　d.fill(color='black')
  96. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  97. 　　f.fill(color='red')
  98. 　　for i in range(2*a+1):
  99. 　　for j in range(2*b+1):
  100. 　　if alist<i>[j]==0:
  101. 　　screen.blit(c,(i*l,j*l))
  102. 　　elif alist<i>[j]==1:
  103. 　　screen.blit(d,(i*l,j*l))
  104. 　　else:
  105. 　　screen.blit(f,(i*l,j*l))
  106. 　　pygame.display.flip()

　　通过这些改动，显示正确路径的效果就实现了。生成完成以后，窗口上显示的是没有正确路径的迷宫，而点击窗口后，正确的路径就会显示（再次点击隐藏）。


　　刚刚那张100×100的迷宫，其正确路径是：

07.png

　　可以看出，本文中所用的算法生成的迷宫，其正确路径还是非常曲折的（难度很高）。你何不将其发给你的朋友，让其破解一下呢？


　　完整的代码：


</>复制代码 
  1. 　　#coding:utf-8
  2. 　　import contextlib
  3. 　　with contextlib.redirect_stdout(None):
  4. 　　import pygame
  5. 　　import random
  6. 　　import sys
  7. 　　import time
  8. 　　from tkinter.filedialog import*
  9. 　　a=int(input("列数："))
  10. 　　b=int(input("行数："))
  11. 　　l=int(input("大小："))
  12. 　　saveit=input("是否保存：")
  13. 　　print("生成中...")
  14. 　　e=time.time()
  15. 　　alist=[]
  16. 　　aa=0
  17. 　　need=[]
  18. 　　for j in range(2*a+1):
  19. 　　if aa==0:
  20. 　　aa=1
  21. 　　alistone=[]
  22. 　　for i in range(2*b+1):
  23. 　　alistone.append(1)
  24. 　　alist.append(alistone)
  25. 　　else:
  26. 　　aa=0
  27. 　　alistone=[]
  28. 　　bb=0
  29. 　　for i in range(2*b+1):
  30. 　　if bb==0:
  31. 　　bb=1
  32. 　　alistone.append(1)
  33. 　　else:
  34. 　　bb=0
  35. 　　need.append((j,i))
  36. 　　alistone.append(0)
  37. 　　alist.append(alistone)
  38. 　　alist[0][1]=0
  39. 　　alist[-1][-2]=0
  40. 　　x=1
  41. 　　y=1
  42. 　　need.remove((1,1))
  43. 　　listing=[]
  44. 　　while len(need)&gt;0:
  45. 　　aroundit=[]
  46. 　　try:
  47. 　　if x-2&lt;0:
  48. 　　print(1+"1")
  49. 　　alist[x-2][y]=0
  50. 　　if(x-2,y)in need:
  51. 　　aroundit.append("alist[x-1][y],x=(0,x-2)")
  52. 　　except:
  53. 　　while False:
  54. 　　print()
  55. 　　try:
  56. 　　alist[x+2][y]=0
  57. 　　if(x+2,y)in need:
  58. 　　aroundit.append("alist[x+1][y],x=(0,x+2)")
  59. 　　except:
  60. 　　while False:
  61. 　　print()
  62. 　　try:
  63. 　　alist[x][y+2]=0
  64. 　　if(x,y+2)in need:
  65. 　　aroundit.append("alist[x][y+1],y=(0,y+2)")
  66. 　　except:
  67. 　　while False:
  68. 　　print()
  69. 　　try:
  70. 　　if y-2&lt;0:
  71. 　　print(1+"1")
  72. 　　alist[x][y-2]=0
  73. 　　if(x,y-2)in need:
  74. 　　aroundit.append("alist[x][y-1],y=(0,y-2)")
  75. 　　except:
  76. 　　while False:
  77. 　　print()
  78. 　　if len(aroundit)&gt;0:
  79. 　　listing.append((x,y))
  80. 　　exec(random.choice(aroundit))
  81. 　　need.remove((x,y))
  82. 　　else:
  83. 　　x,y=listing[-1]
  84. 　　listing.pop()
  85. 　　x2=0
  86. 　　y2=1
  87. 　　listing2=[]
  88. 　　while not(alist[-1][-2]==2):
  89. 　　alist[x2][y2]=3
  90. 　　around2=[]
  91. 　　try:
  92. 　　if x2-1&lt;0:
  93. 　　print(1+"1")
  94. 　　if alist[x2-1][y2]==0:
  95. 　　around2.append("x2=x2-1")
  96. 　　except:
  97. 　　while False:
  98. 　　print()
  99. 　　try:
  100. 　　if alist[x2+1][y2]==0:
  101. 　　around2.append("x2=x2+1")
  102. 　　except:
  103. 　　while False:
  104. 　　print()
  105. 　　try:
  106. 　　if alist[x2][y2+1]==0:
  107. 　　around2.append("y2=y2+1")
  108. 　　except:
  109. 　　while False:
  110. 　　print()
  111. 　　try:
  112. 　　if y2-1&lt;0:
  113. 　　print(1+"1")
  114. 　　if alist[x2][y2-1]==0:
  115. 　　around2.append("y2=y2-1")
  116. 　　except:
  117. 　　while False:
  118. 　　print()
  119. 　　if len(around2)&gt;0:
  120. 　　listing2.append((x2,y2))
  121. 　　exec(random.choice(around2))
  122. 　　else:
  123. 　　alist[x2][y2]=2
  124. 　　x2,y2=listing2[-1]
  125. 　　listing2.pop()
  126. 　　alist[-1][-2]=3
  127. 　　for i in range(len(alist)):
  128. 　　for j in range(len(alist[0])):
  129. 　　if alist<i>[j]==2:
  130. 　　alist<i>[j]=0
  131. 　　print("完成！用时{}秒".format(time.time()-e))
  132. 　　if saveit=="1":
  133. 　　ccc=askdirectory()
  134. 　　h=""
  135. 　　bbbbb=1
  136. 　　while True:
  137. 　　try:
  138. 　　open("{}/{}×{}迷宫{}.png".format(ccc,a,b,h),"r")
  139. 　　open("{}/{}×{}迷宫（正确线路）{}.png".format(ccc,a,b,h),"r")
  140. 　　h="({})".format(bbbbb)
  141. 　　except:
  142. 　　break
  143. 　　bbbbb+=1
  144. 　　pygame.init()
  145. 　　icon=pygame.image.load("迷宫.png")
  146. 　　pygame.display.set_icon(icon)
  147. 　　screen=pygame.display.Info()
  148. 　　screen=pygame.display.set_mode((l*(2*a+1),l*(2*b+1)))
  149. 　　pygame.display.set_caption('迷宫')
  150. 　　screen.fill("white")
  151. 　　if saveit=="1":
  152. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  153. 　　c.fill(color='white')
  154. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  155. 　　d.fill(color='black')
  156. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  157. 　　f.fill(color='white')
  158. 　　for i in range(2*a+1):
  159. 　　for j in range(2*b+1):
  160. 　　if alist<i>[j]==0:
  161. 　　screen.blit(c,(i*l,j*l))
  162. 　　elif alist<i>[j]==1:
  163. 　　screen.blit(d,(i*l,j*l))
  164. 　　else:
  165. 　　screen.blit(f,(i*l,j*l))
  166. 　　pygame.image.save(screen,"{}/{}×{}迷宫{}.png".format(ccc,a,b,h))
  167. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  168. 　　c.fill(color='white')
  169. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  170. 　　d.fill(color='black')
  171. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  172. 　　f.fill(color='red')
  173. 　　for i in range(2*a+1):
  174. 　　for j in range(2*b+1):
  175. 　　if alist<i>[j]==0:
  176. 　　screen.blit(c,(i*l,j*l))
  177. 　　elif alist<i>[j]==1:
  178. 　　screen.blit(d,(i*l,j*l))
  179. 　　else:
  180. 　　screen.blit(f,(i*l,j*l))
  181. 　　pygame.image.save(screen,"{}/{}×{}迷宫（正确线路）{}.png".format(ccc,a,b,h))
  182. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  183. 　　c.fill(color='white')
  184. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  185. 　　d.fill(color='black')
  186. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  187. 　　f.fill(color='white')
  188. 　　for i in range(2*a+1):
  189. 　　for j in range(2*b+1):
  190. 　　if alist<i>[j]==0:
  191. 　　screen.blit(c,(i*l,j*l))
  192. 　　elif alist<i>[j]==1:
  193. 　　screen.blit(d,(i*l,j*l))
  194. 　　else:
  195. 　　screen.blit(f,(i*l,j*l))
  196. 　　pygame.display.flip()
  197. 　　aaaaaaa=0
  198. 　　while True:
  199. 　　for event in pygame.event.get():
  200. 　　if event.type==pygame.QUIT:
  201. 　　pygame.quit()
  202. 　　sys.exit()
  203. 　　if event.type==pygame.MOUSEBUTTONDOWN:
  204. 　　if aaaaaaa==1:
  205. 　　aaaaaaa=0
  206. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  207. 　　c.fill(color='white')
  208. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  209. 　　d.fill(color='black')
  210. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  211. 　　f.fill(color='white')
  212. 　　for i in range(2*a+1):
  213. 　　for j in range(2*b+1):
  214. 　　if alist<i>[j]==0:
  215. 　　screen.blit(c,(i*l,j*l))
  216. 　　elif alist<i>[j]==1:
  217. 　　screen.blit(d,(i*l,j*l))
  218. 　　else:
  219. 　　screen.blit(f,(i*l,j*l))
  220. 　　pygame.display.flip()
  221. 　　else:
  222. 　　aaaaaaa=1
  223. 　　c=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  224. 　　c.fill(color='white')
  225. 　　d=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  226. 　　d.fill(color='black')
  227. 　　f=pygame.Surface((l,l),flags=pygame.HWSURFACE)
  228. 　　f.fill(color='red')
  229. 　　for i in range(2*a+1):
  230. 　　for j in range(2*b+1):
  231. 　　if alist<i>[j]==0:
  232. 　　screen.blit(c,(i*l,j*l))
  233. 　　elif alist<i>[j]==1:
  234. 　　screen.blit(d,(i*l,j*l))
  235. 　　else:
  236. 　　screen.blit(f,(i*l,j*l))
  237. 　　pygame.display.flip()


　　代码的结束，对于程序也许仅仅只是开始；学习的暂时告一段落，从不影响生活的继续。生命无止境，贵在一颗永远向上的心。


　　至此，小编就给大家介绍完毕了，希望可以给大家带来更多的帮助。

GPU云服务器 云服务器 js迷宫生成 python代码生成 java实现类是什么 代码是什么

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/128009.html

相关文章

  • 用并查集(find-union)实现迷宫算法以及最短路径求解

    摘要：本人邮箱欢迎转载转载请注明网址代码已经全部托管有需要的同学自行下载引言迷宫对于大家都不会陌生那么迷宫是怎么生成已经迷宫要如何找到正确的路径呢用代码又怎么实现带着这些问题我们继续往下看并查集朋友圈有一种算法就做并查集什么意思呢比如现在有零 本人邮箱: 欢迎转载,转载请注明网址 http://blog.csdn.net/tianshi_kcogithub: https://github.c...

    xiangchaobin 评论0 收藏0

  • 一篇文章把本该属于你的源码天赋还给你

    摘要：一些方法不应该这样不应该漫无目的地随手拿起一分源码，试图去通读。应该这样精心挑选要阅读的源码项目。这最好是与你的编程语言你的工作内容你的兴趣所在相关的，这样才能更切实地感受到阅读源码给你带来的益处，更有动力继续。 showImg(https://segmentfault.com/img/bVbcvmm?w=785&h=525); 怎么阅读源码 没有经验的技术差底子薄的初级程序员，如何阅...

    chanjarster 评论0 收藏0

  • 快速实现一个简单的canvas迷宫游戏

    摘要：所以我先写了一个样例扔在服务器上，大家可以先体验一下效果用成就感作为驱动力哈哈哈点我体验地址正文实现这个小游戏也不难，让我们想想，一个迷宫游戏有哪些基本要素。迷宫地图的生成，可以借助谷歌的一个迷宫在线生成器来获得。 前言 （最近设计模式看的有点头大，一直面对纯js实在是有些枯燥-_-。所以写一点有趣的东西调剂一下）现在canvas已经不算新鲜了，不过由于日常业务中并不常用，所以实践并不...

    wangdai 评论0 收藏0

发表评论

登陆后可评论

0条评论

89542767

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<