新鲜出炉的连连看连接算法Python版

这段时间老是“不务正业”的搞一些东西玩。之前的贪吃蛇，俄罗斯方块激发了我研究游戏算法的兴趣。经过1个星期的构思，连连看的连接算法终于出炉了。再过一段时间就基于这个算法使用JavaScript推出网页版的连连看。下面是说明及代码。

功能：为连连看游戏提供连接算法
说明：模块中包含一个Point类，该类是游戏的基本单元“点”，该类包含属性：x,y,value。
其中x,y代表了该点的坐标，value代表该点的特征：0代表没有被填充，1-8代表被填充为游戏图案，9代表被填充为墙壁
模块中还包含一个名为points的Point列表，其中保存着整个游戏界面中的每个点
使用模块的时候应首先调用createPoints方法，初始化游戏界面中每个点，然后可通过points访问到每个点，继而初始化界面
模块中核心的方法是link，通过提供源点和终点，可尝试连接两点，如果可以连接则返回保存路径的path列表，否则返回False

鸣谢：感谢我的同学asy668(http://hi.baidu.com/myasy)完善这个算法中createPoints，帮助我测试这个算法，并为这个算法写了一个用户交互界面。

1. #-*-coding:utf-8-*-
2. """连连看连接算法
4. 为连连看游戏提供连接算法
5. 模块中包含一个Point类，该类是游戏的基本单元“点”，该类包含属性：x,y,value。
6. 其中x,y代表了该点的坐标，value代表该点的特征：0代表没有被填充，1-8代表被填充为游戏图案，9代表被填充为墙壁
7. 模块中还包含一个名为points的Point列表，其中保存着整个游戏界面中的每个点
8. 使用模块的时候应首先调用createPoints方法，初始化游戏界面中每个点，然后可通过points访问到每个点，继而初始化界面
9. 模块中核心的方法是link，通过提供源点和终点，可尝试连接两点，如果可以连接则返回保存路径的path列表，否则返回False
10. """
11. importrandom
12. importtime
14. __author__="http://blog.youkuaiyun.com/anhulife"
15. __license__="python"
17. classPoint:
18. """Point类
20. Point类是游戏中基本单元：“点”
21. """
22. def__init__(self,x,y,value):
23. self.x=x
24. self.y=y
25. self.value=value
26. self.directs=None
27. self.changed=0
30. def__createDirect(self,pre,target):
31. """构造点的方向集
33. 每个点在连接的过程中都持有一个方向集，这个方向集中保
34. 存着该点的前进方向选择的优先级优先级：指向目标点的方向级别最
35. 高，在同等级别并且遵循x方向优先于y方向
36. """
37. self.directs=list()
38. stx=target.x-self.x
39. sty=target.y-self.y
40. ifstx>=0:
41. self.directs.append("right")
42. self.directs.append("left")
43. else:
44. self.directs.append("left")
45. self.directs.append("right")
46. ifsty>=0:
47. self.directs.insert(1,"up")
48. self.directs.append("down")
49. else:
50. self.directs.insert(1,"down")
51. self.directs.append("up")
52. ifpre==None:
53. return
54. spx=pre.x-self.x
55. spy=pre.y-self.y
56. ifspx==0:
57. ifspy==1:
58. self.directs.remove("up")
59. else:
60. self.directs.remove("down")
61. else:
62. ifspx==1:
63. self.directs.remove("right")
64. else:
65. self.directs.remove("left")
68. defforward(self,pre,target):
69. """点的前进动作
71. 点的前进即是依次从方向集中取出优先级高的方向，并判
72. 断该方向上的下一个点是否被填充如果没有被填充则说明该方
73. 向可通，并返回该方向。否则试探下一个方向，如果方向集中没
74. 有方向可用了，则返回None
75. """
76. ifself.directs==None:
77. self.__createDirect(pre,target)
78. iflen(self.directs)==0:
79. returnNone
80. direct=None
81. while(True):
82. iflen(self.directs)==0:
83. break
84. tmpDirect=self.directs.pop(0)
85. iftmpDirect=="up":
86. x=self.x
87. y=self.y+1
88. eliftmpDirect=="down":
89. x=self.x
90. y=self.y-1
91. eliftmpDirect=="left":
92. x=self.x-1
93. y=self.y
94. eliftmpDirect=="right":
95. x=self.x+1
96. y=self.y
97. p=points[x][y]
98. ifp.value>0andp!=target:
99. continue
100. else:
101. direct=tmpDirect
102. ifpre==None:
103. self.changed=1
104. else:
105. if(pre.x-self.x)==0and(p.x-self.x)==0:
106. self.changed=0
107. else:
108. if(pre.y-self.y)==0and(p.y-self.y)==0:
109. self.changed=0
110. else:
111. self.changed=1
112. break
113. returndirect
115. def__eq__(self,p):
116. ifp==None:
117. returnFalse
118. ifself.x==p.xandself.y==p.y:
119. returnTrue
120. else:
121. returnFalse
123. points=list()
124. valuestack=list()
126. defcreatePoints(w,h):
127. """构造游戏界面的点
129. 初始化界面中的所有的点，并且规则如下：
130. 最外一层是“墙壁”点，接下来的一层是没有被填充的点，被包裹的是填充的点
131. """
132. r=random.randint
133. random.seed(time.time())
134. Pointstack(w,h)
135. forxinrange(w):
136. temp=list()
137. foryinrange(h):
138. ifx==0orx==(w-1)ory==0ory==(h-1):
139. temp.append(Point(x,y,9))
140. else:
141. ifx==1orx==(w-2)ory==1ory==(h-2):
142. temp.append(Point(x,y,0))
143. else:
144. temp.append(Point(x,y,valuestack.pop()))
145. points.append(temp)
147. defPointstack(w,h):
148. size=w*h-(w*4+h*4-16)
149. size=size/2
150. random.seed(time.time())
151. foriinrange(size):
152. value=random.randint(1,8)
153. iflen(valuestack)==0:
154. valuestack.append(value)
155. valuestack.append(value)
156. else:
157. valuestack.insert(random.randint(1,len(valuestack)),value)
158. valuestack.insert(random.randint(1,len(valuestack)),value)
160. deflink(source,target):
161. """点的连接
163. 连接方法的思想：针对源点的每个方向尝试前进，如果可以前进，
164. 则将针对该方向上的下个点的每个方向尝试前进，
165. 当一个点的可选方向都不能前进的时候，则使用规定的信息标记该点，
166. 并返回到已有前进路径中的前一个点，尝试该点其他可选方向。当回源点
167. 的每个方向都走不通，连接失败返回False。否则当路径连接到目标点而且
168. 路径的方向变化小于4的时候，连接成功返回路径
169. """
170. ifsource==target:
171. returnFalse
172. ifsource.value==9orsource.value==0:
173. returnFalse
174. path=list()
175. fail=dict()
176. change=0
177. current=source
178. tempPoint=None
179. whileTrue:
180. ifcurrent==targetandchange<4:
181. forpinpath:
182. p.directs=None
183. returnpath
184. ifchange==4:
185. current.directs=None
186. fail[str(current.x)+"_"+str(current.y)]=change
187. current=path.pop()
188. change=change-current.changed
189. continue
190. ifcurrent==source:
191. direct=current.forward(None,target)
192. else:
193. direct=current.forward(path[len(path)-1],target)
194. ifdirect!=None:
195. ifdirect=="up":
196. x=current.x
197. y=current.y+1
198. elifdirect=="down":
199. x=current.x
200. y=current.y-1
201. elifdirect=="left":
202. x=current.x-1
203. y=current.y
204. elifdirect=="right":
205. x=current.x+1
206. y=current.y
207. iffail.has_key(str(x)+"_"+str(y)):
208. ifchange>=fail.get(str(x)+"_"+str(y)):
209. continue
210. else:
211. fail.pop(str(x)+"_"+str(y))
212. change=change+current.changed
213. path.append(current)
214. current=points[x][y]
215. else:
216. ifcurrent==source:
217. source.directs=None
218. returnFalse
219. else:
220. current.directs=None
221. fail[str(current.x)+"_"+str(current.y)]=change
222. current=path.pop()
223. change=change-current.changed
224. #createPoints(8,8)
225. #p=link(points[2][2],points[5][2])
226. #printp