1. # coding: utf-8
  2. import os
  3. import sys
  4. import subprocess
  5. import shutil
  6. import time
  7. import math
  8. from PIL import Image, ImageDraw
  9. import random
  10. import json
  11. import re
  14. # === 思路 ===
  15. # 核心：每次落稳之后截图，根据截图算出棋子的坐标和下一个块顶面的中点坐标，
  16. # 根据两个点的距离乘以一个时间系数获得长按的时间
  17. # 识别棋子：靠棋子的颜色来识别位置，通过截图发现最下面一行大概是一条直线，就从上往下一行一行遍历，
  18. # 比较颜色（颜色用了一个区间来比较）找到最下面的那一行的所有点，然后求个中点，
  19. # 求好之后再让 Y 轴坐标减小棋子底盘的一半高度从而得到中心点的坐标
  20. # 识别棋盘：靠底色和方块的色差来做，从分数之下的位置开始，一行一行扫描，由于圆形的块最顶上是一条线，
  21. # 方形的上面大概是一个点，所以就用类似识别棋子的做法多识别了几个点求中点，
  22. # 这时候得到了块中点的 X 轴坐标，这时候假设现在棋子在当前块的中心，
  23. # 根据一个通过截图获取的固定的角度来推出中点的 Y 坐标
  24. # 最后：根据两点的坐标算距离乘以系数来获取长按时间（似乎可以直接用 X 轴距离）
  27. # TODO: 解决定位偏移的问题
  28. # TODO: 看看两个块中心到中轴距离是否相同，如果是的话靠这个来判断一下当前超前还是落后，便于矫正
  29. # TODO: 一些固定值根据截图的具体大小计算
  30. # TODO: 直接用 X 轴距离简化逻辑
  32. def open_accordant_config():
  33. screen_size = _get_screen_size()
  34. config_file = "{path}/config/{screen_size}/config.json".format(
  35. path=sys.path[0],
  36. screen_size=screen_size
  37. )
  38. if os.path.exists(config_file):
  39. with open(config_file, 'r') as f:
  40. print("Load config file from {}".format(config_file))
  41. return json.load(f)
  42. else:
  43. with open('{}/config/default.json'.format(sys.path[0]), 'r') as f:
  44. print("Load default config")
  45. return json.load(f)
  48. def _get_screen_size():
  49. size_str = os.popen('adb shell wm size').read()
  50. m = re.search('(\d )x(\d )', size_str)
  51. if m:
  52. width = m.group(1)
  53. height = m.group(2)
  54. return "{height}x{width}".format(height=height, width=width)
  57. config = open_accordant_config()
  59. # Magic Number，不设置可能无法正常执行，请根据具体截图从上到下按需设置
  60. under_game_score_y = config['under_game_score_y']
  61. press_coefficient = config['press_coefficient'] # 长按的时间系数，请自己根据实际情况调节
  62. piece_base_height_1_2 = config['piece_base_height_1_2'] # 二分之一的棋子底座高度，可能要调节
  63. piece_body_width = config['piece_body_width'] # 棋子的宽度，比截图中量到的稍微大一点比较安全，可能要调节
  65. # 模拟按压的起始点坐标，需要自动重复游戏请设置成“再来一局”的坐标
  66. if config.get('swipe'):
  67. swipe = config['swipe']
  68. else:
  69. swipe = {}
  70. swipe['x1'], swipe['y1'], swipe['x2'], swipe['y2'] = 320, 410, 320, 410
  73. screenshot_backup_dir = 'screenshot_backups/'
  74. if not os.path.isdir(screenshot_backup_dir):
  75. os.mkdir(screenshot_backup_dir)
  78. def pull_screenshot():
  79. process = subprocess.Popen('adb shell screencap -p', shell=True, stdout=subprocess.PIPE)
  80. screenshot = process.stdout.read()
  81. if sys.platform == 'win32':
  82. screenshot = screenshot.replace(b'\r\n', b'\n')
  83. f = open('autojump.png', 'wb')
  84. f.write(screenshot)
  85. f.close()
  87. def backup_screenshot(ts):
  88. # 为了方便失败的时候 debug
  89. if not os.path.isdir(screenshot_backup_dir):
  90. os.mkdir(screenshot_backup_dir)
  91. shutil.copy('autojump.png', '{}{}.png'.format(screenshot_backup_dir, ts))
  94. def save_debug_creenshot(ts, im, piece_x, piece_y, board_x, board_y):
  95. draw = ImageDraw.Draw(im)
  96. # 对debug图片加上详细的注释
  97. draw.line((piece_x, piece_y) (board_x, board_y), fill=2, width=3)
  98. draw.line((piece_x, 0, piece_x, im.size[1]), fill=(255, 0, 0))
  99. draw.line((0, piece_y, im.size[0], piece_y), fill=(255, 0, 0))
  100. draw.line((board_x, 0, board_x, im.size[1]), fill=(0, 0, 255))
  101. draw.line((0, board_y, im.size[0], board_y), fill=(0, 0, 255))
  102. draw.ellipse((piece_x - 10, piece_y - 10, piece_x 10, piece_y 10), fill=(255, 0, 0))
  103. draw.ellipse((board_x - 10, board_y - 10, board_x 10, board_y 10), fill=(0, 0, 255))
  104. del draw
  105. im.save('{}{}_d.png'.format(screenshot_backup_dir, ts))
  108. def set_button_position(im):
  109. # 将swipe设置为 `再来一局` 按钮的位置
  110. global swipe_x1, swipe_y1, swipe_x2, swipe_y2
  111. w, h = im.size
  112. left = w / 2
  113. top = 1003 * (h / 1280.0) 10
  114. swipe_x1, swipe_y1, swipe_x2, swipe_y2 = left, top, left, top
  117. def jump(distance):
  118. press_time = distance * press_coefficient
  119. press_time = max(press_time, 200) # 设置 200 ms 是最小的按压时间
  120. press_time = int(press_time)
  121. cmd = 'adb shell input swipe {x1} {y1} {x2} {y2} {duration}'.format(
  122. x1=swipe['x1'],
  123. y1=swipe['y1'],
  124. x2=swipe['x2'],
  125. y2=swipe['y2'],
  126. duration=press_time
  127. )
  128. print(cmd)
  129. os.system(cmd)
  131. # 转换色彩模式hsv2rgb
  132. def hsv2rgb(h, s, v):
  133. h = float(h)
  134. s = float(s)
  135. v = float(v)
  136. h60 = h / 60.0
  137. h60f = math.floor(h60)
  138. hi = int(h60f) % 6
  139. f = h60 - h60f
  140. p = v * (1 - s)
  141. q = v * (1 - f * s)
  142. t = v * (1 - (1 - f) * s)
  143. r, g, b = 0, 0, 0
  144. if hi == 0: r, g, b = v, t, p
  145. elif hi == 1: r, g, b = q, v, p
  146. elif hi == 2: r, g, b = p, v, t
  147. elif hi == 3: r, g, b = p, q, v
  148. elif hi == 4: r, g, b = t, p, v
  149. elif hi == 5: r, g, b = v, p, q
  150. r, g, b = int(r * 255), int(g * 255), int(b * 255)
  151. return r, g, b
  153. # 转换色彩模式rgb2hsv
  154. def rgb2hsv(r, g, b):
  155. r, g, b = r/255.0, g/255.0, b/255.0
  156. mx = max(r, g, b)
  157. mn = min(r, g, b)
  158. df = mx-mn
  159. if mx == mn:
  160. h = 0
  161. elif mx == r:
  162. h = (60 * ((g-b)/df) 360) % 360
  163. elif mx == g:
  164. h = (60 * ((b-r)/df) 120) % 360
  165. elif mx == b:
  166. h = (60 * ((r-g)/df) 240) % 360
  167. if mx == 0:
  168. s = 0
  169. else:
  170. s = df/mx
  171. v = mx
  172. return h, s, v
  175. def find_piece_and_board(im):
  176. w, h = im.size
  178. piece_x_sum = 0
  179. piece_x_c = 0
  180. piece_y_max = 0
  181. board_x = 0
  182. board_y = 0
  184. left_value = 0
  185. left_count = 0
  186. right_value = 0
  187. right_count = 0
  188. from_left_find_board_y = 0
  189. from_right_find_board_y = 0
  192. scan_x_border = int(w / 8) # 扫描棋子时的左右边界
  193. scan_start_y = 0 # 扫描的起始y坐标
  194. im_pixel=im.load()
  195. # 以50px步长，尝试探测scan_start_y
  196. for i in range(int(h / 3), int( h*2 /3 ), 50):
  197. last_pixel = im_pixel[0,i]
  198. for j in range(1, w):
  199. pixel=im_pixel[j,i]
  200. # 不是纯色的线，则记录scan_start_y的值，准备跳出循环
  201. if pixel[0] != last_pixel[0] or pixel[1] != last_pixel[1] or pixel[2] != last_pixel[2]:
  202. scan_start_y = i - 50
  203. break
  204. if scan_start_y:
  205. break
  206. print('scan_start_y: ', scan_start_y)
  208. # 从scan_start_y开始往下扫描，棋子应位于屏幕上半部分，这里暂定不超过2/3
  209. for i in range(scan_start_y, int(h * 2 / 3)):
  210. for j in range(scan_x_border, w - scan_x_border): # 横坐标方面也减少了一部分扫描开销
  211. pixel = im_pixel[j,i]
  212. # 根据棋子的最低行的颜色判断，找最后一行那些点的平均值，这个颜色这样应该 OK，暂时不提出来
  213. if (50 < pixel[0] < 60) and (53 < pixel[1] < 63) and (95 < pixel[2] < 110):
  214. piece_x_sum = j
  215. piece_x_c = 1
  216. piece_y_max = max(i, piece_y_max)
  218. if not all((piece_x_sum, piece_x_c)):
  219. return 0, 0, 0, 0
  220. piece_x = piece_x_sum / piece_x_c
  221. piece_y = piece_y_max - piece_base_height_1_2 # 上移棋子底盘高度的一半
  223. for i in range(int(h / 3), int(h * 2 / 3)):
  225. last_pixel = im_pixel[0, i]
  226. # 计算阴影的RGB值,通过photoshop观察,阴影部分其实就是背景色的明度V 乘以0.7的样子
  227. h, s, v = rgb2hsv(last_pixel[0], last_pixel[1], last_pixel[2])
  228. r, g, b = hsv2rgb(h, s, v * 0.7)
  230. if from_left_find_board_y and from_right_find_board_y:
  231. break
  233. if not board_x:
  234. board_x_sum = 0
  235. board_x_c = 0
  237. for j in range(w):
  238. pixel = im_pixel[j,i]
  239. # 修掉脑袋比下一个小格子还高的情况的 bug
  240. if abs(j - piece_x) < piece_body_width:
  241. continue
  243. # 修掉圆顶的时候一条线导致的小 bug，这个颜色判断应该 OK，暂时不提出来
  244. if abs(pixel[0] - last_pixel[0]) abs(pixel[1] - last_pixel[1]) abs(pixel[2] - last_pixel[2]) > 10:
  245. board_x_sum = j
  246. board_x_c = 1
  247. if board_x_sum:
  248. board_x = board_x_sum / board_x_c
  249. else:
  250. # 继续往下查找,从左到右扫描,找到第一个与背景颜色不同的像素点,记录位置
  251. # 当有连续3个相同的记录时,表示发现了一条直线
  252. # 这条直线即为目标board的左边缘
  253. # 然后当前的 y 值减 3 获得左边缘的第一个像素
  254. # 就是顶部的左边顶点
  255. for j in range(w):
  256. pixel = im_pixel[j, i]
  257. # 修掉脑袋比下一个小格子还高的情况的 bug
  258. if abs(j - piece_x) < piece_body_width:
  259. continue
  260. if (abs(pixel[0] - last_pixel[0]) abs(pixel[1] - last_pixel[1]) abs(pixel[2] - last_pixel[2])
  261. > 10) and (abs(pixel[0] - r) abs(pixel[1] - g) abs(pixel[2] - b) > 10):
  262. if left_value == j:
  263. left_count = left_count 1
  264. else:
  265. left_value = j
  266. left_count = 1
  268. if left_count > 3:
  269. from_left_find_board_y = i - 3
  270. break
  271. # 逻辑跟上面类似,但是方向从右向左
  272. # 当有遮挡时,只会有一边有遮挡
  273. # 算出来两个必然有一个是对的
  274. for j in range(w)[::-1]:
  275. pixel = im_pixel[j, i]
  276. # 修掉脑袋比下一个小格子还高的情况的 bug
  277. if abs(j - piece_x) < piece_body_width:
  278. continue
  279. if (abs(pixel[0] - last_pixel[0]) abs(pixel[1] - last_pixel[1]) abs(pixel[2] - last_pixel[2])
  280. > 10) and (abs(pixel[0] - r) abs(pixel[1] - g) abs(pixel[2] - b) > 10):
  281. if right_value == j:
  282. right_count = left_count 1
  283. else:
  284. right_value = j
  285. right_count = 1
  287. if right_count > 3:
  288. from_right_find_board_y = i - 3
  289. break
  291. # 如果顶部像素比较多,说明图案近圆形,相应的求出来的值需要增大,这里暂定增大顶部宽的三分之一
  292. if board_x_c > 5:
  293. from_left_find_board_y = from_left_find_board_y board_x_c / 3
  294. from_right_find_board_y = from_right_find_board_y board_x_c / 3
  296. # 按实际的角度来算，找到接近下一个 board 中心的坐标 这里的角度应该是30°,值应该是tan 30°,math.sqrt(3) / 3
  297. board_y = piece_y - abs(board_x - piece_x) * math.sqrt(3) / 3
  299. # 从左从右取出两个数据进行对比,选出来更接近原来老算法的那个值
  300. if abs(board_y - from_left_find_board_y) > abs(from_right_find_board_y):
  301. new_board_y = from_right_find_board_y
  302. else:
  303. new_board_y = from_left_find_board_y
  305. if not all((board_x, board_y)):
  306. return 0, 0, 0, 0
  308. return piece_x, piece_y, board_x, new_board_y
  311. def dump_device_info():
  312. size_str = os.popen('adb shell wm size').read()
  313. device_str = os.popen('adb shell getprop ro.product.model').read()
  314. density_str = os.popen('adb shell wm density').read()
  315. print("如果你的脚本无法工作，上报issue时请copy如下信息:\n**********\
  316. \nScreen: {size}\nDensity: {dpi}\nDeviceType: {type}\nOS: {os}\nPython: {python}\n**********".format(
  317. size=size_str.strip(),
  318. type=device_str.strip(),
  319. dpi=density_str.strip(),
  320. os=sys.platform,
  321. python=sys.version
  322. ))
  325. def check_adb():
  326. flag = os.system('adb devices')
  327. if flag == 1:
  328. print('请安装ADB并配置环境变量')
  329. sys.exit()
  332. def main():
  334. h, s, v = rgb2hsv(201, 204, 214)
  335. print(h, s, v)
  336. r, g, b = hsv2rgb(h, s, v*0.7)
  337. print(r, g, b)
  339. dump_device_info()
  340. check_adb()
  341. while True:
  342. pull_screenshot()
  343. im = Image.open('./autojump.png')
  344. # 获取棋子和 board 的位置
  345. piece_x, piece_y, board_x, board_y = find_piece_and_board(im)
  346. ts = int(time.time())
  347. print(ts, piece_x, piece_y, board_x, board_y)
  348. set_button_position(im)
  349. jump(math.sqrt((board_x - piece_x) ** 2 (board_y - piece_y) ** 2))
  350. save_debug_creenshot(ts, im, piece_x, piece_y, board_x, board_y)
  351. backup_screenshot(ts)
  352. time.sleep(random.uniform(1.2, 1.4)) # 为了保证截图的时候应落稳了，多延迟一会儿
  355. if __name__ == '__main__':
  356. main()

python游戏跳一跳教学（跳一跳Python代码）(1)

,