[Python] 用python作一個遊戲輔助腳本，完整思路

1、說明

　　簡述：本文將以4399小遊戲《寵物連連看經典版2》做爲測試案例，經過識別小圖標，模擬鼠標點擊，快速完成配對。對於有興趣學習遊戲腳本的同窗有必定的幫助。

　　運行環境：Win10/Python3.5。

　　主要模塊：win32gui（識別窗口、窗口置頂等操做）、PIL（屏幕截圖）、numpy（建立矩陣）、operator（比較值）、pymouse（模擬鼠標點擊）。

　　注意點：

　　　　　　一、若是安裝pymouse不成功或者運行報錯，能夠考慮先經過whl 安裝pyHook、而後再經過pip安裝pyuserinput。

　　　　　　二、若是報錯 [ImportError: No module named 'windows' ]，能夠修改__init__.py相應的行 爲 windows => pymouse.windows。

 

　　本文主要參考：https://baijiahao.baidu.com/s?id=1618385402903335091&wfr=spider&for=pc。

　　　　

 

2、開發前景（隨便嘮叨一哈，可跳過）

　　遊戲輔助腳本在當前環境也算是比較流行了，對於常常玩遊戲人來講，適當的遊戲輔助仍是頗有幫助的，讓計算機作一些繁瑣乏味的操做。固然還有更加高大上的其餘操做，這裏就不贅述了。對於遊戲輔助腳本，能想到基本有如下兩種：一是讀取遊戲在內存中的數據，理想的話能夠作到更改遊戲一些基本屬性，原理和不少的外掛或破解遊戲相似；二是模擬用戶用戶行爲，模擬鼠標點擊、鍵盤操做等。固然，因爲本人從未涉及遊戲輔助腳本這一領域，出於我的興趣，學習研究一下，本文例子則是第二種，主要仍是模擬用戶行爲，讓程序代替用戶操做。

 

3、開發流程

　　先看看程序運行圖吧：

　　

 

　　瀏覽器打開遊戲窗口（單個一個窗口），遊戲界面以下圖所示，遊戲主要界面截圖須要兩個座標（左上角座標和右下角座標）來肯定，原點通常是屏幕左上角，不肯定座標點值的同窗，能夠全屏截圖，用編輯圖片軟件查看座標值。獲取窗口句柄，這裏就是瀏覽器標題欄的標題了（右鍵-查看源代碼-title，加上軟件名）好比：「寵物連連看經典2,寵物連連看經典版2小遊戲,4399小遊戲 www.4399.com - Google Chrome「。獲取窗口句柄就能夠開始了。

　　整體開發思路：截取遊戲主圖 ---> 分割成小圖 ---> 對比每一個小圖，對比圖片相識度，編號存入矩陣 ---> 對矩陣進行可連計算 ---> 模擬點擊。

　　

 

　　3.一、獲取窗口句柄，把窗口置頂

　　　　python可使用win32gui模塊調用Windows API實現對窗口的操做，使用FindWindow()方法能夠獲取窗口的句柄（handle），須要傳入兩個參數，第一個爲父窗口句柄（這裏填0便可），第二個參數是窗口的名稱（標籤title - Google Chrome）。獲取句柄以後而後經過SetForegroundWindows() 設置窗口在前面，這裏傳入遊戲窗口的舉報便可，代碼以下：

 1 import win32gui  2 
 3 class GameAssist:  4 
 5     def __init__(self, wdname):  6         """初始化"""
 7 
 8         # 取得窗口句柄
 9         self.hwnd = win32gui.FindWindow(0, wdname) 10         if not self.hwnd: 11             print("窗口找不到，請確認窗口句柄名稱：【%s】" % wdname ) 12  exit() 13         # 窗口顯示最前面
14  win32gui.SetForegroundWindow(self.hwnd) 15 
16 
17 if __name__ == "__main__": 18     # wdname 爲連連看窗口的名稱，必須寫完整
19     wdname = u'寵物連連看經典版2,寵物連連看經典版2小遊戲,4399小遊戲 www.4399.com - Google Chrome'
20 
21     demo = GameAssist(wdname) 22     demo.start()

　　　　　

　　3.二、截取遊戲界面，分割圖標，圖片比較

　　　　這裏須要花費一些時間來校驗程序，若是截取的圖片很差，則會影響後續操做，因此比較主要的是確認遊戲左上角和右下角這兩個座標值，以及每一個小圖標的寬高。以下圖所示，先截取整個遊戲界面圖，而後分割小圖標，接着對每一個圖標進行比較，而後以編號代替圖標存入矩陣（這裏的編號矩陣和遊戲圖不一致，原理同樣）。

　　　　

　　　　

　　　　根據初始化設定的左上角和右下角兩個座標，使用ImageGrab.grab()方法進行截圖，傳入一個元組便可，而後對這個大圖進行分割，切割成一個個小圖標存入到images_list數組中。　　　

 1     def screenshot(self):  2         """屏幕截圖"""
 3 
 4         # 一、用grab函數截圖，參數爲左上角和右下角左標
 5         # image = ImageGrab.grab((417, 257, 885, 569))
 6         image = ImageGrab.grab(self.scree_left_and_right_point)  7 
 8         # 二、分切小圖
 9         # exit()
10         image_list = {} 11         offset = self.im_width  # 39
12 
13         # 8行12列
14         for x in range(8): 15             image_list[x] = {} 16             for y in range(12): 17                 # print("show",x, y)
18                 # exit()
19                 top = x * offset 20                 left = y * offset 21                 right = (y + 1) * offset 22                 bottom = (x + 1) * offset 23 
24                 # 用crop函數切割成小圖標，參數爲圖標的左上角和右下角左邊
25                 im = image.crop((left, top, right, bottom)) 26                 # 將切割好的圖標存入對應的位置
27                 image_list[x][y] = im 28 
29         return image_list

　　　　

　　　　經過上面代碼切割的小圖標，轉成數字矩陣，若是圖標已經存入image_type_list則返回這個索引，若是不存在，則在追加進去，而後當前長度就是這個新加入圖標的編號，代碼以下所示：

 1     def image2num(self, image_list):  2         """將圖標矩陣轉換成數字矩陣"""
 3 
 4         # 一、建立全零矩陣和空的一維數組
 5         arr = np.zeros((10, 14), dtype=np.int32)    # 以數字代替圖片
 6         image_type_list = []  7 
 8         # 二、識別出不一樣的圖片，將圖片矩陣轉換成數字矩陣
 9         for i in range(len(image_list)): 10             for j in range(len(image_list[0])): 11                 im = image_list[i][j] 12                 
13                 # 驗證當前圖標是否已存入
14                 index = self.getIndex(im, image_type_list) 15 
16                 # 不存在image_type_list
17                 if index < 0: 18  image_type_list.append(im) 19                     arr[i + 1][j + 1] = len(image_type_list) 20                 else: 21                     arr[i + 1][j + 1] = index + 1
22 
23         print("圖標數：", len(image_type_list)) 24 
25         self.im2num_arr = arr 26         return arr

 

　　　　

　　　　上面的getIndex就是對比圖片，判斷圖標是否出現過（是否已存在image_type_list中，沒出現則追加進去），這裏使用漢明距離判斷兩個圖片的相識度，設置閥值10，當小於閥值則認爲是同一個圖片，具體代碼以下：　　

 1     # 檢查數組中是否有圖標,若是有則返回索引下表
 2     def getIndex(self,im, im_list):  3         for i in range(len(im_list)):  4             if self.isMatch(im, im_list[i]):  5                 return i  6 
 7         return -1
 8 
 9     # 漢明距離判斷兩個圖標是否同樣
10     def isMatch(self, im1, im2): 11 
12         # 縮小圖標，轉成灰度
13         image1 = im1.resize((20, 20), Image.ANTIALIAS).convert("L") 14         image2 = im2.resize((20, 20), Image.ANTIALIAS).convert("L") 15 
16         # 將灰度圖標轉成01串,即系二進制數據
17         pixels1 = list(image1.getdata()) 18         pixels2 = list(image2.getdata()) 19 
20         avg1 = sum(pixels1) / len(pixels1) 21         avg2 = sum(pixels2) / len(pixels2) 22         hash1 = "".join(map(lambda p: "1" if p > avg1 else "0", pixels1)) 23         hash2 = "".join(map(lambda p: "1" if p > avg2 else "0", pixels2)) 24 
25         # 統計兩個01串不一樣數字的個數
26         match = sum(map(operator.ne, hash1, hash2)) 27 
28         # 閥值設爲10
29         return match < 10

　　　　　

 

4、程序核心-圖標鏈接算法（路徑尋找）

　　這裏僅對算法代碼進行簡單分析，若是對程序很差理解，能夠留言，後續能夠圖文分析。

　　經過上面的開發流程，基本獲取以下這樣的矩陣，只要比較兩個編號相同的值進行可連路徑尋找，若是找到即進行模擬點擊操做。這裏簡單介紹下游戲規則：8行乘12列遊戲圖標區域，外圍的0其實表示尋找路徑的時候能夠經過，例如座標（1, 1）能夠與（1,10）進行鏈接、（7, 1）和（7,2）進行鏈接。

 1 arr = [  2  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],  3     [ 0,  1,  2,  3,  4,  5,  4,  6,  7,  2,  1,  1,  8, 0],  4     [ 0,  9,  3,  3, 10,  4,  7, 11,  7,  2,  3,  1,  6, 0],  5     [ 0,  6,  7,  4, 11,  5,  8,  1,  6,  5,  4,  2,  8, 0],  6     [ 0,  6,  2,  9,  6,  8,  9,  7, 12, 11,  3, 11, 11, 0],  7     [ 0,  5,  9,  8,  9,  2,  6, 11, 11,  3,  9,  2, 12, 0],  8     [ 0, 12,  5, 12,  5, 10,  5,  6,  5,  7, 12,  4,  3, 0],  9     [ 0,  1,  8, 10, 12,  9, 10,  4,  3,  7,  2,  1, 10, 0], 10     [ 0,  1,  4, 10,  8, 12, 10, 10,  9, 12,  8,  7, 11, 0], 11  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 12 ]

　　

　　算法的思路：路徑的尋找首先是尋找一個座標的橫向豎向能夠直接相連的座標集合，好比座標p1（1,1）這樣的集合有[ （0,1）, （1,0） ]，另一個座標p2（1,10）的可連集合爲[ （0,10） ]，而後再對p1和p2的可連座標集合進行比較，若是集合中座標也有可連，則表示p1和p2可連，很明顯，（0,1）和（0,10）爲同一行且可連，這樣就表示p1和p2兩點存在可連路徑了，代碼以下所示：

　　簡單分析下代碼實現過程：在isReachable()傳入兩個須要比較的座標值，而後分別獲取兩個點橫豎向（isRowConnect()、isColConnect()）能夠鏈接的座標集合，最後再對集合進行遍歷比較是否存在可連的，若是存在則表示傳入的兩個座標是能夠鏈接的。

 1     # 是否爲同行或同列且可連
 2     def isReachable(self, x1, y1, x2, y2):  3         # 一、先判斷值是否相同
 4         if self.im2num_arr[x1][y1] != self.im2num_arr[x2][y2]:  5             return False  6 
 7         # 一、分別獲取兩個座標同行或同列可連的座標數組
 8         list1 = self.getDirectConnectList(x1, y1)  9         list2 = self.getDirectConnectList(x2, y2) 10         # print(x1, y1, list1)
11         # print(x2, y2, list2)
12 
13         # exit()
14 
15         # 二、比較座標數組中是否可連
16         for x1, y1 in list1: 17             for x2, y2 in list2: 18                 if self.isDirectConnect(x1, y1, x2, y2): 19                     return True 20         return False 21 
22     # 獲取同行或同列可連的座標數組
23     def getDirectConnectList(self, x, y): 24 
25         plist = [] 26         for px in range(0, 10): 27             for py in range(0, 14): 28                 # 獲取同行或同列且爲0的座標
29                 if self.im2num_arr[px][py] == 0 and self.isDirectConnect(x, y, px, py): 30  plist.append([px, py]) 31 
32         return plist 33 
34     # 是否爲同行或同列且可連
35     def isDirectConnect(self, x1, y1, x2, y2): 36         # 一、位置徹底相同
37         if x1 == x2 and y1 == y2: 38             return False 39 
40         # 二、行列都不一樣的
41         if x1 != x2 and y1 != y2: 42             return False 43 
44         # 三、同行
45         if x1 == x2 and self.isRowConnect(x1, y1, y2): 46             return True 47 
48         # 四、同列
49         if y1 == y2 and self.isColConnect(y1, x1, x2): 50             return True 51 
52         return False 53 
54     # 判斷同行是否可連
55     def isRowConnect(self, x, y1, y2): 56         minY = min(y1, y2) 57         maxY = max(y1, y2) 58 
59         # 相鄰直接可連
60         if maxY - minY == 1: 61             return True 62 
63         # 判斷兩個座標之間是否全爲0
64         for y0 in range(minY + 1, maxY): 65             if self.im2num_arr[x][y0] != 0: 66                 return False 67         return True 68 
69     # 判斷同列是否可連
70     def isColConnect(self, y, x1, x2): 71         minX = min(x1, x2) 72         maxX = max(x1, x2) 73 
74         # 相鄰直接可連
75         if maxX - minX == 1: 76             return True 77 
78         # 判斷兩個座標之間是否全爲0
79         for x0 in range(minX + 1, maxX): 80             if self.im2num_arr[x0][y] != 0: 81                 return False 82         return True

　　

 

5、開發總結

　　學習這樣一個遊戲輔助腳本，對於我的培養編程興趣也是有不少幫助的，在工做之餘不失爲一個好的消遣方式，之後會多向這些方向研究學習。本案例僅僅是截圖、比較圖片和模擬鼠標點擊，我以爲還能夠更增強大，並且還不侷限於遊戲這樣一個領域，相信你們應該見過自動發QQ消息的軟件吧，我以爲這徹底能夠作。還有不少模擬操做能夠實現：鼠標滾輪，左右鍵、鍵盤輸入等。

 

6、附件-源碼

　　注意：源碼僅供學習，轉發註明出處，謝謝！

  1 # -*- coding:utf-8 -*-
  2 
  3 import win32gui
  4 import time
  5 from PIL import ImageGrab, Image
  6 import numpy as np
  7 import operator
  8 from pymouse import PyMouse
  9 
 10 
 11 class GameAssist:
 12 
 13     def __init__(self, wdname):
 14         """初始化"""
 15 
 16         # 取得窗口句柄
 17         self.hwnd = win32gui.FindWindow(0, wdname)
 18         if not self.hwnd:
 19             print("窗口找不到，請確認窗口句柄名稱：【%s】" % wdname )
 20             exit()
 21 
 22         # 窗口顯示最前面
 23         win32gui.SetForegroundWindow(self.hwnd)
 24 
 25         # 小圖標編號矩陣
 26         self.im2num_arr = []
 27 
 28         # 主截圖的左上角座標和右下角座標
 29         self.scree_left_and_right_point = (299, 251, 768, 564)
 30         # 小圖標寬高
 31         self.im_width = 39
 32 
 33         # PyMouse對象，鼠標點擊
 34         self.mouse = PyMouse()
 35 
 36     def screenshot(self):
 37         """屏幕截圖"""
 38 
 39         # 一、用grab函數截圖，參數爲左上角和右下角左標
 40         # image = ImageGrab.grab((417, 257, 885, 569))
 41         image = ImageGrab.grab(self.scree_left_and_right_point)
 42 
 43         # 二、分切小圖
 44         # exit()
 45         image_list = {}
 46         offset = self.im_width  # 39
 47 
 48         # 8行12列
 49         for x in range(8):
 50             image_list[x] = {}
 51             for y in range(12):
 52                 # print("show",x, y)
 53                 # exit()
 54                 top = x * offset
 55                 left = y * offset
 56                 right = (y + 1) * offset
 57                 bottom = (x + 1) * offset
 58 
 59                 # 用crop函數切割成小圖標，參數爲圖標的左上角和右下角左邊
 60                 im = image.crop((left, top, right, bottom))
 61                 # 將切割好的圖標存入對應的位置
 62                 image_list[x][y] = im
 63 
 64         return image_list
 65 
 66     def image2num(self, image_list):
 67         """將圖標矩陣轉換成數字矩陣"""
 68 
 69         # 一、建立全零矩陣和空的一維數組
 70         arr = np.zeros((10, 14), dtype=np.int32)    # 以數字代替圖片
 71         image_type_list = []
 72 
 73         # 二、識別出不一樣的圖片，將圖片矩陣轉換成數字矩陣
 74         for i in range(len(image_list)):
 75             for j in range(len(image_list[0])):
 76                 im = image_list[i][j]
 77 
 78                 # 驗證當前圖標是否已存入
 79                 index = self.getIndex(im, image_type_list)
 80 
 81                 # 不存在image_type_list
 82                 if index < 0:
 83                     image_type_list.append(im)
 84                     arr[i + 1][j + 1] = len(image_type_list)
 85                 else:
 86                     arr[i + 1][j + 1] = index + 1
 87 
 88         print("圖標數：", len(image_type_list))
 89 
 90         self.im2num_arr = arr
 91         return arr
 92 
 93     # 檢查數組中是否有圖標,若是有則返回索引下表
 94     def getIndex(self,im, im_list):
 95         for i in range(len(im_list)):
 96             if self.isMatch(im, im_list[i]):
 97                 return i
 98 
 99         return -1
100 
101     # 漢明距離判斷兩個圖標是否同樣
102     def isMatch(self, im1, im2):
103 
104         # 縮小圖標，轉成灰度
105         image1 = im1.resize((20, 20), Image.ANTIALIAS).convert("L")
106         image2 = im2.resize((20, 20), Image.ANTIALIAS).convert("L")
107 
108         # 將灰度圖標轉成01串,即系二進制數據
109         pixels1 = list(image1.getdata())
110         pixels2 = list(image2.getdata())
111 
112         avg1 = sum(pixels1) / len(pixels1)
113         avg2 = sum(pixels2) / len(pixels2)
114         hash1 = "".join(map(lambda p: "1" if p > avg1 else "0", pixels1))
115         hash2 = "".join(map(lambda p: "1" if p > avg2 else "0", pixels2))
116 
117         # 統計兩個01串不一樣數字的個數
118         match = sum(map(operator.ne, hash1, hash2))
119 
120         # 閥值設爲10
121         return match < 10
122 
123     # 判斷矩陣是否全爲0
124     def isAllZero(self, arr):
125         for i in range(1, 9):
126             for j in range(1, 13):
127                 if arr[i][j] != 0:
128                     return False
129         return True
130 
131     # 是否爲同行或同列且可連
132     def isReachable(self, x1, y1, x2, y2):
133         # 一、先判斷值是否相同
134         if self.im2num_arr[x1][y1] != self.im2num_arr[x2][y2]:
135             return False
136 
137         # 一、分別獲取兩個座標同行或同列可連的座標數組
138         list1 = self.getDirectConnectList(x1, y1)
139         list2 = self.getDirectConnectList(x2, y2)
140         # print(x1, y1, list1)
141         # print(x2, y2, list2)
142 
143         # exit()
144 
145         # 二、比較座標數組中是否可連
146         for x1, y1 in list1:
147             for x2, y2 in list2:
148                 if self.isDirectConnect(x1, y1, x2, y2):
149                     return True
150         return False
151 
152     # 獲取同行或同列可連的座標數組
153     def getDirectConnectList(self, x, y):
154 
155         plist = []
156         for px in range(0, 10):
157             for py in range(0, 14):
158                 # 獲取同行或同列且爲0的座標
159                 if self.im2num_arr[px][py] == 0 and self.isDirectConnect(x, y, px, py):
160                     plist.append([px, py])
161 
162         return plist
163 
164     # 是否爲同行或同列且可連
165     def isDirectConnect(self, x1, y1, x2, y2):
166         # 一、位置徹底相同
167         if x1 == x2 and y1 == y2:
168             return False
169 
170         # 二、行列都不一樣的
171         if x1 != x2 and y1 != y2:
172             return False
173 
174         # 三、同行
175         if x1 == x2 and self.isRowConnect(x1, y1, y2):
176             return True
177 
178         # 四、同列
179         if y1 == y2 and self.isColConnect(y1, x1, x2):
180             return True
181 
182         return False
183 
184     # 判斷同行是否可連
185     def isRowConnect(self, x, y1, y2):
186         minY = min(y1, y2)
187         maxY = max(y1, y2)
188 
189         # 相鄰直接可連
190         if maxY - minY == 1:
191             return True
192 
193         # 判斷兩個座標之間是否全爲0
194         for y0 in range(minY + 1, maxY):
195             if self.im2num_arr[x][y0] != 0:
196                 return False
197         return True
198 
199     # 判斷同列是否可連
200     def isColConnect(self, y, x1, x2):
201         minX = min(x1, x2)
202         maxX = max(x1, x2)
203 
204         # 相鄰直接可連
205         if maxX - minX == 1:
206             return True
207 
208         # 判斷兩個座標之間是否全爲0
209         for x0 in range(minX + 1, maxX):
210             if self.im2num_arr[x0][y] != 0:
211                 return False
212         return True
213 
214     # 點擊事件並設置數組爲0
215     def clickAndSetZero(self, x1, y1, x2, y2):
216         # print("click", x1, y1, x2, y2)
217 
218         # (299, 251, 768, 564)
219         # 原理：左上角圖標中點 + 偏移量
220         p1_x = int(self.scree_left_and_right_point[0] + (y1 - 1)*self.im_width + (self.im_width / 2))
221         p1_y = int(self.scree_left_and_right_point[1] + (x1 - 1)*self.im_width + (self.im_width / 2))
222 
223         p2_x = int(self.scree_left_and_right_point[0] + (y2 - 1)*self.im_width + (self.im_width / 2))
224         p2_y = int(self.scree_left_and_right_point[1] + (x2 - 1)*self.im_width + (self.im_width / 2))
225 
226         time.sleep(0.2)
227         self.mouse.click(p1_x, p1_y)
228         time.sleep(0.2)
229         self.mouse.click(p2_x, p2_y)
230 
231         # 設置矩陣值爲0
232         self.im2num_arr[x1][y1] = 0
233         self.im2num_arr[x2][y2] = 0
234 
235         print("消除：(%d, %d) (%d, %d)" % (x1, y1, x2, y2))
236         # exit()
237 
238     # 程序入口、控制中心
239     def start(self):
240 
241         # 一、先截取遊戲區域大圖，而後分切每一個小圖
242         image_list = self.screenshot()
243 
244         # 二、識別小圖標，收集編號
245         self.image2num(image_list)
246 
247         print(self.im2num_arr)
248 
249         # 三、遍歷查找能夠相連的座標
250         while not self.isAllZero(self.im2num_arr):
251             for x1 in range(1, 9):
252                 for y1 in range(1, 13):
253                     if self.im2num_arr[x1][y1] == 0:
254                         continue
255 
256                     for x2 in range(1, 9):
257                         for y2 in range(1, 13):
258                             # 跳過爲0 或者同一個
259                             if self.im2num_arr[x2][y2] == 0 or (x1 == x2 and y1 == y2):
260                                 continue
261                             if self.isReachable(x1, y1, x2, y2):
262                                 self.clickAndSetZero(x1, y1, x2, y2)
263 
264 
265 if __name__ == "__main__":
266     # wdname 爲連連看窗口的名稱，必須寫完整
267     wdname = u'寵物連連看經典版2,寵物連連看經典版2小遊戲,4399小遊戲 www.4399.com - Google Chrome'
268 
269     demo = GameAssist(wdname)
270     demo.start()

GameAssist.py