Python实现的QQ空间3366小游戏彩色砖块的辅助工具

Posted 2021-03-04 xwcbx

      由于女朋友每天玩这个小游戏，每天挑战我……囧，只好写了一个辅助工具帮我自动满分，最后的结果是大家一起满分……本人不是程序员，请大家指正。

      主要使用了PIL模块和pymouse模块，一个做图像识别，另一个做自动点击，这个小工具只在我的电脑，Python2.5+XP下测试通过。

1. # -*- coding: utf-8 -*-  
2. #这是一个QQ空间3366小游戏中的彩色砖块游戏的辅助工具  
3. #他可以帮你自动计算一种正确的算法，保证你得200分！  
4. #使用时不能有任何窗口遮挡游戏界面，同时也不能做其他操作  
5.  
6. #程序基本原理：  
7. #彩色砖块可以看作是一个23*15的矩阵，其中有10中颜色的砖块。没有砖块的空白块填充有灰白相间的背景  
8. #点击其中一个空白块，则四周相同的砖块将消除，直至所有砖块消除为止  
9. #游戏首先截取屏幕，然后寻找边长为25的灰色块和白色块，并加上一个偏移量，从而确定矩阵的起始坐标。  
10. #通过获取矩阵中心点位置的颜色，确定所在位置的砖块，然后记录在一个二维列表中。  
11. #将所有空白块按顺序生成一个列表，随即选出一个空白块，直到找到四周有相同砖块可以点击的空白块。  
12. #在二维列表中进行消除，重复以上操作，将点击的空白块顺序记录在一个列表中，直到矩阵全部为空白块为止。  
13. #如果当还有砖块但已经找不到周围可以消除的空白块，则表示这种点击顺序不成功。然后从新计算一种点击顺序，直至成功未知。  
14. #最后按计算出的顺序模拟鼠标点击砖块。  
15. import copy  
16. import time  
17. import random  
18. import pymouse  
19. from PIL import ImageGrab  
20. from PIL import Image  
21.  
22. raw_input(u"输入任意键开始……".encode("gb2312"))  
23. #定义灰色正方形块,白色正方形块的RGB值  
24. gray = (237, 237, 237)  
25. white = (247, 247, 247)  
26. #定义砖块颜色  
27. color = {  
28.     1:(0, 102, 255), #蓝色  
29.     2:(255, 102, 102), #红色  
30.     3:(204, 102, 204),#紫色  
31.     4:(204, 102, 0), #棕色  
32.     5:(0, 204, 0), #绿色  
33.     6:(102, 204, 204),#青色  
34.     7:(255, 153, 0),#橙色  
35.     8:(187, 187, 187),#中灰  
36.     9:(204, 204, 102),#咖啡色  
37.     10:(255, 136, 255)#淡紫  
38.     }  
39. #定义方块大小  
40. blockSize = 25 
41. #定义游戏方块矩阵的大小  
42. gameSize = [23, 15]  
43.  
44. #屏幕截图  
45. #screen = Image.open("screen.bmp") #用来测试的截图  
46. screen = ImageGrab.grab()  
47. #获得屏幕像素矩阵  
48. xy = screen.load()  
49. #遍历每一个像素，发现RGB值等于gray的像素时，检查他的右24和下24像素是否为gray  
50. #灰色块  
51. print u"正在获取游戏起始坐标……" 
52. isGray = False 
53. #白色块  
54. isWhite = False 
55. for y in xrange(screen.size[1]):  
56.     for x in xrange(screen.size[0]):  
57.         if xy[x, y] == gray:  
58.             #查右24个像素RGB值为gray的像素,不是则继续找  
59.             for i in xrange(blockSize):  
60.                 try:  
61.                     if xy[x+i, y] == gray:  
62.                         isGray = True 
63.                     else:  
64.                         isGray = False 
65.                         break 
66.                 except IndexError:  
67.                         isGray = False 
68.                         break 
69.  
70.             if isGray == True:  
71.                 #检查前一个像素和后第25个像素的RGB是否为white  
72.                 if xy[x-1, y] == white and xy[x+blockSize, y] == white:  
73.                     isWhite = True 
74.  
75.         if isWhite == True: break 
76.     if isWhite == True: break 
77.  
78. #定义游戏操作区的开始坐标  
79. gamePos = [x+10, y+31+10]  
80. #记录砖块状况的二维数组  
81. array = []  
82. for y in xrange(gameSize[1]):  
83.     xArray = []  
84.     for x in xrange(gameSize[0]):  
85.         #获得砖块RGB值  
86.         blackRGB = xy[gamePos[0]+blockSize*x, gamePos[1]+blockSize*y]  
87.         #如果砖块RGB值为gray, white，则此二维坐标为空  
88.         if blackRGB in [gray, white]:  
89.             xArray.append(0)  
90.         else:  
91.             for key in color:  
92.                 if color[key] == blackRGB:  
93.                     xArray.append(key)  
94.                     break 
95.     array.append(xArray)  
96. #复制array，用于以后重复寻找正确的点击顺序  
97. ar = copy.deepcopy(array)  
98.  
99. #检查一个空白点周围4边的色块，返回一个包含边界色块坐标的列表  
100. def check(x, y):  
101.     border = []  
102.     #前  
103.     i = 0 
104.     while True:  
105.         i = i+1 
106.         z = y-i  
107.         if z in [-1, 23]:  
108.             break 
109.         if array[x][z] != 0:  
110.             border.append([x, z])  
111.             break 
112.     #后  
113.     i = 0 
114.     while True:  
115.         i = i+1 
116.         z = y+i  
117.         if z in [-1, 23]:  
118.             break 
119.         if array[x][z] != 0:  
120.             border.append([x, z])  
121.             break 
122.     #上  
123.     i = 0 
124.     while True:  
125.         i = i+1 
126.         z = x-i  
127.         if z in [-1, 15]:  
128.             break 
129.         if array[z][y] != 0:  
130.             border.append([z, y])  
131.             break 
132.     #下  
133.     i = 0 
134.     while True:  
135.         i = i+1 
136.         z = x+i  
137.         if z in [-1, 15]:  
138.             break 
139.         if array[z][y] != 0:  
140.             border.append([z, y])  
141.             break 
142.     return border  
143.  
144. #比较一个空白色块周围4边的色块，如颜色相同则消除  
145. def compare(border, doCompare=False):  
146.     a = border.pop()  
147.     aValue = array[a[0]][a[1]]  
148.     list = copy.deepcopy(border)  
149.     for b in list:  
150.         bValue = array[b[0]][b[1]]  
151.         if aValue == bValue:  
152.             array[a[0]][a[1]] = 0 
153.             array[b[0]][b[1]] = 0 
154.             border.remove(b)  
155.             doCompare = True 
156.     if border != []: doCompare = compare(border, doCompare)  
157.     return doCompare  
158.  
159. #在游戏矩阵中寻找空白块模拟点击消除  
160. def simClick():  
161.     emptyBlack = []  
162.     for x, xArray in enumerate(array):  
163.         for y, value in enumerate(xArray):  
164.             #如果方块是空白的，则查看四个方向有无相同色块  
165.             if value == 0:  
166.                 emptyBlack.append([x, y])  
167.     lenEmptyBlack = len(emptyBlack)  
168.     #如果空白色块的数量达到23*15，那么说明此时已经完成了游戏  
169.     if lenEmptyBlack == gameSize[0]*gameSize[1]: return "complete" 
170.     for i in xrange(lenEmptyBlack):  
171.         randomBlack = random.choice(emptyBlack)  
172.         x, y = randomBlack  
173.         border = check(x, y)  
174.         if border != []:  
175.             if compare(border) == True:  
176.                 return randomBlack  
177.     #如果已经没有可以合并的色块，则表示此种点击顺序失败  
178.     return "fail" 
179.  
180. #寻找正确点击顺序的算法，返回一个依次点击的列表  
181. def algorithm():  
182.     print u"正在计算正确的点击顺序……" 
183.     while True:  
184.         clickOrder = []  
185.         global array  
186.         array = copy.deepcopy(ar)  
187.         while True:  
188.             randomBlack = simClick()  
189.             if randomBlack not in ["complete", "fail"]:  
190.                 clickOrder.append(randomBlack)  
191.                 continue 
192.             if randomBlack == "fail": break 
193.             else: return clickOrder  
194.  
195. #开始真正玩游戏。  
196. def playGame(clickOrder):  
197.     #模拟鼠标点击  
198.     print u"开始自动玩游戏……" 
199.     mouse = pymouse.PyMouse()  
200.     for x, y in clickOrder:  
201.         mouse.press(gamePos[0]+blockSize*y, gamePos[1]+blockSize*x)  
202.         time.sleep(0.6)  
203.     print u"完成!3秒后自动退出！" 
204.     time.sleep(3)  
205.  
206. playGame(algorithm())  
207.  
208.