def init_fastscreen(self):
if fast_screencut and Multithreading({}).program_is_stopped():
from core.get_screen import ReceiveFromMinicap
self.receive_minicap = ReceiveFromMinicap(self.address)
self.receive_minicap.start()
print("Device:", self._d.serial, "快速截图已打开，测试中……")
for retry in range(3):
try:
data = self.receive_minicap.receive_img()
if data is None:
raise Exception("读取数据超过最大尝试次数")
self.fastscreencut_retry = 0
print("Device:", self._d.serial, "快速截图运行正常。")
break
except Exception as e:
self.receive_minicap.stop()
time.sleep(1)
if retry < 2:
print("Device:", self._d.serial, f"尝试重新开启快速截图...{e}")
self.receive_minicap = ReceiveFromMinicap(self.address)
self.receive_minicap.start()
else:
self.fastscreencut_retry = 3
if force_fast_screencut:
raise FastScreencutException("快速截图打开失败！")
else:
print("Device:", self._d.serial, f"快速截图打开失败！使用慢速截图。")
class BaseMixin:
"""
基础插片：包含设备信息(u2)，账户信息(account)
辅助功能：日志，静态存储
基本操作 （click,find_img,guochang,click_img,lock_img,lock_no_img，chulijiaocheng)
需要在Automator中手动初始化，传入address和account参数。
"""
def __init__(self):
self.appRunning = False
self.account = "debug"
self._d: Optional[u2.Device] = None
self.d: Optional[SafeU2Handle] = None
self.dWidth = 960
self.dHeight = 540
self.log: Optional[log_handler.pcr_log] = None
self.AR: Optional[AutomatorRecorder] = None
self.ms: Optional[moveset] = None
self.debug_screen = None # 如果debug_screen为None，则正常截图；否则，getscreen函数使用debug_screen作为读取的screen
self.last_screen = None # 每次调用getscreen会把图片暂存至last_screen
self.fastscreencut_retry = 0 # 快速截图失败次数
self.address = None
self.today_date = datetime.date.today()
self.cpu_occupy = 0
self.change_time = 0.5
self.last_screen_time = 0
self.async_juqingtiaoguo_switch = False
self.last_star = 0 # 上次战斗的星数
self._move_method = "" # 接收其它线程发送的处理方法
self._move_msg = "" # 接收其它线程发送的信息
# fastscreencap
if fast_screencut:
self.lport: Optional[int] = None
self.receive_minicap: Optional[ReceiveFromMinicap] = None
def save_last_screen(self, filename):
if self.last_screen is not None:
try:
cv2.imwrite(filename, self.last_screen)
except Exception as e:
self.log.write_log("error", f"保存最后一次截图失败：{e}")
def do_nothing(self):
# 啥事不干
self.log.write_log("info", "Do nothing.")
pass
def init_fastscreen(self):
if fast_screencut and Multithreading({}).program_is_stopped():
from core.get_screen import ReceiveFromMinicap
self.receive_minicap = ReceiveFromMinicap(self.address)
self.receive_minicap.start()
print("Device:", self._d.serial, "快速截图已打开，测试中……")
for retry in range(3):
try:
data = self.receive_minicap.receive_img()
if data is None:
raise Exception("读取数据超过最大尝试次数")
self.fastscreencut_retry = 0
print("Device:", self._d.serial, "快速截图运行正常。")
break
except Exception as e:
self.receive_minicap.stop()
time.sleep(1)
if retry < 2:
print("Device:", self._d.serial, f"尝试重新开启快速截图...{e}")
self.receive_minicap = ReceiveFromMinicap(self.address)
self.receive_minicap.start()
else:
self.fastscreencut_retry = 3
if force_fast_screencut:
raise FastScreencutException("快速截图打开失败！")
else:
print("Device:", self._d.serial, f"快速截图打开失败！使用慢速截图。")
def init_device(self, address):
"""
device: 如果是 USB 连接，则为 adb devices 的返回结果；如果是模拟器，则为模拟器的控制 URL 。
"""
self.appRunning = False
self.address = address
if address != "debug":
self._d = safe_u2_connect(address)
self.d = SafeU2Handle(self._d)
self.init_fastscreen()
def init_account(self, account, rec_addr="users"):
self.account = account
self.log = log_handler.pcr_log(account) # 初始化日志
self.AR = AutomatorRecorder(account, rec_addr)
def init(self, address, account, rec_addr="users"):
# 兼容
self.init_device(address)
self.init_account(account, rec_addr)
def force_kill(self):
"""
强制结束Automator
:return:
"""
self.send_move_method("forcekill", "")
@staticmethod
def _get_at(at):
# at参数的转换
if isinstance(at, PCRelement):
return at.at
else:
return at
def send_move_method(self, method, msg):
"""
给主线程发送一条消息
:param method: 处理方法
restart: 重启
:param msg: 附带信息
restart: 重启时显示的错误提示
"""
while self._move_method != "":
pass
self._move_msg = msg
self._move_method = method
while self._move_method != "":
pass
def _move_check(self):
"""
作为最小执行单元，接收暂停、退出等信息
:return: False：无影响 True：造成影响
"""
try:
from automator_mixins._async import block_sw
if block_sw == 1:
print("脚本暂停中~")
while block_sw == 1:
from automator_mixins._async import block_sw
time.sleep(1)
return True
except Exception as error:
print('暂停-错误:', error)
return True
if self._move_method == "restart":
self._move_method = ""
raise Exception(self._move_msg)
if self._move_method == "forcekill":
self._move_method = ""
raise ForceKillException()
def click_img(self,
screen,
img,
threshold=0.84,
at=None,
pre_delay=0.,
post_delay=0.,
method=cv2.TM_CCOEFF_NORMED):
"""
try to click the img
:param screen:
:param threshold:
:param img:
:return: success
"""
self._move_check()
at = self._get_at(at)
position = UIMatcher.img_where(screen, img, threshold, at, method)
if position:
self.click(*position, pre_delay, post_delay)
return True
else:
return False
def click(self, *args, pre_delay=0., post_delay=0., **kwargs):
"""
点击函数
2020-07-28 TheAutumnOfRice:把x,y参数换程args参数以遍兼容各种点击类型
1. 若args为数字的x,y，则点击该位置。
如:self.click(100,200)
2. 若args为PCRelement类型（见core.constant），则：
点击其坐标
:param pre_delay: 前置延时
:param post_delay: 后置延时
:return: True
"""
self._move_check()
time.sleep(pre_delay)
if len(args) >= 2 and isinstance(args[0], (int, float)) and isinstance(
args[1], (int, float)):
# (x,y)型：点击坐标
x = args[0]
y = args[1]
self.d.click(x, y)
time.sleep(post_delay)
return True
elif len(args) == 1 and isinstance(args[0], PCRelement):
# 点击一个PCRelement元素
pe = args[0]
self.d.click(pe.x, pe.y)
time.sleep(post_delay)
return True
@staticmethod
def _get_img_at(img, at):
at = BaseMixin._get_at(at)
if isinstance(img, PCRelement):
if at is None:
at = img.at
img = img.img
return img, at
def is_exists(self,
img,
threshold=0.84,
at=None,
screen=None,
is_black=False,
black_threshold=1500,
method=cv2.TM_CCOEFF_NORMED):
"""
判断一个图片是否存在。
:param black_threshold: 判断暗点的阈值
:param is_black: 是否判断为暗色图片（多用于检测点击按钮后颜色变暗）灰色返回Ture,默认需要配合at，否则自行调整阈值
:param method:
:param img:
一个字符串，表示图片的地址；或者为PCRelement类型。
当img为PCRelement时，如果at参数为None，则会使用img.at。
:param threshold: 判定阈值
:param at: 搜素范围
:param screen: 若设置为None，则重新截图；否则使用screen为截图
:return: 是否存在
"""
if screen is None:
screen = self.getscreen()
img, at = self._get_img_at(img, at)
return UIMatcher.img_where(screen, img, threshold, at, method,
is_black, black_threshold) is not False
def img_prob(self, img, at=None, screen=None, method=cv2.TM_CCOEFF_NORMED):
"""
返回一个图片存在的阈值
通过比较两幅图片的阈值大小可以分辨它“更”是什么图
:param img:
一个字符串，表示图片的地址；或者为PCRelement类型。
当img为PCRelement时，如果at参数为None，则会使用img.at。
:param at: 搜素范围
:param screen: 若设置为None，则重新截图；否则使用screen为截图
:return: 是否存在
"""
if screen is None:
screen = self.getscreen()
img, at = self._get_img_at(img, at)
return UIMatcher.img_prob(screen, img, at, method)
def img_where_all(self,
img,
threshold=0.9,
at=None,
screen=None,
method=cv2.TM_CCOEFF_NORMED):
"""
返回一个图片所有的位置
:param img:
一个字符串，表示图片的地址；或者为PCRelement类型。
当img为PCRelement时，如果at参数为None，则会使用img.at。
:param threshold: 阈值
:param at: 搜素范围
:param screen: 若设置为None，则重新截图；否则使用screen为截图
:return: list[(x,y,at)]
"""
if screen is None:
screen = self.getscreen()
img, at = self._get_img_at(img, at)
return UIMatcher.img_all_where(screen, img, threshold, at, method)
def img_equal(self, img1, img2, at=None, similarity=0.01) -> float:
"""
输出两张图片对应像素相似程度
要求两张图片大小一致
:return: 相似度 0~1
"""
if isinstance(img1, str):
img1 = cv2.imread(img1)
if isinstance(img2, str):
img2 = cv2.imread(img2)
at = self._get_at(at)
if at is not None:
img1 = UIMatcher.img_cut(img1, at)
img2 = UIMatcher.img_cut(img2, at)
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) / 255
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY) / 255
eqt = np.sum(np.abs(img1 - img2) < similarity) / img1.size
if debug:
print("EQT:", eqt)
return eqt
def wait_for_stable(self,
delay=0.5,
threshold=0.2,
similarity=0.001,
max_retry=0,
at=None,
screen=None):
"""
等待动画结束,画面稳定。此时相邻两帧的相似度大于threshold
:param similarity: 近似程度0~1
:param delay: 每次刷新间隔。
:param max_retry: 最大重试次数
:param at: 缩小范围
:param screen: 设置为None时，参照图截图获得，否则参照图
:return: True：动画结束 False：动画未结束
"""
sc = self.getscreen() if screen is None else screen
retry = 0
at = self._get_at(at)
while retry < max_retry or max_retry == 0:
self._move_check()
retry += 1
time.sleep(delay)
sc2 = self.getscreen()
value = self.img_equal(sc, sc2, at, similarity)
if debug:
print("Stable : ", value, " >? ", threshold)
if value > threshold:
return True
sc = sc2
return False
def wait_for_change(self,
delay=0.5,
threshold=0.10,
similarity=0.01,
max_retry=0,
at=None,
screen=None):
"""
等待画面跳转变化，此时尾帧与头帧的相似度小于threshold
:param similarity: 近似程度0~1
:param delay: 每次刷新间隔。
:param max_retry: 最大重试次数
:param at: 缩小范围
:param screen: 设置为None时，参照图截图获得，否则参照图
:return: True：动画改变 False：动画未改变
"""
sc = self.getscreen() if screen is None else screen
retry = 0
at = self._get_at(at)
while retry < max_retry or max_retry == 0:
self._move_check()
retry += 1
time.sleep(delay)
sc2 = self.getscreen()
value = self.img_equal(sc, sc2, at, similarity)
if debug:
print("Stable : ", value, " <? ", threshold)
if value < threshold:
return True
return False
def wait_for_loading(self, screen=None, delay=0.5, timeout=30):
"""
等待黑屏loading结束
:param screen: 设置为None时，截图，否则使用screen
:param delay: 检测间隔
:param timeout: 超过timeout，报错
Add 2020-08-15: 增加对Connect的检测。
"""
time.sleep(delay)
sc = self.getscreen() if screen is None else screen
last_time = time.time()
while True:
self._move_check()
if self.is_exists(img='img/connecting.bmp',
at=(748, 20, 931, 53),
screen=sc):
time.sleep(delay)
sc = self.getscreen()
continue
sc_cut = UIMatcher.img_cut(sc, MAIN_BTN["loading_left"].at)
if not (sc_cut == 1).all():
break
if time.time() - last_time > timeout:
raise Exception("Loading 超时！")
time.sleep(delay)
sc = self.getscreen()
def check_dict_id(self,
id_dict,
screen=None,
max_threshold=0.8,
diff_threshold=0.05):
"""
识别不同图的编号，比较其概率
:param id_dict: 字典，{key:PCRElement}，表示{编号:图片}
:param screen: 设置为None时，第一次重新截图
:param max_threshold: 最大阈值，获得图片最大概率必须超过max_threshold
:param diff_threshold: 相差阈值，第一大的概率和第二大的概率差必须超过diff_threshold
:return:
None: 识别失败
Else: 识别的key
"""
sc = self.getscreen() if screen is None else screen
pdict = {}
for i, j in id_dict.items():
pdict[i] = self.img_prob(j, screen=sc)
tu = max(pdict, key=lambda x: pdict[x])
l = sorted(pdict.values(), reverse=True)
if debug:
print(tu)
print(l)
if l[0] < max_threshold or l[0] - l[1] < diff_threshold:
return None
else:
return tu
def run_func(self, th_name, a, fun, async_sexitflag=False):
if async_sexitflag:
th_name.exit()
pass
else:
self.do(a, fun)
def do(self, a, fun):
# 自定义，在此定义你要运行的参数
getattr(asyncio, 'run')(fun)
# getattr获取asyncio中run对象，然后进行调用
# 凄凄惨惨的替代eval这类危险的函数
pass
def c_async(self, a, account, fun, sync=False, async_sexitflag=False):
_async_infodic = {
'a': a,
'account': account,
'fun': fun,
'"pack_Thread-" + str(account)': "pack_Thread-" + str(account),
'async_sexitflag': async_sexitflag
}
th = Multithreading(kwargs=_async_infodic)
# print(threading.currentThread().ident)
# id, name
th.start()
if sync:
# 线程同步异步开关，True/False
th.join()
# 线程等待，执行完才能进入下一个线程
pass
else:
# 异步，推荐
pass
pass
def getscreen(self, filename=None):
"""
包装了self.d.screenshot
如果self.debug_screen为None，则
:return: 截图的opencv格式
"""
# 如果debug_screen为None，则正常截图；
# 否则，getscreen函数使用debug_screen作为读取的screen
if self.debug_screen is None:
if fast_screencut and self.fastscreencut_retry < 3:
try:
data = self.receive_minicap.receive_img()
if data is None:
raise Exception("读取数据超过最大尝试次数")
# 改用内存缓存
self.last_screen = data
# 如果传入了文件路径参数，则保存文件
if filename is not None:
cv2.imwrite(filename, self.last_screen)
self.fastscreencut_retry = 0
except Exception as e:
if force_fast_screencut:
raise FastScreencutException(*e.args)
else:
self.log.write_log("warning", f"快速截图出错 {e}， 使用低速截图")
self.fastscreencut_retry += 1
if self.fastscreencut_retry == 3:
self.log.write_log("error", f"快速截图连续出错3次，关闭快速截图。")
self.receive_minicap.stop()
self.last_screen = self.d.screenshot(filename,
format="opencv")
else:
self.last_screen = self.d.screenshot(filename, format="opencv")
self.last_screen_time = time.time()
return UIMatcher.AutoRotateClockWise90(self.last_screen)
else:
if isinstance(self.debug_screen, str):
return cv2.imread(self.debug_screen)
else:
return self.debug_screen
def find_img(self,
img,
at=None,
alldelay=0.5,
ifclick=None,
ifbefore=0.5,
ifdelay=1,
elseclick=None,
elsedelay=0.5,
retry=0):
"""
前身：_lock_img
匹配图片并点击指定坐标
Parameters:
img (str): 要匹配的图片目录
at (:tuple: `(int: 左上x, int: 左上y, int: 右下x, int: 右下y)`): 查找范围
ifbefore (float): 识别成功后延迟点击时间
ifclick (:list: ``): 在识别到图片时要点击的坐标，列表，列表元素为坐标如(1,1)
ifdelay: 上述点击后延迟的时间
elseclick: 在找不到图片时要点击的坐标，列表，列表元素为坐标如(1,1)
elsedelay: 上述点击后延迟的时间
retry: elseclick最多点击次数, `0为无限次`
Returns:
success (bool): 是否在retry次内点击成功
"""
# 2020-07-12 Add: 增加了ifclick,elseclick参数对Tuple的兼容性
# 2020-07-14 Add: added retry
if elseclick is None:
elseclick = []
if ifclick is None:
ifclick = []
if type(ifclick) is tuple:
ifclick = [ifclick]
if type(elseclick) is tuple:
elseclick = [elseclick]
inf_attempt = True if retry == 0 else False
attempt = 0
while inf_attempt or attempt < retry:
self._move_check()
screen_shot = self.getscreen()
if UIMatcher.img_where(screen_shot, img, at=at):
# 成功匹配图片
for clicks in ifclick:
self.click(clicks[0],
clicks[1],
pre_delay=ifbefore,
post_delay=ifdelay)
break
for clicks in elseclick:
self.click(clicks[0], clicks[1], post_delay=elsedelay)
time.sleep(alldelay)
attempt += 1
return True if inf_attempt or attempt < retry else False
def guochang(self, screen_shot, template_paths, suiji=1):
# suji标号置1, 表示未找到时将点击左上角, 置0则不点击
# 输入截图, 模板list, 得到下一次操作
# 2020-08-08 建议弃用该函数。
screen_shot = screen_shot
template_paths = template_paths
active_path = UIMatcher.imgs_where(screen_shot, template_paths)
if active_path:
# print(active_path)
if 'img/juqing/tiaoguo_1.bmp' in active_path:
x, y = active_path['img/juqing/tiaoguo_1.bmp']
self.click(x, y)
else:
for name, (x, y) in active_path.items():
# print(name)
self.click(x, y)
time.sleep(0.5)
else:
if suiji:
# print('未找到所需的按钮,将点击左上角')
self.click(0.1 * self.dWidth, 0.1 * self.dHeight)
else:
# print('未找到所需的按钮,无动作')
pass
def lock_fun(self,
RTFun,
*args,
ifclick=None,
ifbefore=0.,
ifdelay=1.,
elseclick=None,
elsedelay=0.5,
alldelay=0.5,
retry=0,
is_raise=False,
timeout=None,
elseafter=0.,
**kwargs):
"""
任意方法锁定
@RTFun 锁定的函数
返回False，锁定失败
返回其它，锁定成功，返回值为函数返回值
"""
if elseclick is None:
elseclick = []
if ifclick is None:
ifclick = []
if type(ifclick) is not list:
ifclick = [ifclick]
if type(elseclick) is not list:
elseclick = [elseclick]
attempt = 0
lasttime = time.time()
ec_time = 0 # else click time: 上次点elseclick的时间
if timeout is None:
timeout = lockimg_timeout
while True:
self._move_check()
lasttime = time.time()
if debug:
print("FUN:", RTFun)
print("FUNOUT:", RTFun())
out = RTFun(*args, **kwargs)
if debug:
print("OUT:", out)
if out:
if ifclick != []:
for clicks in ifclick:
time.sleep(ifbefore)
self.click(clicks[0], clicks[1], post_delay=elseafter)
time.sleep(ifdelay)
return out
if ec_time == 0:
# 第一次：必点
# 此后每次等待elsedelay
ec_time = time.time() - elsedelay
if time.time() - ec_time >= elsedelay:
if elseclick != []:
for clicks in elseclick:
self.click(clicks[0], clicks[1], post_delay=elseafter)
attempt += 1
ec_time = time.time()
time.sleep(alldelay)
if retry != 0 and attempt > retry:
return False
if timeout != 0 and time.time() - lasttime > timeout:
if is_raise:
if disable_timeout_raise:
continue
raise Exception("lock_fun 超时！")
return False
def _lock_img(self,
img: Union[PCRelement, str, dict, list],
ifclick=None,
ifbefore=0.,
ifdelay=1.,
elseclick=None,
elsedelay=0.5,
alldelay=0.5,
retry=0,
side_check=None,
at=None,
is_raise=False,
lock_no=False,
timeout=None,
method=cv2.TM_CCOEFF_NORMED,
threshold=0.84,
elseafter=0.):
"""
@args:
img:要匹配的图片目录
2020-07-31: TheAutumnOfRice Add: img可以传入dict类型
{PCRElement:return_value}
或者：
{(img,at):return_value}
此时，at参数不起作用。
2020-08-06： TheAutumnOfRice Add: img可以传入list类型
[PCRElement]或者[(img,at)]
此时，每一个找到的PCRElement，都会对应True
2020-07-28：TheAutumnOfRice Add: img支持兼容PCRelement格式
传入PCRelement后,自动填充img和at。
如果PCRelement含有at属性而外部设置了at，以lockimg的参数为准
ifbefore:识别成功后延迟点击时间
ifclick:在识别到图片时要点击的坐标，列表，列表元素为坐标如(1,1)
ifdelay:上述点击后延迟的时间
elseclick:在找不到图片时要点击的坐标，列表，列表元素为坐标如(1,1)
elsedelay:上述点击后延迟的时间
retry:elseclick最多点击次数，0为无限次
is_raise: 失败时，是否弹出错误
lock_no: False: lock_img True: lock_no_img
timeout: 设置为None时，使用pcr_config中的lockimg_timeout，否则用自己的。
side_check：传入字符串然后调用字符串里边的基于_base的函数方法
elseafter: 点击elseclick后等待的时间
@pcr_config:
lockimg_timeout: 设置为0时，不做超时处理；否则，如果超过该时间，报错
@return:是否在retry次内点击成功
"""
# 2020-07-12 Add: 增加了ifclick,elseclick参数对Tuple的兼容性
# 2020-07-14 Add: added retry
# 2020-07-30 Add: 整合了lockimg 和 lock_no_img，增加timeout
# 2020-08-01 Add: 取消了elseclick两个click之间的间隔，elsedelay表
# 示elseclick操作之后的等待时间，该时间内会一直检测。
# 2020-08-01 Add: 增加了局部timeout参数
# 2020-08-06 Add: img可以传入list了
# 2020-8-19 Add:暂停+方法调用
if elseclick is None:
elseclick = []
if ifclick is None:
ifclick = []
if type(ifclick) is not list:
ifclick = [ifclick]
if type(elseclick) is not list:
elseclick = [elseclick]
if isinstance(img, list):
tmp = img
img = {}
for i in tmp:
img[i] = True
if not isinstance(img, dict):
img = {(img, at): True}
attempt = 0
lasttime = time.time()
ec_time = 0 # else click time: 上次点elseclick的时间
if timeout is None:
timeout = lockimg_timeout
while True:
screen_shot = self.getscreen()
# 方法配对，如有需要可以加个验证side_check是否合法
if side_check is not None:
# 感谢Sisphyus大佬分享的文章
# side_check理论支持调用_base的所有子类方法
# _method = getattr(self, side_check)
determine = side_check(screen_shot)
if determine:
lasttime = time.time()
if self._move_check():
lasttime = time.time()
for i, j in img.items():
if not isinstance(i, PCRelement):
_img, _at = self._get_img_at(i[0], i[1])
else:
_img, _at = self._get_img_at(i, None)
if self.is_exists(_img,
at=_at,
screen=screen_shot,
method=method,
threshold=threshold) is not lock_no:
if ifclick != []:
for clicks in ifclick:
time.sleep(ifbefore)
self.click(clicks[0],
clicks[1],
post_delay=elseafter)
time.sleep(ifdelay)
return j
if ec_time == 0:
# 第一次：必点
# 此后每次等待elsedelay
ec_time = time.time() - elsedelay
if time.time() - ec_time >= elsedelay:
if elseclick != []:
for clicks in elseclick:
self.click(clicks[0], clicks[1], post_delay=elseafter)
attempt += 1
ec_time = time.time()
time.sleep(alldelay)
if retry != 0 and attempt > retry:
return False
if timeout != 0 and time.time() - lasttime > timeout:
if is_raise:
if disable_timeout_raise:
continue
raise Exception("%s——lock_img 超时！" % img)
return False
def lock_img(self,
img,
ifclick=None,
ifbefore=0.,
ifdelay=1.,
elseclick=None,
elsedelay=2.,
alldelay=0.5,
retry=0,
at=None,
is_raise=True,
timeout=None,
method=cv2.TM_CCOEFF_NORMED,
threshold=0.84,
side_check=None,
elseafter=0.):
"""
锁定图片，直到该图出现。
图片出现后，点击ifclick；未出现，点击elseclick
"""
return self._lock_img(img,
ifclick=ifclick,
ifbefore=ifbefore,
ifdelay=ifdelay,
elseclick=elseclick,
elsedelay=elsedelay,
alldelay=alldelay,
retry=retry,
at=at,
is_raise=is_raise,
lock_no=False,
timeout=timeout,
method=method,
threshold=threshold,
side_check=side_check,
elseafter=elseafter)
def lock_no_img(self,
img,
ifclick=None,
ifbefore=0.,
ifdelay=1.,
elseclick=None,
elsedelay=2.,
alldelay=0.5,
retry=0,
at=None,
is_raise=True,
timeout=None,
method=cv2.TM_CCOEFF_NORMED,
threshold=0.84,
side_check=None,
elseafter=0.): # 锁定指定图像
"""
锁定图片，直到该图消失
图片消失后，点击ifclick；未消失，点击elseclick
"""
return self._lock_img(img,
ifclick=ifclick,
ifbefore=ifbefore,
ifdelay=ifdelay,
elseclick=elseclick,
elsedelay=elsedelay,
alldelay=alldelay,
retry=retry,
at=at,
is_raise=is_raise,
lock_no=True,
timeout=timeout,
method=method,
threshold=threshold,
side_check=side_check,
elseafter=elseafter)
def click_btn(self,
btn: PCRelement,
elsedelay=8.,
timeout=30.,
wait_self_before=False,
until_appear: Optional[Union[PCRelement, dict, list]] = None,
until_disappear: Optional[Union[str, PCRelement, dict,
list]] = "self",
retry=0,
is_raise=True,
method=cv2.TM_CCOEFF_NORMED,
elseafter=None,
side_check=None):
"""
稳定的点击按钮函数，合并了等待按钮出现与等待按钮消失的动作
:param side_check: 检测
:param retry: 尝试次数,少用
:param btn: PCRelement类型，要点击的按钮
:param elsedelay: 尝试点击按钮后等待响应的间隔
:param timeout: lockimg和lock_no_img所用的超时参数
:param wait_self_before: 是否等待本按钮出现，再进行点击
:param until_appear: 是否在点击后等待该元素出现，再返回
设置为None（默认）时不等待按钮出现
设置为PCRelement的时候，检测该元素是否出现，出现则返回
:param until_disappear: 是否在点击后等待该元素消失，再返回
设置为None时不等待按钮消失
设置为"self"（默认）时等待按钮自己消失
设置为PCRelement的时候，检测该元素是否消失
若指定元素没有消失，则每过elsedelay的时长点击一次按钮
（until_disappear,until_appear不要同时使用）
:param is_raise:
是否报错。设置为False时，匹配失败，返回False
:param method:
用于lockimg的方法
:param elseafter:
默认值None，此时，若条件为until_disappear="self"，则设置为0.8，否则为0.
点击之后的等待时间。
"""
r = 0
if isinstance(until_disappear, str):
assert until_disappear == "self"
if wait_self_before is True:
r = self.lock_img(btn,
timeout=timeout,
retry=retry,
is_raise=is_raise,
method=method,
side_check=side_check)
if until_disappear is None and until_appear is None:
self.click(btn,
post_delay=0.5) # 这边不加延迟，点击的波纹会影响到until_disappear自己
else:
if until_appear is not None:
r = self.lock_img(
until_appear,
elseclick=btn,
elsedelay=elsedelay,
timeout=timeout,
retry=retry,
is_raise=is_raise,
method=method,
elseafter=0 if elseafter is None else elseafter,
side_check=side_check)
elif until_disappear == "self":
r = self.lock_no_img(
btn,
elseclick=btn,
elsedelay=elsedelay,
timeout=timeout,
retry=retry,
is_raise=is_raise,
method=method,
elseafter=0.8 if elseafter is None else elseafter,
side_check=side_check)
elif until_disappear is not None:
r = self.lock_no_img(
until_disappear,
elseclick=btn,
elsedelay=elsedelay,
timeout=timeout,
retry=retry,
is_raise=is_raise,
method=method,
elseafter=0 if elseafter is None else elseafter,
side_check=side_check)
return r
def chulijiaocheng(self, turnback="shuatu"): # 处理教程, 最终返回刷图页面
"""
这个处理教程函数是给chushihua.py用的
有引导点引导
有下一步点下一步
有主页点主页
有圆menu就点跳过，跳过
有跳过点跳过
都没有就点边界点
# 有取消点取消
:turnback:
shuatu: 返回刷图页面
None: 不返回任何页面
:return:
"""
count = 0 # 出现主页的次数
while True:
screen_shot_ = self.getscreen()
num_of_white, _, x, y = UIMatcher.find_gaoliang(screen_shot_)
if num_of_white < 77000:
try:
self.click(x * self.dWidth, y * self.dHeight + 20)
except:
pass
time.sleep(1)
continue
if UIMatcher.img_where(screen_shot_,
'img/liwu.bmp',
at=(891, 413, 930, 452)):
count += 1
if count > 2:
break
time.sleep(1)
continue
elif UIMatcher.img_where(screen_shot_, 'img/jiaruhanghui.jpg'):
break
elif self.click_img(screen_shot_, 'img/xiayibu.jpg'):
time.sleep(2)
elif self.click_img(screen_shot_,
'img/niudan_jiasu.jpg',
at=(700, 0, 960, 100)):
pass
elif self.click_img(screen_shot_,
'img/wuyuyin.jpg',
at=(450, 355, 512, 374)):
time.sleep(3)
elif self.click_img(screen_shot_, 'img/juqing/tiaoguo_2.bmp'):
time.sleep(3)
elif self.click_img(screen_shot_,
'img/zhuye.jpg',
at=(46, 496, 123, 537)):
pass
elif self.click_img(screen_shot_,
'img/juqing/caidanyuan.bmp',
at=(898, 23, 939, 62)):
time.sleep(0.7)
self.click(804, 45)
time.sleep(0.7)
self.click(593, 372)
time.sleep(2)
elif UIMatcher.img_where(screen_shot_, 'img/qianwanghuodong.bmp'):
for _ in range(3):
self.click(390, 369)
time.sleep(1)
else:
self.click(1, 100)
count = 0
time.sleep(1)
if turnback == "shuatu":
# 返回冒险
self.click(480, 505)
time.sleep(2)
self.lock_img('img/zhuxianguanqia.jpg',
elseclick=[(480, 513), (390, 369)],
elsedelay=0.5)
while True:
screen_shot_ = self.getscreen()
if UIMatcher.img_where(screen_shot_,
'img/zhuxianguanqia.jpg',
at=(511, 286, 614, 314)):
self.click(562, 253)
time.sleep(0.5)
else:
break
time.sleep(3)
while True:
screen_shot_ = self.getscreen()
if UIMatcher.img_where(screen_shot_,
'img/normal.jpg',
at=(660, 72, 743, 94)):
break
self.click(704, 84)
time.sleep(0.5)
def task_start(self):
# 标记这个用户开始重新刷图了
d = self.AR.get_run_status()
d["finished"] = False
d["current"] = "..."
self.AR.set_run_status(d)
def task_finished(self):
# 标记这个用户已经刷完了图
d = self.AR.get_run_status()
d["finished"] = True
self.AR.set_run_status(d)
def task_current(self, title):
# 标记这个用户当前正在进行的项目
d = self.AR.get_run_status()
d["current"] = title
self.AR.set_run_status(d)
def task_error(self, error):
# 标记某一项错误，并停止刷图
d = self.AR.get_run_status()
d["finished"] = True
d["error"] = error
self.AR.set_run_status(d)
def juqing_kkr(self, screen_shot=None):
"""
处理剧情+剧情版的可可萝
:return:
"""
if screen_shot is None:
screen_shot = self.getscreen()
if self.is_exists(JUQING_BTN["caidanyuan"], screen=screen_shot):
self.click_btn(JUQING_BTN["caidanyuan"],
wait_self_before=True,
until_appear=JUQING_BTN["tiaoguo_1"]) # 菜单
self.click_btn(JUQING_BTN["tiaoguo_1"],
until_appear=JUQING_BTN["tiaoguo_2"]) # 跳过
self.click_btn(JUQING_BTN["tiaoguo_2"],
until_disappear=JUQING_BTN["tiaoguo_2"]) # 蓝色跳过
return True
elif self.is_exists(img='img/kekeluo.bmp',
at=(181, 388, 384, 451),
screen=screen_shot):
# 防妈骑脸
self.lock_no_img('img/kekeluo.bmp',
elseclick=[(1, 1)],
at=(181, 388, 384, 451))
return True
return False
def right_kkr(self, screen=None):
"""
处理提示kkr。一般在右边。
处理方法：点屏幕
:param screen:
"""
flag = False
if screen is None:
screen = self.getscreen()
cnt = 0
while self.is_exists(MAIN_BTN["right_kkr"], screen=screen):
self.click(1, 1, post_delay=1)
flag = True
cnt += 1
if cnt >= 10:
raise Exception("点了10次，可可罗依然没有消失！")
screen = self.getscreen()
return flag
def phone_privacy(self):
"""
2020/7/10
模拟器隐私函数
'高'匿名 防记录(
By：CyiceK
:return:
"""
def luhn_residue(digits):
return sum(
sum(divmod(int(d) * (1 + i % 2), 10))
for i, d in enumerate(digits[::-1])) % 10
def _get_imei(n):
part = ''.join(str(random.randrange(0, 9)) for _ in range(n - 1))
res = luhn_residue('{}{}'.format(part, 0))
return '{}{}'.format(part, -res % 10)
# print("》》》匿名开始《《《", self.address)
tmp_rand = []
tmp_rand = random.sample(range(1, 10), 3)
phone_model = {
1: 'LIO-AN00',
2: 'TAS-AN00',
3: 'TAS-AL00',
4: 'AUSU-AT00',
5: 'AAA-SN00',
6: 'GMI1910',
7: 'G-OXLPix',
8: 'AM-1000',
9: 'G7',
}
phone_manufacturer = {
1: 'HUAWEI',
2: 'MEIZU',
3: 'XIAOMI',
4: 'OPPO',
5: 'VIVO',
6: 'MOTO',
7: 'GooglePix',
8: 'Redmi',
9: 'LG',
}
os.system('cd adb & adb -s %s shell setprop ro.product.model %s' %
(self.address, phone_model[tmp_rand[0]]))
os.system(
'cd adb & adb -s %s shell setprop ro.product.manufacturer %s' %
(self.address, phone_manufacturer[tmp_rand[1]]))
os.system('cd adb & adb -s %s shell setprop phone.imei %s' %
(self.address, _get_imei(15)))
os.system('cd adb & adb -s %s shell setprop ro.product.name %s' %
(self.address, phone_model[tmp_rand[2]]))
os.system('cd adb & adb -s %s shell setprop phone.imsi %s' %
(self.address, _get_imei(15)))
os.system('cd adb & adb -s %s shell setprop phone.linenum %s' %
(self.address, _get_imei(11)))
os.system('cd adb & adb -s %s shell setprop phone.simserial %s' %
(self.address, _get_imei(20)))