python 谷歌小恐龙自动跳跃

最新推荐文章于 2024-04-14 11:17:23 发布

i道i

最新推荐文章于 2024-04-14 11:17:23 发布

阅读量2.6k

点赞数 2

文章标签： python 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_58196051/article/details/129236398

版权

针对Cent Browser断网谷歌小恐龙，屏幕1920*1080。关闭慢速模式。

第一版

仅仅是简单的检测像素点，像素点不一样就会跳跃

大约能到700分左右，因为700分左右会变色，变色过程中由于色差问题，小恐龙可能会不停跳跃或者无视仙人掌。

你可以尝试更改andx()中的睡眠时间，set_out中的跳跃时间，或者x1,y1的初始值来优化。

from ctypes import *
import pyautogui as ui
from threading import Thread
import keyboard
import time


# 当进程启动时如果两个点不同，就会按下空格
def set_out():
    global x1, x2, y1, y2, a 
    gdi32 = windll.gdi32
    user32 = windll.user32
    # 获取句柄
    hdc = user32.GetDC(None)
    # 获取指定像素的颜色
    while a:
        c1 = gdi32.GetPixel(hdc, x1, y1)
        c2 = gdi32.GetPixel(hdc, x2, y2)
        if not c1 == c2:
            keyboard.press(' ')
            time.sleep(0.8)
            keyboard.release(' ')


# 该进程每隔一段时间使得监测点右移，适应速度
def andx():
    global a, x2
    while (a):
        time.sleep(1.35)
        x2 = x2 + 1


# 开始按下*号，获得两个检测点，
# 鼠标指向小恐龙眼睛按*号
global x1, x2, y1, y2, a
keyboard.wait('*')
x1, y1 = ui.position()
x2 = x1
y2 = y1 - 50
x1 = x1 + 85
y1 = y1 + 30
print(x1, y1, x2, y2)
t = Thread(target=set_out)  # 进程绑定
t1 = Thread(target=andx)  # 进程绑定
a = 1
keyboard.wait('+')
t.start()
t1.start()
keyboard.wait('-')
a = 0
t.join()
t1.join()

第二版

调整判定，使用两个检测区域，测定危险移动速度，再算出危险到小恐龙时间，提前跳跃

from PIL import ImageGrab  # 截屏用
import pyautogui as ui  # 获取鼠标位置
from threading import Thread  # 进程
import keyboard  # 键盘监听
import numpy as np
import time


def jump_(wait):
    # 执行线程，睡眠后按空格
    time.sleep(wait)
    keyboard.press(' ')
    time.sleep(0.2)
    keyboard.release(' ')


def set_out():
    global x, y, end_l, end_r, a
    time_r = []  # 经过右端的时间队列
    while a:
        # 获得一排像素点,二值化，并且转数组
        img = ImageGrab.grab(bbox=(end_l, y - 1, end_r, y)).convert('1')
        img = list(np.array(img)[0])
        # 开始处理数组，使得危险‘连续’
        lenimg = len(img)
        setting = img[0]  # 背景颜色
        t = True  # 背景标记避免重复膨胀
        i = 200  # 循环变量
        # '膨胀'
        while i < lenimg:
            if not img[i] == setting:  # 若与背景不同色
                if t:  # 之前是背景
                    j = 1
                    t = False  # 遇到不是背景
                    while j < 10:  # 将之前10个像素‘膨胀’
                        if not img[i - j] == setting:  # 遇到不是背景的
                            break  # 结束
                        img[i - j] = img[i]
                        j += 1
            else:  # 遇到背景
                t = True
            i += 1
        t = True  # 背景标记
        i = 200  # 循环变量
        # '腐蚀'
        while i < lenimg:  # 针对后2/3像素点
            if not img[i] == setting:  # 若与背景不同色
                if t:  # 之前是背景
                    j = 0
                    t = False
                    while j < 12 and i < lenimg:  # 将其与之后共12个像素‘腐蚀’
                        img[i] = setting
                        j += 1
                        i += 1
            else:  # 遇到背景
                t = True
            i += 1
        # 数组已经处理，对于中点和最右点区域检测
        # 让危险距离恐龙0.24s时起跳
        i = lenimg - 70  # 检测最末尾20个
        while i < lenimg - 50:
            if not img[i] == setting:  # 如果是危险
                time_r=time.time()  # 获得经过右监测点的时间
                break
            i += 1
        i = lenimg - 470  # 检测中间20个
        while i < lenimg - 450:
            if not img[i] == setting:  # 如果是危险
                time_c = time.time()  # 获得经过中间监测点的时间
                tt = time_c - time_r  # 经过两个监测点的时间差
                # v=400/tt
                # t=s/v=250*tt/400=tt * 0.625   到小恐龙的时间
                # 设定一个线程，睡眠t-0.24s后按空格
                wait = tt * 0.625 - 0.24
                if 0.15 < wait < 1.2:
                    jump = Thread(target=lambda st=wait: jump_(st))  # 跳跃线程
                    jump.start()
                break
            i += 1


np.set_printoptions(threshold=np.inf)  # 输出不省略
# 开始按下*号，获得三个检测点，
# 鼠标指向小恐龙眼睛按*号
keyboard.wait('*')
x, y = ui.position()
print(x, y)
end_l = x - 80
centre = x + 400
end_r = centre + 300
y = y + 20
# 小恐龙距离最右边700像素
t = Thread(target=set_out)  # 进程绑定
a = 1
keyboard.wait('+')
t.start()
print('自动跳越开启')
keyboard.wait('-')
a = 0
t.join()
print('自动跳越关闭')

写时意识到，根本不需要膨胀腐蚀，仙人掌十分稀疏，用不着队列，可能改版了，没有翼龙，两个监测点不如直接测速度

第三版

from PIL import ImageGrab  # 截屏用
import pyautogui as ui  # 获取鼠标位置
from threading import Thread  # 进程
import keyboard  # 键盘监听
import numpy as np
import time


def jump_(wait):
    # 执行线程，睡眠后按空格
    # print(wait)
    time.sleep(wait)
    keyboard.press(' ')
    time.sleep(0.2)
    keyboard.release(' ')


def set_out():
    global x, y, end_l, end_r, a
    peril = []  # 危险组 [[位置],[时间],]
    risk = 0
    j = 0
    while a:
        # time.sleep(0.1)
        # 获得一排像素点,二值化，并且转数组
        img = ImageGrab.grab(bbox=(end_l, y - 1, end_r, y)).convert('1')
        img = list(np.array(img)[0])
        # 开始处理数组，寻找危险位置
        lenimg = len(img)
        setting = img[0]  # 背景颜色
        i = 250  # 循环变量
        # 寻找危险位置
        while i < lenimg - 50:  # 找危险开始点
            if not img[i] == setting:  # 若与背景不同色
                risk = i  # 记录危险
                break
            i += 1
        if i == lenimg - 50:  # 这一轮没找到
            continue
        i = lenimg - 50  # 循环变量
        j = 0
        while i > risk:  # 找危险结束点，求出危险近似中点
            if not img[i] == setting:  # 若与背景不同色
                if i - risk > 120:  # 距离差距太大
                    j = 1
                else:
                    risk = (risk + i) // 2
                break
            i -= 1
        if j or risk < 300 or risk > lenimg-100:
            continue
        # 数组已经处理
        # 让危险距离恐龙0.25s时起跳
        time_1 = time.time()  # 得到时间
        if not len(peril) == 0:  # 有上一次的位置
            # 找到了，且在上一次出现位置的左边
            if peril[-1][0] > risk:
                tt = time_1 - peril[-1][1]  # 和上一次的时间差
                # v = s/tt    速度
                # t = s'/v = s'*tt/s   到小恐龙的时间
                # 设定一个线程，睡眠 t-0.25s 后按空格
                wait = (risk - 80) * tt / (peril[-1][0] - risk) - 0.25
                if 0 < wait < 1:
                    jump = Thread(target=lambda st=wait: jump_(st))  # 跳跃线程
                    jump.start()
            elif risk - peril[-1][0] < 50:  # 太近
                continue
        peril = [[risk, time_1]]


np.set_printoptions(threshold=np.inf)  # 输出不省略
# 开始按下*号，获得三个检测点，
# 鼠标指向小恐龙眼睛按*号
keyboard.wait('*')
x, y = ui.position()
print(x, y)
end_l = x - 80
centre = x + 400
end_r = centre + 300
y = y + 20
# 小恐龙距离最右边700像素
t = Thread(target=set_out)  # 进程绑定
a = 1
keyboard.wait('+')
t.start()
print('自动跳越开启')
keyboard.wait('-')
a = 0
t.join()
print('自动跳越关闭')