本文例項為大家分享了微信小程式跳一跳自動執行指令碼，供大家參考，具體內容如下

1、壓縮包帶了adb等必須工具，配置一下環境變數即可

2、Python 直接執行即可 （Python3.6）

程式碼：

wechat_jump_auto.py

    # coding: utf-8
    '''
    # === 思路 ===
    # 核心：每次落穩之後截圖，根據截圖算出棋子的座標和下一個塊頂面的中點座標，
    # 根據兩個點的距離乘以一個時間係數獲得長按的時間
    # 識別棋子：靠棋子的顏色來識別位置，通過截圖發現最下面一行大概是一條直線，就從上往下一行一行遍歷，
    # 比較顏色（顏色用了一個區間來比較）找到最下面的那一行的所有點，然後求箇中點，
    # 求好之後再讓 Y 軸座標減小棋子底盤的一半高度從而得到中心點的座標
    # 識別棋盤：靠底色和方塊的色差來做，從分數之下的位置開始，一行一行掃描，由於圓形的塊最頂上是一條線，
    # 方形的上面大概是一個點，所以就用類似識別棋子的做法多識別了幾個點求中點，
    # 這時候得到了塊中點的 X 軸座標，這時候假設現在棋子在當前塊的中心，
    # 根據一個通過截圖獲取的固定的角度來推出中點的 Y 座標
    # 最後：根據兩點的座標算距離乘以係數來獲取長按時間（似乎可以直接用 X 軸距離）
    '''
    import os
    import sys
    import subprocess
    import time
    import math
    from PIL import Image
    import random
    from six.moves import input
    import debug, config
    import numpy as np
    
    
    
    VERSION = "1.1.1"
    
    
    debug_switch = False # debug 開關，需要除錯的時候請改為：True
    config = config.open_accordant_config()
    
    # Magic Number，不設定可能無法正常執行，請根據具體截圖從上到下按需設定，設定儲存在 config 資料夾中
    under_game_score_y = config['under_game_score_y']
    press_coefficient = config['press_coefficient'] # 長按的時間係數，請自己根據實際情況調節
    piece_base_height_1_2 = config['piece_base_height_1_2'] # 二分之一的棋子底座高度，可能要調節
    piece_body_width = config['piece_body_width'] # 棋子的寬度，比截圖中量到的稍微大一點比較安全，可能要調節
    
    
    screenshot_way = 2
    
    
    def pull_screenshot():
     '''
     新的方法請根據效率及適用性由高到低排序
     '''
     global screenshot_way
     if screenshot_way == 2 or screenshot_way == 1:
     process = subprocess.Popen('adb shell screencap -p', shell=True, stdout=subprocess.PIPE)
     screenshot = process.stdout.read()
     if screenshot_way == 2:
     binary_screenshot = screenshot.replace(b'\r\n', b'\n')
     else:
     binary_screenshot = screenshot.replace(b'\r\r\n', b'\n')
     f = open('autojump.png', 'wb')
     f.write(binary_screenshot)
     f.close()
     elif screenshot_way == 0:
     os.system('adb shell screencap -p /sdcard/autojump.png')
     os.system('adb pull /sdcard/autojump.png .')
    
    
    def set_button_position(im):
     '''
     將 swipe 設定為 `再來一局` 按鈕的位置
     '''
     global swipe_x1, swipe_y1, swipe_x2, swipe_y2
     w, h = im.size
     left = int(w / 2)
     top = int(1584 * (h / 1920.0))
     left = int(random.uniform(left-50, left+50))
     top = int(random.uniform(top-10, top+10)) # 隨機防 ban
     swipe_x1, swipe_y1, swipe_x2, swipe_y2 = left, top, left, top
    
    
    def jump(distance):
     '''
     跳躍一定的距離
     '''
     press_time = distance * press_coefficient
     press_time = max(press_time, 200) # 設定 200ms 是最小的按壓時間
     press_time = int(press_time)
     cmd = 'adb shell input swipe {x1} {y1} {x2} {y2} {duration}'.format(
     x1=swipe_x1,
     y1=swipe_y1,
     x2=swipe_x2,
     y2=swipe_y2,
     duration=press_time
     )
     print(cmd)
     os.system(cmd)
     return press_time
    
    
    def find_piece_and_board(im):
     '''
     尋找關鍵座標
     '''
     w, h = im.size
    
     piece_x_sum = 0
     piece_x_c = 0
     piece_y_max = 0
     board_x = 0
     board_y = 0
     scan_x_border = int(w / 8) # 掃描棋子時的左右邊界
     scan_start_y = 0 # 掃描的起始 y 座標
     im_pixel = im.load()
     # 以 50px 步長，嘗試探測 scan_start_y
     for i in range(int(h / 3), int(h*2 / 3), 50):
     last_pixel = im_pixel[0, i]
     for j in range(1, w):
     pixel = im_pixel[j, i]
     # 不是純色的線，則記錄 scan_start_y 的值，準備跳出迴圈
     if pixel[0] != last_pixel[0] or pixel[1] != last_pixel[1] or pixel[2] != last_pixel[2]:
     scan_start_y = i - 50
     break
     if scan_start_y:
     break
     print('scan_start_y: {}'.format(scan_start_y))
    
     # 從 scan_start_y 開始往下掃描，棋子應位於螢幕上半部分，這裡暫定不超過 2/3
     for i in range(scan_start_y, int(h * 2 / 3)):
     for j in range(scan_x_border, w - scan_x_border): # 橫座標方面也減少了一部分掃描開銷
     pixel = im_pixel[j, i]
     # 根據棋子的最低行的顏色判斷，找最後一行那些點的平均值，這個顏色這樣應該 OK，暫時不提出來
     if (50 < pixel[0] < 60) and (53 < pixel[1] < 63) and (95 < pixel[2] < 110):
     piece_x_sum += j
     piece_x_c += 1
     piece_y_max = max(i, piece_y_max)
    
     if not all((piece_x_sum, piece_x_c)):
     return 0, 0, 0, 0
     piece_x = int(piece_x_sum / piece_x_c)
     piece_y = piece_y_max - piece_base_height_1_2 # 上移棋子底盤高度的一半
    
     # 限制棋盤掃描的橫座標，避免音符 bug
     if piece_x < w/2:
     board_x_start = piece_x
     board_x_end = w
     else:
     board_x_start = 0
     board_x_end = piece_x
    
     for i in range(int(h / 3), int(h * 2 / 3)):
     last_pixel = im_pixel[0, i]
     if board_x or board_y:
     break
     board_x_sum = 0
     board_x_c = 0
    
     for j in range(int(board_x_start), int(board_x_end)):
     pixel = im_pixel[j, i]
     # 修掉腦袋比下一個小格子還高的情況的 bug
     if abs(j - piece_x) < piece_body_width:
     continue
    
     # 修掉圓頂的時候一條線導致的小 bug，這個顏色判斷應該 OK，暫時不提出來
     if abs(pixel[0] - last_pixel[0]) + abs(pixel[1] - last_pixel[1]) + abs(pixel[2] - last_pixel[2]) > 10:
     board_x_sum += j
     board_x_c += 1
     if board_x_sum:
     board_x = board_x_sum / board_x_c
     last_pixel = im_pixel[board_x, i]
    
     # 從上頂點往下 +274 的位置開始向上找顏色與上頂點一樣的點，為下頂點
     # 該方法對所有純色平面和部分非純色平面有效，對高爾夫草坪面、木紋桌面、藥瓶和非菱形的碟機（好像是）會判斷錯誤
     for k in range(i+274, i, -1): # 274 取開局時最大的方塊的上下頂點距離
     pixel = im_pixel[board_x, k]
     if abs(pixel[0] - last_pixel[0]) + abs(pixel[1] - last_pixel[1]) + abs(pixel[2] - last_pixel[2]) < 10:
     break
     board_y = int((i+k) / 2)
    
     # 如果上一跳命中中間，則下個目標中心會出現 r245 g245 b245 的點，利用這個屬性彌補上一段程式碼可能存在的判斷錯誤
     # 若上一跳由於某種原因沒有跳到正中間，而下一跳恰好有無法正確識別花紋，則有可能遊戲失敗，由於花紋面積通常比較大，失敗概率較低
     for l in range(i, i+200):
     pixel = im_pixel[board_x, l]
     if abs(pixel[0] - 245) + abs(pixel[1] - 245) + abs(pixel[2] - 245) == 0:
     board_y = l+10
     break
    
     if not all((board_x, board_y)):
     return 0, 0, 0, 0
    
     return piece_x, piece_y, board_x, board_y
    
    
    def check_screenshot():
     '''
     檢查獲取截圖的方式
     '''
     global screenshot_way
     if os.path.isfile('autojump.png'):
     os.remove('autojump.png')
     if (screenshot_way < 0):
     print('暫不支援當前裝置')
     sys.exit()
     pull_screenshot()
     try:
     Image.open('./autojump.png').load()
     print('採用方式 {} 獲取截圖'.format(screenshot_way))
     except Exception:
     screenshot_way -= 1
     check_screenshot()
    
    
    def yes_or_no(prompt, true_value='y', false_value='n', default=True):
     default_value = true_value if default else false_value
     prompt = '%s %s/%s [%s]: ' % (prompt, true_value, false_value, default_value)
     i = input(prompt)
     if not i:
     return default
     while True:
     if i == true_value:
     return True
     elif i == false_value:
     return False
     prompt = 'Please input %s or %s: ' % (true_value, false_value)
     i = input(prompt)
    
    
    def main():
     '''
     主函式
     '''
     op = yes_or_no('請確保手機打開了 ADB 並連線了電腦，然後開啟跳一跳並【開始遊戲】後再用本程式，確定開始？')
     if not op:
     print('bye')
     return
     print('程式版本號：{}'.format(VERSION))
     debug.dump_device_info()
     check_screenshot()
    
     i, next_rest, next_rest_time = 0, random.randrange(3, 10), random.randrange(5, 10)
     while True:
     pull_screenshot()
     im = Image.open('./autojump.png')
     # 獲取棋子和 board 的位置
     piece_x, piece_y, board_x, board_y = find_piece_and_board(im)
     ts = int(time.time())
     print(ts, piece_x, piece_y, board_x, board_y)
     set_button_position(im)
     jump(math.sqrt((board_x - piece_x) ** 2 + (board_y - piece_y) ** 2))
     if debug_switch:
     debug.save_debug_screenshot(ts, im, piece_x, piece_y, board_x, board_y)
     debug.backup_screenshot(ts)
     i += 1
     if i == next_rest:
     print('已經連續打了 {} 下，休息 {}s'.format(i, next_rest_time))
     for j in range(next_rest_time):
     sys.stdout.write('\r程式將在 {}s 後繼續'.format(next_rest_time - j))
     sys.stdout.flush()
     time.sleep(2)
     print('\n繼續')
     i, next_rest, next_rest_time = 0, random.randrange(30, 100), random.randrange(10, 60)
     time.sleep(np.random.uniform(0.6,0.9)) # 為了保證截圖的時候應落穩了，多延遲一會兒，隨機值防 ban
    
    
    if __name__ == '__main__':
     main()
    
    
 

simple.py

    # -*- coding: utf-8 -*-
    
    import numpy as np
    import cv2
    import os
    import time
    import re
    
    # 螢幕截圖
    def pull_screenshot(path):
     os.system('adb shell screencap -p /sdcard/%s' % path)
     os.system('adb pull /sdcard/%s .' % path)
    
    # 根據x距離跳躍
    def jump(distance, alpha):
     press_time = max(int(distance * alpha), 200)
    
     cmd = 'adb shell input swipe {} {} {} {} {}'.format(bx1, by1, bx2, by2, press_time)
     os.system(cmd)
    
    screenshot = 'screenshot.png'
    alpha = 0
    bx1, by1, bx2, by2 = 0, 0, 0, 0
    chess_x = 0
    target_x = 0
    
    fix = 1.6667
    
    # 檢查解析度是否是960x540
    size_str = os.popen('adb shell wm size').read()
    if size_str:
     m = re.search(r'(\d+)x(\d+)', size_str)
     if m:
     hxw = "{height}x{width}".format(height=m.group(2), width=m.group(1))
     if hxw == "960x540":
     fix = 3.16
    
    while True:
     pull_screenshot(screenshot)
     image_np = cv2.imread(screenshot)
     image_np = cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB)
     gray = cv2.Canny(image_np, 20, 80)
    
     HEIGHT = image_np.shape[0]
     WIDTH = image_np.shape[1]
    
     bx1 = WIDTH / 2
     bx2 = WIDTH / 2
     by1 = HEIGHT * 0.785
     by2 = HEIGHT * 0.785
     alpha = WIDTH * fix
    
     # 獲取棋子x座標
     linemax = []
     for i in range(int(HEIGHT * 0.4), int(HEIGHT * 0.6)):
     line = []
     for j in range(int(WIDTH * 0.15), int(WIDTH * 0.85)):
     if image_np[i, j, 0] > 40 and image_np[i, j, 0] < 70 and image_np[i, j, 1] > 40 and image_np[i, j, 1] < 70 and image_np[i, j, 2] > 60 and image_np[i, j, 2] < 110:
     gray[i, j] = 255
     if len(line) > 0 and j - line[-1] > 1:
     break
     else:
     line.append(j)
    
     if len(line) > 5 and len(line) > len(linemax):
     linemax = line
     if len(linemax) > 20 and len(line) == 0:
     break
    
     chess_x = int(np.mean(linemax))
    
     # 獲取目標x座標
     for i in range(int(HEIGHT * 0.3), int(HEIGHT * 0.5)):
     flag = False
     for j in range(WIDTH):
     # 超過朋友時棋子上方的圖案
     if np.abs(j - chess_x) < len(linemax):
     continue
     if not gray[i, j] == 0:
     target_x = j
     flag = True
     break
     if flag:
     break
    
     # 修改檢測圖
     gray[:, chess_x] = 255
     gray[:, target_x] = 255
     # 儲存檢測圖
     cv2.imwrite('detection.png', gray)
    
     print(chess_x, target_x)
     jump(float(np.abs(chess_x - target_x)) / WIDTH, alpha)
    
     # 等棋子落穩
     time.sleep(np.random.random() + 1)
    
 

下載： [ 微信小程式跳一跳自動執行指令碼

](http://xiazai.jb51.net/201801/yuanma/pywechatjumpauto(jb51.net).rar)

更多內容大家可以參考專題 《微信跳一跳》 進行學習。

更多關於python安裝教程的文章請參考 《python各版本安裝教程》

更多精彩書單，請點選 python程式設計必備書單

領取乾貨： 零基礎入門學習python視訊教程

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援指令碼之家。