| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663 |
- """
- ╔══════════════════════════════════════════════════════════════════════════════════╗
- ║ battle_wait.py 调用链地图 ║
- ╚══════════════════════════════════════════════════════════════════════════════════╝
- 装饰器双层栈(任务级,配置保存在当前上下文)
- ───────────────────────────────────────────────────────────────────
- @battle_wait_options(excludes=[...]) ← 覆盖 options
- @battle_wait_strategy(success='activity') ← 覆盖 plan
- ↓
- script_task.battle_wait()
- ↓
- ┌─────────────────────────────────────────────────────────┐
- │ battle_wait_options.__call__.inner │
- │ options → pub.options │
- │ finally: 还原上下文 options │
- └───────────────────────────┬─────────────────────────────┘
- ↓
- ┌─────────────────────────────────────────────────────────┐
- │ battle_wait_strategy.__call__.inner │
- │ current_plan = deepcopy(当前上下文或装饰器 plan).override(kwargs) │
- │ runtime.reset_per_battle() ← 每场新状态 │
- │ runtime.update_options() ← 按事件切片到各 pri │
- └───────────────────────────┬─────────────────────────────┘
- ↓
- ┌─────────────────────────────────────────────────────────┐
- │ battle_wait_with_strategy(plan) │
- │ │
- │ setup hook ──────────────────────── run 一次 │
- │ hook_enabled = sequence events − {completion} │
- │ │
- │ ┌─── while True ─────────────────────────────────┐ │
- │ │ screenshot() │ │
- │ │ for handler in sequence顺序: │ │
- │ │ if event not in hook_enabled: skip │ │
- │ │ result = handler() ──┐ │ │
- │ │ ↓ │ │ │
- │ │ DONE ────────────────┤ 结束循环 │ │
- │ │ CONTINUE ──→ 下一个 handler │ │
- │ │ │ │
- │ │ success/failure 结算后: │ │
- │ │ per_battle['success'] = BattleResult.X │ │
- │ │ enable=('completion',) ← completion 开门 │ │
- │ └───────────────────────────────────────────────────┘ │
- │ │
- │ return per_battle['success'] == BattleResult.SUCCESS │
- └─────────────────────────────────────────────────────────┘
- ┌──────────────────── Hook 调用 ────────────────────────────┐
- │ BattleWait.__new__ 遍历 MRO, _bw_* → runtime 包装 │
- │ handler() │
- │ → runtime.__call__(owner) │
- │ → func(owner, pub=pub_ctx, pri=pri_ctx[hook_name]) │
- └───────────────────────────────────────────────────────────────┘
- ┌──────────────────── 数据流 ─────────────────────────────────┐
- │ │
- │ battle_wait_options.current() (默认值 + 装饰器 + with) │
- │ ↓ pub.options = 上面整个 │
- │ ↓ pri[hook].options = 按事件名切片 │
- │ │
- │ pub (全局) pri (每个 hook 各一份) │
- │ ├─ cross ├─ cross │
- │ ├─ per_task ├─ per_task │
- │ ├─ per_battle ├─ per_battle │
- │ │ ├─ success │ │
- │ │ └─ hook_enabled │ │
- │ └─ options └─ options(本事件切片) │
- │ │
- │ 生命周期: │
- │ reset_per_task runtime 首次遇到新 task_owner │
- │ reset_per_battle 每次 battle_wait_strategy.__call__ │
- └─────────────────────────────────────────────────────────────┘
- """
- import random
- import time
- import math
- import difflib
- from copy import deepcopy
- from functools import wraps, update_wrapper
- from contextvars import ContextVar
- from dataclasses import dataclass, field, fields
- from typing import TypeVar, ParamSpec, Callable
- from enum import Enum, auto
- from cached_property import cached_property
- from module.logger import logger
- from module.base.timer import Timer
- from module.atom.click import RuleClickExclude
- from module.atom.image import RuleImage
- from module.base.utils import get_color, color_similar
- from tasks.base_task import BaseTask
- from tasks.Component.GeneralBattle.assets import GeneralBattleAssets
- from tasks.Component.GeneralBattle.config_general_battle import GreenMarkType, GreenMarkEnum
- P = ParamSpec('P')
- T = TypeVar('T')
- class HookSignal(Enum):
- CONTINUE = auto() # 无事发生
- BUSY = auto() # 处理了,继续
- DONE = auto() # 流程结束
- class BattleResult(Enum):
- SUCCESS = auto()
- FAILURE = auto()
- # ─── 默认值常量 ───────────────────────────────────
- # 战斗 hook 事件列表 & 默认调用顺序
- _HOOKS_DEFAULT: tuple[str, ...] = (
- 'setup', 'completion', 'interrupt', 'prepare', 'preset', 'green', 'red', 'echo', 'success', 'failure', 'idle',
- )
- _SEQUENCE_DEFAULT: str = 'completion > interrupt > prepare > preset > green > red > echo > success > failure >'
- # 跨任务/跨战斗状态的初始
- @dataclass
- class PerTaskState:
- """跨任务状态, 单个任务全程共享, reset_per_task 时重建"""
- count: int = 0
- @dataclass
- class PerBattleState:
- """跨战斗状态, 每场战斗独立, reset_per_battle 时重建"""
- success: BattleResult = BattleResult.FAILURE
- hook_enabled: set = field(default_factory=lambda: set(_HOOKS_DEFAULT) - {'completion'})
- # 每个 hook 事件的 options 数据类: pri[hook].options 就是这个实例。
- # 按 event 建模 —— 不管 success 挂的是什么 strategy, OptionSuccessDefault 都是它的配置。
- @dataclass
- class OptionSetupDefault:
- excludes: list | None = None
- @dataclass
- class OptionInterruptDefault:
- pass
- @dataclass
- class OptionSuccessDefault:
- excludes_1: list[str] = field(default_factory=lambda:
- [
- 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
- 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
- ])
- excludes_2: list[str] = field(default_factory=lambda:
- [
- 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
- 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
- 'C_END_1_1', 'C_END_1_2', 'C_END_1_3', 'C_END_1_4',
- 'C_END_1_5', 'C_END_1_6', "C_OVERFLOW_GHOST",
- ])
- @dataclass
- class OptionCompletionDefault:
- # 这里是为了, 确认结束战斗后退回到 “fire” 的界面
- check_imgs: list[RuleImage] | None = None
- # 兜底:check_imgs 都检测不到时,间隔点击的排除位
- excludes: list[str] = field(default_factory=lambda:
- [
- 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
- 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
- 'C_END_MASTER',
- ])
- @dataclass
- class OptionFailureDefault:
- pass
- @dataclass
- class OptionIdleDefault:
- pass
- @dataclass
- class OptionPrepareDefault:
- lock_team: bool = False
- @dataclass
- class OptionPresetDefault:
- preset_enable: bool = False
- preset_group: int = 1
- preset_team: int = 1
- @dataclass
- class OptionGreenDefault:
- green_enable: bool = False
- green_mark: GreenMarkType = GreenMarkType.GREEN_LEFT1
- green_mark_type: GreenMarkEnum = GreenMarkEnum.CHOOSE
- green_mark_name: str = ''
- @dataclass
- class OptionRedDefault:
- pass
- @dataclass
- class OptionEchoDefault:
- pass
- @dataclass
- class OptionRandomclickDefault:
- # 战斗开始后,首次允许执行前等待多久 每次战斗重抽存状态到 per_battle.start_delay_resolved
- start_delay: tuple[float, float] = (5.0, 10.0)
- # 两次执行之间的最小间隔, 每次执行的时候随机选一个,不存状态, 这个时间包括战斗结束后到下一轮的时间哈
- cooldown: tuple[float, float] = (30.0, 60.0)
- # 到达可执行时间后,本次实际执行的概率
- trigger_probability: float = 0.6
- # 本场战斗最多执行几次;元组表示开场时随机取一个上限, 每次战斗重抽一次,存状态到per_battle.execution_limit_resolved
- execution_limit: tuple[int, int] = (1, 2)
- def expected_random_clicks(
- self,
- battle_seconds: float = 30.0,
- gap_seconds: float = 10.0,
- battles: int = 100
- ) -> float:
- """估算多场战斗累计的期望随机动作执行次数(稳态解析模型)。
- 实际触发 14/115 ≈ 12.2% swipe 8 + random_click 6,平均约每 8.2 场实操一次
- 模型预测 单场 0.125 → 115 场 ≈ 14.4 次 (12.5%) expected_random_clicks(8.75, 6.24, 115)
- 这行是统计数据: 实际战斗时间,约 7.0 ~ 7.7 s:约 30 场,约 8.9 ~ 10.2 s:约 85 场。gap时间平均gap 约 6.24 s。 整体周期均值8.75 + 6.24 ≈ 15.0 s
- Args:
- battle_seconds: 单场战斗的持续时间(秒)。
- gap_seconds: 战斗结束到下一轮战斗的间隔(秒),冷却在该时段内持续流逝。
- battles: 统计的战斗场数。
- Returns:
- 累计 battles 场的期望随机动作执行次数。
- """
- cooldown_low, cooldown_high = self.cooldown
- cooldown_window_mean = cooldown_low + (math.sqrt(math.pi) / 2) * math.sqrt(cooldown_high - cooldown_low)
- start_delay_low, start_delay_high = self.start_delay
- start_delay_mean = (start_delay_low + start_delay_high) / 2
- attempts_per_battle = (battle_seconds + gap_seconds - start_delay_mean) / cooldown_window_mean
- attempts_can_execute = self.trigger_probability * attempts_per_battle
- attempts_can_execute_exp = math.exp(-attempts_can_execute)
- # 这里建模成泊松分布
- limit_low, limit_high = self.execution_limit
- per_battle = 0.0
- for limit in range(limit_low, limit_high + 1):
- probability_below = attempts_can_execute_exp # P(成功次数 < k)
- expected_with_limit = 0.0
- # E[min(H, limit)] = Σ_{k=1}^{limit} P(成功次数 ≥ k)
- for k in range(1, limit + 1):
- expected_with_limit += 1 - probability_below
- probability_below += attempts_can_execute_exp * attempts_can_execute ** k / math.factorial(k)
- per_battle += expected_with_limit
- per_battle /= limit_high - limit_low + 1
- return per_battle * battles
- # event → options 数据类, update_options 靠它按 hook2event 自动实例化分发
- _OPTION_CLASSES: dict[str, type] = {
- 'setup': OptionSetupDefault,
- 'completion': OptionCompletionDefault,
- 'interrupt': OptionInterruptDefault,
- 'success': OptionSuccessDefault,
- 'failure': OptionFailureDefault,
- 'idle': OptionIdleDefault,
- 'prepare': OptionPrepareDefault,
- 'preset': OptionPresetDefault,
- 'green': OptionGreenDefault,
- 'red': OptionRedDefault,
- 'echo': OptionEchoDefault,
- 'randomclick': OptionRandomclickDefault,
- }
- def _options_to_instances(raw: dict) -> dict:
- """把按 event 分组的原始 dict 转成对应的 Option 数据类实例(未知 key 过滤)"""
- result = {}
- for event, value in (raw or {}).items():
- opt_cls = _OPTION_CLASSES.get(event)
- if opt_cls is not None and isinstance(value, opt_cls):
- result[event] = value
- elif opt_cls is not None and isinstance(value, dict):
- known = {k: v for k, v in value.items() if k in opt_cls.__dataclass_fields__}
- result[event] = opt_cls(**known)
- else:
- result[event] = deepcopy(value)
- return result
- # pri 层的私有状态, 同样按 event 建模: pri[hook].per_task / per_battle 就是这个实例。
- # 字段按需声明 —— 有自定义私有状态的 strategy 往自己 event 的类里加字段。
- @dataclass
- class PerTaskSetup:
- pass
- @dataclass
- class PerTaskCompletion:
- pass
- @dataclass
- class PerTaskInterrupt:
- pass
- @dataclass
- class PerTaskSuccess:
- pass
- @dataclass
- class PerTaskFailure:
- pass
- @dataclass
- class PerTaskIdle:
- pass
- @dataclass
- class PerTaskPrepare:
- pass
- @dataclass
- class PerTaskPreset:
- # 一次任务类型触发一次,想要再次触发把done设置False
- done: bool = False
- @dataclass
- class PerTaskGreen:
- pass
- @dataclass
- class PerTaskRed:
- pass
- @dataclass
- class PerTaskEcho:
- pass
- @dataclass
- class PerTaskRandomclick:
- # 上一次点击的时间
- last_attempt_time: float = 0.0
- @dataclass
- class PerBattleSetup:
- pass
- @dataclass
- class PerBattleCompletion:
- click_stage_2: RuleClickExclude | None = None
- # 兜底点击节拍器:进入 completion 起算,满 3s 才首次点击,之后每 3s 一次
- fallback_timer: Timer | None = None
- fallback_cnt: int = 0
- @dataclass
- class PerBattleInterrupt:
- pass
- @dataclass
- class PerBattleSuccess:
- click_stage_1: RuleClickExclude | None = None
- click_stage_2: RuleClickExclude | None = None
- @classmethod
- def reward_exclude_click(
- cls,
- onwer,
- areas: list[str] = None,
- name: str = 'success_exclude_click'
- ) -> RuleClickExclude:
- inputs = []
- for area in areas:
- click = getattr(onwer, area, None)
- if click is None:
- raise ValueError(f'Unknown success exclusion click: {area!r}')
- inputs.append(click)
- return RuleClickExclude(inputs, name=name)
- @dataclass
- class PerBattleFailure:
- pass
- @dataclass
- class PerBattleIdle:
- pass
- @dataclass
- class PerBattlePrepare:
- done: bool = False
- timer: Timer = None
- @dataclass
- class PerBattlePreset:
- pass
- @dataclass
- class PerBattleGreen:
- # 本场战斗完成
- done: bool = False
- @dataclass
- class PerBattleRed:
- pass
- @dataclass
- class PerBattleEcho:
- pass
- @dataclass
- class PerBattleRandomclick:
- # 本场战斗已执行的随机动作次数
- execution_count: int = 0
- # 本场战斗的执行次数上限,首次拦截时从 execution_limit 随机解析
- execution_limit_resolved: int = 0
- # 本场战斗的首次执行延迟,首次拦截时从 start_delay 随机解析
- start_delay_resolved: float = 0.0
- # 首次允许执行的时间戳(0.0 表示尚未解析,首次拦截时写入)
- first_allowed_time: float = 0.0
- # event → pri 私有状态数据类
- _PER_TASK_CLASSES: dict[str, type] = {
- 'setup': PerTaskSetup,
- 'completion': PerTaskCompletion,
- 'interrupt': PerTaskInterrupt,
- 'success': PerTaskSuccess,
- 'failure': PerTaskFailure,
- 'idle': PerTaskIdle,
- 'prepare': PerTaskPrepare,
- 'preset': PerTaskPreset,
- 'green': PerTaskGreen,
- 'red': PerTaskRed,
- 'echo': PerTaskEcho,
- 'randomclick': PerTaskRandomclick,
- }
- _PER_BATTLE_CLASSES: dict[str, type] = {
- 'setup': PerBattleSetup,
- 'completion': PerBattleCompletion,
- 'interrupt': PerBattleInterrupt,
- 'success': PerBattleSuccess,
- 'failure': PerBattleFailure,
- 'idle': PerBattleIdle,
- 'prepare': PerBattlePrepare,
- 'preset': PerBattlePreset,
- 'green': PerBattleGreen,
- 'red': PerBattleRed,
- 'echo': PerBattleEcho,
- 'randomclick': PerBattleRandomclick,
- }
- # ────────────────────────────────────────────
- class BattleWaitPlan:
- """
- 就是一个超级大的状态机,这里拆成了很多hook
- """
- HOOKS_DEFAULT = _HOOKS_DEFAULT
- SEQUENCE_DEFAULT = _SEQUENCE_DEFAULT
- def __init__(self, *arg, **kwargs):
- extra_sequence: str = ''
- #
- for event_strategy in arg:
- if not isinstance(event_strategy, str):
- raise TypeError(
- 'Battle wait hook must be a string in '
- '"event_strategy" format; '
- f'got {event_strategy!r}'
- )
- if not event_strategy:
- raise ValueError(
- 'Battle wait hook cannot be empty; '
- 'expected "event_strategy" format'
- )
- event, separator, strategy = event_strategy.partition('_')
- if not separator or not event or not strategy:
- raise ValueError(
- 'Invalid battle wait hook '
- f'{event_strategy!r}; expected "event_strategy" format'
- )
- setattr(self, event, strategy)
- if event not in self.HOOKS_DEFAULT:
- extra_sequence += f'{event} > '
- #
- for event, strategy in kwargs.items():
- if not event or not isinstance(event, str) or not isinstance(strategy, str):
- raise TypeError(f'{event} or {strategy} is not a string')
- if getattr(self, event, None) is not None:
- raise ValueError(
- f'Battle wait event {event!r} was configured more than once'
- )
- setattr(self, event, strategy)
- if event not in self.HOOKS_DEFAULT:
- extra_sequence += f'{event} > '
- # 补齐默认的
- for event in self.HOOKS_DEFAULT:
- if getattr(self, event, None) is None:
- setattr(self, event, 'default')
- #
- self.sequence = kwargs.get('sequence', None)
- if self.sequence is None:
- self.sequence = f'{BattleWaitPlan.SEQUENCE_DEFAULT} {extra_sequence} idle'
- if not isinstance(self.sequence, str):
- raise TypeError(
- 'Battle wait sequence must be a string containing event names '
- "separated by '>'; "
- f'got {self.sequence!r}'
- )
- self.sequence: str = self.sequence.replace(' ', '').replace('\n', '').replace('\r', '').replace('setup', '')
- for event_name in self.sequence.split('>'):
- event_name = event_name.strip()
- if event_name == "sequence":
- continue
- if getattr(self, event_name, None) is None:
- raise ValueError(
- f'Unknown battle wait event {event_name!r} in '
- f'sequence {self.sequence!r}'
- )
- for event in self.HOOKS_DEFAULT:
- if event != 'setup' and event not in self.sequence:
- raise ValueError(
- f'Battle wait sequence is missing required event {event!r}; '
- f'got {self.sequence!r}'
- )
- def __str__(self):
- lines = [f"{self.__class__.__name__}:", f" sequence: {self.sequence}", " hooks:"]
- for event_name in self.HOOKS_DEFAULT:
- strategy_name = getattr(self, event_name, None)
- if callable(strategy_name):
- if hasattr(strategy_name, '__name__'):
- func_name = strategy_name.__name__
- else:
- func_name = repr(strategy_name)
- val_str = f"<function {func_name}>"
- else:
- val_str = repr(strategy_name)
- lines.append(f" {event_name}: {val_str}")
- return "\n".join(lines)
- def __repr__(self):
- return self.__str__()
- @property
- def function_setup_name(self) -> str:
- if getattr(self, 'setup', None) is None:
- self.setup = 'default'
- return f'_bw_setup_{self.setup}'
- def sequence_function_names(self) -> list[str]:
- """
- 注意,这里是没有setup的
- """
- function_names = []
- for event_name in self.sequence.split('>'):
- event_name = event_name.strip()
- if not event_name:
- continue
- if not hasattr(self, event_name):
- raise ValueError(f'Unknown battle wait event: {event_name}')
- strategy_name = getattr(self, event_name)
- if not isinstance(strategy_name, str) or not strategy_name:
- raise ValueError(
- f'Invalid strategy for battle wait event {event_name}: '
- f'{strategy_name!r}'
- )
- function_names.append(f'_bw_{event_name}_{strategy_name}')
- return function_names
- def override(self, *arg, **kwargs):
- if kwargs:
- raise TypeError(
- 'sequence is not supported' if 'sequence' in kwargs else f'Unexpected keyword arguments: {tuple(kwargs)}')
- if not arg:
- return self
- events = [event for event in self.sequence.split('>') if event]
- if 'idle' not in events:
- raise ValueError(f'Sequence {self.sequence!r} must contain "idle"')
- idle_index = events.index('idle')
- for event_strategy in arg:
- if not isinstance(event_strategy, str):
- raise TypeError(f'event_strategy must be a string, got {event_strategy!r}')
- event, separator, strategy = event_strategy.partition('_')
- if not separator or not event or not strategy:
- raise ValueError(f'Invalid event_strategy: {event_strategy!r}')
- if event == 'sequence':
- raise ValueError('sequence cannot be overridden')
- is_new = not hasattr(self, event)
- setattr(self, event, strategy)
- if is_new:
- events.insert(idle_index, event)
- idle_index += 1
- self.sequence = '>'.join(events)
- return self
- class battle_wait_strategy:
- """每个装饰器保存自己的策略,with 在当前上下文内临时覆盖。
- Options are provided independently by battle_wait_options. Dynamic
- random_click_swipt_enable remains scoped to one call for legacy tasks.
- """
- _context = ContextVar('battle_wait_strategy_context', default=None)
- def __init__(self, *arg, **kwargs):
- self.battle_wait_plan = BattleWaitPlan(*arg, **kwargs)
- self._context_tokens = ContextVar('battle_wait_strategy_tokens', default=())
- def __enter__(self):
- token = self._context.set(self.battle_wait_plan)
- self._context_tokens.set(self._context_tokens.get() + (token,))
- return self
- def __exit__(self, *exc):
- tokens = self._context_tokens.get()
- self._context.reset(tokens[-1])
- self._context_tokens.set(tokens[:-1])
- return False
- def __str__(self):
- scope = 'temporary' if self._context_tokens.get() else 'decorator'
- return (
- f'{type(self).__name__}(scope={scope}, '
- f'plan={self.battle_wait_plan}, active_plan={self._context.get()})'
- )
- def __repr__(self):
- return self.__str__()
- def _recreate_cm(self):
- return self
- def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
- @wraps(func)
- def inner(owner, *args: P.args, **kwargs: P.kwargs) -> T:
- current_plan = self._context.get() or self.battle_wait_plan
- if kwargs.get('random_click_swipt_enable'):
- current_plan = deepcopy(current_plan)
- current_plan.override('randomclick_default')
- options = battle_wait_options.current()
- runtime.reset_per_battle()
- runtime.update_options(options, plan=current_plan)
- return func(owner, battle_wait_plan=current_plan, options=options)
- return inner
- class battle_wait_options:
- """按事件设置 options;with 覆盖装饰器值,退出后恢复调用前的上下文。
- Both dict values and the corresponding Option dataclass instances are
- accepted. Defaults and overrides are copied for every battle.
- """
- options: dict = {event: cls() for event, cls in _OPTION_CLASSES.items()}
- _context = ContextVar('battle_wait_options_context', default=None)
- _decorator_options = ContextVar('battle_wait_decorator_options', default=None)
- def __init__(self, **kwargs):
- self._overrides = deepcopy(_options_to_instances(kwargs))
- self._context_tokens = ContextVar('battle_wait_options_tokens', default=())
- @classmethod
- def current(cls) -> dict:
- merged = deepcopy(cls.options)
- merged.update(deepcopy(cls._decorator_options.get() or {}))
- merged.update(deepcopy(cls._context.get() or {}))
- return merged
- def __enter__(self):
- merged = deepcopy(self._context.get() or {})
- merged.update(deepcopy(self._overrides))
- token = self._context.set(merged)
- self._context_tokens.set(self._context_tokens.get() + (token,))
- return self
- def __exit__(self, *exc):
- tokens = self._context_tokens.get()
- self._context.reset(tokens[-1])
- self._context_tokens.set(tokens[:-1])
- return False
- def __str__(self):
- scope = 'temporary' if self._context_tokens.get() else 'decorator'
- return (
- f'{type(self).__name__}(scope={scope}, '
- f'overrides={self._overrides}, options={self.current()})'
- )
- def __repr__(self):
- return self.__str__()
- def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
- @wraps(func)
- def inner(owner, *args: P.args, **kwargs: P.kwargs) -> T:
- token = self._decorator_options.set(deepcopy(self._overrides))
- try:
- return func(owner, *args, **kwargs)
- finally:
- self._decorator_options.reset(token)
- return inner
- @dataclass
- class PublicContext:
- cross: dict = field(default_factory=dict)
- per_task: PerTaskState = field(default_factory=PerTaskState)
- per_battle: PerBattleState = field(default_factory=PerBattleState)
- options: dict = field(default_factory=dict) # 所有hook的options
- @dataclass
- class PrivateContext:
- cross: dict = field(default_factory=dict)
- per_task: dict = field(default_factory=dict)
- per_battle: dict = field(default_factory=dict)
- options: dict = field(default_factory=dict) # 单个hook的options
- class runtime:
- task_owner = None
- pri_ctx: dict[str, PrivateContext] = {}
- pub_ctx: PublicContext = None
- def __init__(self, func: Callable):
- self.func = func
- self.hook_name = func.__name__
- update_wrapper(self, func)
- def __get__(self, obj, objtype=None):
- if obj is None:
- return self
- runtime._ensure_pub_default()
- runtime._ensure_pri_default(self.hook_name)
- @wraps(self.func)
- def bound(*args, **kwargs):
- return self(obj, *args, **kwargs)
- return bound
- def __call__(self, owner, *args, **kwargs):
- # 新任务重置一下
- if runtime.task_owner is None or owner is not runtime.task_owner:
- runtime.task_owner = owner
- runtime.reset_per_task()
- runtime._ensure_pub_default()
- runtime._ensure_pri_default(self.hook_name)
- return self.func(owner, pub=runtime.pub_ctx, pri=runtime.pri_ctx[self.hook_name])
- def __str__(self):
- pub = runtime.pub_ctx or PublicContext()
- pri = runtime.pri_ctx.get(self.hook_name) or PrivateContext()
- def _keys(d):
- if isinstance(d, dict):
- return ','.join(d.keys()) or '-'
- if isinstance(d, tuple(_OPTION_CLASSES.values())) or isinstance(d, tuple(_PER_TASK_CLASSES.values())) or isinstance(d, tuple(_PER_BATTLE_CLASSES.values())) or isinstance(d, (PerTaskState, PerBattleState)):
- return ','.join(d.__dataclass_fields__) or '-'
- return str(d)
- return (
- f'runtime({self.hook_name}) '
- f'pub[c:{_keys(pub.cross)},t:{_keys(pub.per_task)},b:{_keys(pub.per_battle)},o:{_keys(pub.options)}] '
- f'pri[c:{_keys(pri.cross)},t:{_keys(pri.per_task)},b:{_keys(pri.per_battle)},o:{_keys(pri.options)}]'
- )
- def __repr__(self):
- return self.__str__()
- @classmethod
- def reset_per_task(cls):
- cls._ensure_pub_default()
- cls.pub_ctx.per_task = PerTaskState()
- for hook_name, ctx in cls.pri_ctx.items():
- event = cls.hook2event(hook_name)
- cls_type = _PER_TASK_CLASSES.get(event, dict)
- ctx.per_task = cls_type()
- @classmethod
- def reset_per_battle(cls):
- cls._ensure_pub_default()
- cls.pub_ctx.per_battle = PerBattleState()
- for hook_name, ctx in cls.pri_ctx.items():
- event = cls.hook2event(hook_name)
- cls_type = _PER_BATTLE_CLASSES.get(event, dict)
- ctx.per_battle = cls_type()
- @classmethod
- def _ensure_pub_default(cls):
- if cls.pub_ctx is None:
- cls.pub_ctx = PublicContext()
- @classmethod
- def _ensure_pri_default(cls, name):
- if name not in cls.pri_ctx:
- event = cls.hook2event(name)
- cls.pri_ctx[name] = PrivateContext(
- per_task=_PER_TASK_CLASSES.get(event, dict)(),
- per_battle=_PER_BATTLE_CLASSES.get(event, dict)(),
- )
- @classmethod
- def hook2event(cls, func_name: str) -> str:
- # '_bw_success_soul' -> 'success'(strategy 名里带下划线也能正确切出事件名)
- return func_name[len('_bw_'):].split('_', 1)[0]
- @classmethod
- def event2hook(cls, event_name: str, strategy_name: str) -> str:
- return f'_bw_{event_name}_{strategy_name}'
- @classmethod
- def update_options(cls, options: dict[str, object] | None, plan: BattleWaitPlan):
- """
- 输入 options = {
- 'setup': OptionSetupDefault(excludes=None),
- 'completion': OptionCompletionDefault(),
- 'prepare': OptionPrepareDefault(lock_team=True),
- 'preset': OptionPresetDefault(preset_enable=True, preset_group=1, preset_team=2),
- 'success': OptionSuccessDefault(), # 没传字段 → 全默认
- ... # 其余 event 都有
- }
- 设置值, 这里key没有直接使用 event 而是 _bw_event_strategy 是因为可能这场战斗和下一场战斗的options不同,需要区分开来
- cls.pub_ctx.options = options // 直接的一个引用
- runtime.pri_ctx['_bw_prepare_default'].options == OptionPrepareDefault(lock_team=True)
- runtime.pri_ctx['_bw_preset_default'].options == OptionPresetDefault(preset_enable=True, preset_group=1, preset_team=2)
- runtime.pri_ctx['_bw_success_default'].options == OptionSuccessDefault()
- """
- cls._ensure_pub_default()
- if not isinstance(options, dict):
- raise
- cls.pub_ctx.options = options
- if plan is not None:
- for hook in [plan.function_setup_name] + plan.sequence_function_names():
- cls._ensure_pri_default(hook)
- opt = options.get(cls.hook2event(hook))
- ctx = cls.pri_ctx[hook]
- ctx.options = opt if isinstance(opt, cls._option_class(hook)) \
- else cls._option_class(hook)()
- @classmethod
- def _option_class(cls, hook_name: str) -> type:
- return _OPTION_CLASSES.get(cls.hook2event(hook_name)) or dict
- @classmethod
- def hook_enabled(cls) -> set:
- _hook_enabled = cls.pub_ctx.per_battle.hook_enabled
- if not _hook_enabled:
- raise
- return _hook_enabled
- @classmethod
- def hook_enabled_update(cls, enable: tuple[str, ...], disable: tuple[str, ...]) -> HookSignal:
- """
- hook_enabled 的更新只能在 BattleWait 上。不可以在 battle_wait_options 或者 battle_wait_strategy 上
- """
- if enable:
- cls.pub_ctx.per_battle.hook_enabled.update(enable)
- if disable:
- cls.pub_ctx.per_battle.hook_enabled.difference_update(disable)
- return HookSignal.CONTINUE
- def randomclick_gate(func: Callable) -> Callable:
- """
- randomclick 专属拦截装饰器,零自身状态。全部状态读写透传进来的 pri:
- - per_battle(PerBattleRandomclick): 开场 delay/上限/次数,每场重置
- - per_task (PerTaskRandomclick): cooldown 上次尝试时刻,跨战斗
- 四道门全过才放行 func 真正执行随机动作。
- """
- @wraps(func)
- def wrapper(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- options = pub.options.get('randomclick')
- state_battle: PerBattleRandomclick = pri.per_battle
- state_task: PerTaskRandomclick = pri.per_task
- if not isinstance(options, OptionRandomclickDefault):
- raise TypeError(f"randomclick options must be OptionRandomclickDefault, got {type(options)!r}")
- if not isinstance(state_battle, PerBattleRandomclick):
- raise TypeError(f"randomclick per_battle state must be PerBattleRandomclick, got {type(state_battle)!r}")
- if not isinstance(state_task, PerTaskRandomclick):
- raise TypeError(f"randomclick per_task state must be PerTaskRandomclick, got {type(state_task)!r}")
- if not self.is_in_battle(is_screenshot=False):
- return HookSignal.CONTINUE
- now = time.time()
- # 第一次调用:解析 start_delay 和 execution_limit(只解析一次)
- if state_battle.first_allowed_time == 0.0:
- state_battle.start_delay_resolved = random.uniform(*options.start_delay)
- state_battle.execution_limit_resolved = random.randint(*options.execution_limit)
- state_battle.first_allowed_time = now + state_battle.start_delay_resolved
- return HookSignal.CONTINUE
- # Gate 1: start_delay 未到
- if now < state_battle.first_allowed_time:
- return HookSignal.CONTINUE
- # Gate 2: execution_limit 已满
- if state_battle.execution_count >= state_battle.execution_limit_resolved:
- return HookSignal.CONTINUE
- # Gate 3: cooldown 未到(记在 per_task 跨战斗,秒掉的小战斗也能续上间隔)
- if now - state_task.last_attempt_time < random.uniform(*options.cooldown):
- return HookSignal.CONTINUE
- # 记录本次尝试时间(无论概率是否通过,都算一次 cooldown 周期)
- state_task.last_attempt_time = now
- # Gate 4: trigger_probability 概率判定
- if random.random() >= options.trigger_probability:
- return HookSignal.CONTINUE
- # 通过全部四道门,放行真正执行随机动作
- state_battle.execution_count += 1
- return func(self, pub, pri)
- return wrapper
- class BattleWait(BaseTask, GeneralBattleAssets):
- def __new__(cls, *args, **kwargs):
- for klass in reversed(cls.__mro__):
- # 找遍整个继承链,从父到子
- if klass is object:
- continue
- if klass.__dict__.get('_runtime_auto_decorated'):
- continue
- klass._runtime_auto_decorated = True
- for name, attr in list(vars(klass).items()):
- if name.startswith('_bw_') and callable(attr) and not isinstance(attr, runtime):
- setattr(klass, name, runtime(attr))
- return super().__new__(cls)
- # ----------------------------------------------------------------------------------------------------------------
- # loadout:一行一个 event(event + strategy + options),全量快照,默认值来源 battle_wait.py,不裸写:
- # strategies: dict[event -> strategy],有序,key 是 hook 名,支持 prepare='default' 这类逐 hook 设置
- # options: dict[event -> Option 实例],全部字段可见
- # 跑法:
- # with battle_wait_strategy(**strategies), battle_wait_options(**options):
- # self.battle_wait()
- # ----------------------------------------------------------------------------------------------------------------
- @classmethod
- def loadout_default(cls) -> tuple[dict, dict]:
- """
- 默认策略 + 默认 options 的全量快照(不是 diff,是完整的)。
- 策略来源 BattleWaitPlan()(battle_wait.py),按 sequence 顺序展开成 dict;
- options 来源 battle_wait_options.current()(含当前上下文覆盖)。
- """
- plan = BattleWaitPlan()
- strategies = {e: getattr(plan, e) for e in plan.sequence.replace(' ', '').split('>') if e}
- options = battle_wait_options.current()
- return strategies, options
- @classmethod
- def loadout_show(cls, loadout: tuple[dict, dict] | None = None) -> None:
- """
- 输出类似:
- event strategy options
- idle default OptionIdleDefault()
- prepare default OptionPrepareDefault(lock_team=False)
- preset default OptionPresetDefault(preset_enable=False, preset_group=1, preset_team=1)
- green default OptionGreenDefault(green_enable=False, green_mark=<GreenMarkType.GREEN_LEFT1: 'green_left1'>)
- """
- strategies, options = loadout if loadout is not None else cls.loadout_default()
- order = []
- seen = set()
- for event in options:
- order.append(event)
- seen.add(event)
- for event in strategies:
- if event not in seen:
- order.append(event)
- print('=' * 64)
- print(f'{"event":<12}{"strategy":<12}options')
- for event in order:
- print(f'{event:<12}{strategies.get(event, "default"):<12}{options.get(event)!r}')
- print('=' * 64)
- @classmethod
- def state_show(cls) -> None:
- """
- 输出类似:
- event strategy enabled per_task | per_battle
- completion default True {} | {}
- idle default True {} | {}
- prepare default False {} | {'done': True}
- ----------------------------------------------------------------
- pub per_task count 等全局跨任务状态
- pub per_battle success / hook_enabled 等全局跨战斗状态
- """
- runtime._ensure_pub_default()
- enabled = runtime.hook_enabled()
- def _nondefault(o):
- if isinstance(o, dict):
- return dict(o)
- return {f.name: getattr(o, f.name) for f in fields(o) if getattr(o, f.name) != f.default}
- options = cls.loadout_default()[1]
- order = list(options)
- hooks = sorted(
- runtime.pri_ctx,
- key=lambda h: order.index(runtime.hook2event(h)) if runtime.hook2event(h) in order else len(order),
- )
- print('=' * 64)
- print(f'{"event":<12}{"strategy":<12}{"enabled":<10}per_task | per_battle')
- for hook in hooks:
- event = runtime.hook2event(hook)
- strategy = hook[len(f'_bw_{event}_'):]
- ctx = runtime.pri_ctx[hook]
- print(f'{event:<12}{strategy:<12}{str(event in enabled):<10}'
- f'{_nondefault(ctx.per_task)} | {_nondefault(ctx.per_battle)}')
- print('-' * 64)
- pub = runtime.pub_ctx
- print(f'{"pub":<12}{"":<12}{"per_task":<10}{_nondefault(pub.per_task)}')
- print(f'{"pub":<12}{"":<12}{"per_battle":<10}{_nondefault(pub.per_battle)}')
- print('=' * 64)
- time.sleep(0.6)
- # ------------------------------------------------------------------------------------------------------------------
- # build in
- # ------------------------------------------------------------------------------------------------------------------
- def _bw_setup_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- self.C_REWARD_1.name = 'C_REWARD'
- self.C_REWARD_2.name = 'C_REWARD'
- self.C_REWARD_3.name = 'C_REWARD'
- self.device.stuck_record_add('BATTLE_STATUS_S')
- self.device.click_record_clear()
- logger.info('Start battle process')
- return HookSignal.DONE
- def _bw_completion_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- logger.info('Battle completion process')
- state: PerBattleCompletion = pri.per_battle
- options: OptionCompletionDefault = pri.options
- if not isinstance(state, PerBattleCompletion) or not isinstance(options, OptionCompletionDefault):
- raise
- if options.check_imgs is None:
- pub.per_task.count += 1
- # self.current_count += 1 # 兼容旧的计数
- return HookSignal.DONE
- # 如果需要进一步确认
- if not isinstance(options.check_imgs, list):
- raise
- appears = [self.appear(check) for check in options.check_imgs]
- if any(appears):
- pub.per_task.count += 1
- # self.current_count += 1 # 兼容旧的计数
- return HookSignal.DONE
- # check_imgs 全没出现 → 兜底点击回退界面:进入 completion 满 3s 才首次点击,之后每 3s 一次
- if state.fallback_timer is None:
- state.fallback_timer = Timer(3).start()
- if state.fallback_cnt >= 5:
- pub.per_task.count += 1
- logger.info('Fallback timer expired')
- return HookSignal.DONE
- if not isinstance(state.fallback_timer, Timer):
- raise
- if not state.fallback_timer.reached():
- return HookSignal.CONTINUE
- state.fallback_timer.reset()
- if state.click_stage_2 is None:
- state.click_stage_2 = PerBattleSuccess.reward_exclude_click(self, options.excludes, name='completion_exclude_click')
- if self.click(state.click_stage_2, interval=1.5):
- state.fallback_cnt += 1
- # x, y = state.click_stage_2.coord()
- # self.device.click(x=x, y=y, control_name='completion_exclude_click')
- return HookSignal.CONTINUE
- def _bw_interrupt_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- # 比如 御魂溢出
- # 结算的时候御魂溢出提示,点击【知道了】
- self.appear_then_click(self.I_OVER_GHOST)
- return HookSignal.CONTINUE
- def _bw_success_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- state: PerBattleSuccess = pri.per_battle
- options: OptionSuccessDefault = pri.options
- if not isinstance(state, PerBattleSuccess) or not isinstance(options, OptionSuccessDefault):
- raise
- if state.click_stage_1 is None:
- state.click_stage_1 = PerBattleSuccess.reward_exclude_click(self, pri.options.excludes_1, name='reward_exclude_click_1')
- if state.click_stage_2 is None:
- state.click_stage_2 = PerBattleSuccess.reward_exclude_click(self, pri.options.excludes_2, name='reward_exclude_click_2')
- if self.appear_then_click(self.I_WIN, interval=0.8):
- self.click(state.click_stage_1)
- return HookSignal.CONTINUE
- appear_ghost, appear_reward, appear_gold, appear_skin = (
- self.appear(self.I_GREED_GHOST),
- self.appear(self.I_REWARD),
- self.appear(self.I_REWARD_GOLD),
- self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
- )
- if not any([appear_ghost, appear_reward, appear_gold, appear_skin]):
- return HookSignal.CONTINUE
- logger.info('Win battle')
- timer = Timer(20).start()
- while 1:
- self.screenshot()
- # 发现御魂溢出,直接跳出,在interupt里面处理
- if self.appear(self.I_OVER_GHOST):
- return HookSignal.CONTINUE
- # 不小心点到了具体的奖励,他会弹出这个物品的详细描述 里面必定包含有“获取途径”
- if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2):
- self.click(self.C_REWARD_2, interval=1.5)
- _appear_ghost, _appear_reward, _appear_gold, _appear_skin = (
- self.appear(self.I_GREED_GHOST, threshold=0.6),
- self.appear(self.I_REWARD),
- self.appear(self.I_REWARD_GOLD),
- self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
- )
- # logger.info(f'_appear_ghost: {_appear_ghost} _appear_reward: {_appear_reward} _appear_gold: {_appear_gold} _appear_skin: {_appear_skin}')
- if any([_appear_ghost, _appear_reward, _appear_gold, _appear_skin]):
- if random.random() < 0.02:
- # 有一定的概率专门点击具体的奖励物品
- x, y = state.click_stage_2.coord_in_excluded(None)
- self.device.click(x=x, y=y, control_name='reward_item')
- continue
- self.click(state.click_stage_2, interval=1.5)
- else:
- logger.info('Get all reward')
- pub.per_battle.success = BattleResult.SUCCESS
- return runtime.hook_enabled_update(
- enable=('completion',),
- disable=tuple(['success', 'failure']),
- )
- if timer.reached_and_reset():
- logger.warning('battle')
- break
- return HookSignal.CONTINUE
- def _bw_failure_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- if self.appear(self.I_FALSE, threshold=0.8):
- logger.warning('False battle')
- self.ui_click_until_disappear(self.I_FALSE)
- pub.per_battle.success = BattleResult.FAILURE
- return runtime.hook_enabled_update(
- enable=('completion', ),
- disable=tuple(['success', 'failure']),
- )
- return HookSignal.CONTINUE
- def _bw_idle_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- return HookSignal.CONTINUE
- def _bw_prepare_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- pri_options = pri.options if isinstance(pri.options, OptionPrepareDefault) else None
- state = pri.per_battle if isinstance(pri.per_battle, PerBattlePrepare) else None
- if pri_options is None or state is None:
- return HookSignal.CONTINUE
- if state.done:
- return HookSignal.CONTINUE
- # 活动直接进入新战斗流程,不再经过 GeneralBattle.battle_before。
- # 先关闭御魂不一致提示,避免遮挡准备按钮或误触绿标。
- if self.appear_then_click(self.I_DISABLE_7DAYS_DIFF_SOUL, interval=0.6):
- return HookSignal.CONTINUE
- if self.appear_then_click(self.I_CONFIRM_CLOSE_DIFF_SOUL, interval=0.6):
- return HookSignal.CONTINUE
- # 如果是锁队伍的,就直接跳过, 开启后面的 绿标,红标,应声虫
- # 如果确定进入正式战斗中了 也是同样的操作
- if pri_options.lock_team or self.is_in_real_battle(False):
- logger.info('Prepare stage finish')
- state.done = True
- return runtime.hook_enabled_update(
- enable=('green', 'red', 'echo'),
- disable=('prepare', 'preset'),
- )
- # 如果开启了切阵容,就等执行切阵容完成(切阵容操作会自动把准备按钮给按消失), 这里会等8秒钟,时间一到自动关闭准备阶段
- # 切阵容按 per_task 是一次性的:本任务已切过(done)就不再开定时器等,直接按准备开打
- preset_done = next((
- ctx.per_task.done
- for hook, ctx in runtime.pri_ctx.items()
- if runtime.hook2event(hook) == 'preset' and isinstance(ctx.per_task, PerTaskPreset)
- ), False)
- if pub.options.get('preset', OptionPresetDefault).preset_enable and not preset_done:
- if state.timer is None:
- state.timer = Timer(6).start()
- # return HookSignal.CONTINUE
- return runtime.hook_enabled_update(
- enable=('preset',),
- disable=(),
- )
- # 时间没到就一直等吧
- if not state.timer.reached():
- return HookSignal.CONTINUE
- # 计时8秒时间到了, 那就一直按 准备按钮 直到消失去
- # 不要把这行代码合并到下面去
- self.appear_then_click(self.I_PREPARE_HIGHLIGHT, interval=0.8)
- return HookSignal.CONTINUE
- # 没有切阵容那就一直按 准备按钮 直到消失去]
- self.appear_then_click(self.I_PREPARE_HIGHLIGHT, interval=1)
- return HookSignal.CONTINUE
- def _bw_preset_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- """
- 切阵容:切换预设队伍,每个任务只执行一次
- """
- pri_options = pri.options if isinstance(pri.options, OptionPresetDefault) else None
- state = pri.per_task if isinstance(pri.per_task, PerTaskPreset) else None
- if pri_options is None or state is None:
- return HookSignal.CONTINUE
- if not pri_options.preset_enable or state.done:
- return HookSignal.CONTINUE
- logger.info("Preset is enable")
- # 点击预设按钮
- while 1:
- self.screenshot()
- if self.appear(self.I_PRESET_ENSURE):
- break
- # 首个队伍没有满足5个式神,未出现预设按钮的情况下跳出循环
- if self.appear(self.I_PRESENT_LESS_THAN_5):
- break
- if self.appear_then_click(self.I_PRESET, threshold=0.8, interval=1):
- continue
- if self.appear_then_click(self.I_PRESET_WIT_NUMBER, threshold=0.8, interval=1):
- continue
- if self.ocr_appear(self.O_PRESET):
- self.click(self.O_PRESET, interval=1)
- continue
- if self.ocr_appear(self.O_PRESET_FULL):
- self.click(self.O_PRESET_FULL, interval=1)
- continue
- logger.info("Click preset button")
- def get_unselect_color(tmp1, tmp2, tmp3, size):
- # 获取未选择分组的颜色,3组之中必定存在两个颜色相似
- color_1 = get_color(self.device.image,
- (tmp1.roi_back[0], tmp1.roi_back[1],
- tmp1.roi_back[0] + size[0], tmp1.roi_back[1] + size[1]))
- color_2 = get_color(self.device.image,
- (tmp2.roi_back[0], tmp2.roi_back[1],
- tmp2.roi_back[0] + size[0], tmp2.roi_back[1] + size[1]))
- color_3 = get_color(self.device.image,
- (tmp3.roi_back[0], tmp3.roi_back[1],
- tmp3.roi_back[0] + size[0], tmp3.roi_back[1] + size[1]))
- if color_similar(color_1, color_2):
- return color_1
- if color_similar(color_2, color_3):
- return color_2
- return color_3
- # 选择预设组
- tmp = self.__getattribute__("C_PRESET_GROUP_" + str(pri_options.preset_group))
- if tmp is None:
- tmp = self.C_PRESET_GROUP_1
- color_size = [self.C_PRESET_GROUP_1.roi_back[2],
- self.C_PRESET_GROUP_1.roi_back[3]]
- unselected_color = (224.9, 208.3, 187.4)
- while True:
- self.screenshot()
- color_tmp = get_color(self.device.image,
- (tmp.roi_back[0], tmp.roi_back[1], tmp.roi_back[0] + color_size[0],
- tmp.roi_back[1] + color_size[1]))
- if color_similar(color_tmp, unselected_color):
- self.click(tmp, interval=0.2)
- continue
- break
- logger.info("Select preset group")
- # 选择预设的队伍
- time.sleep(0.5)
- tmp = self.__getattribute__("C_PRESET_TEAM_" + str(pri_options.preset_team))
- if tmp is None:
- tmp = self.C_PRESET_TEAM_1
- color_size = [5, 5]
- unselected_color = (216.8, 185.0, 146.8)
- while True:
- self.screenshot()
- color_tmp = get_color(self.device.image,
- (tmp.roi_back[0], tmp.roi_back[1], tmp.roi_back[0] + color_size[0],
- tmp.roi_back[1] + color_size[1]))
- if color_similar(color_tmp, unselected_color):
- self.click(tmp, interval=0.2)
- continue
- break
- self.click(tmp)
- logger.info("Select preset team")
- # 点击预设确认
- self.wait_until_appear(self.I_PRESET_ENSURE, wait_time=1)
- click_timer = Timer(4).start()
- while 1:
- self.screenshot()
- if click_timer.reached():
- logger.warning("Switch preset failure")
- if not self.appear(self.I_PRESET_ENSURE):
- break
- if self.appear_then_click(self.I_PRESET_ENSURE, threshold=0.8, interval=1):
- continue
- logger.info("Click preset ensure")
- state.done = True
- return runtime.hook_enabled_update(
- enable=(),
- disable=('preset',),
- )
- def _bw_green_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- """
- 绿标:标记己方式神,每场战斗只执行一次
- """
- pri_options = pri.options if isinstance(pri.options, OptionGreenDefault) else None
- state = pri.per_battle if isinstance(pri.per_battle, PerBattleGreen) else None
- if pri_options is None or state is None:
- return HookSignal.CONTINUE
- if not pri_options.green_enable or state.done:
- return runtime.hook_enabled_update(
- enable=(),
- disable=('green',),
- )
- # 等待那个准备的消失
- while 1:
- self.screenshot()
- if not self.appear(self.I_PREPARE_HIGHLIGHT):
- break
- if pri_options.green_mark_type == GreenMarkEnum.NAME:
- name = pri_options.green_mark_name
- if not name:
- logger.warning("Green mark name is empty")
- else:
- timeout_timer = Timer(6).start()
- best = {
- 'name': '',
- 'x': -1,
- 'y': -1,
- 'similarity': 0.0,
- }
- while not timeout_timer.reached():
- self.screenshot()
- results = self.O_GREEN_MARK_AREA.detect_and_ocr(self.device.image)
- for ret in results:
- similarity = difflib.SequenceMatcher(
- None,
- ret.ocr_text,
- name,
- ).ratio()
- if similarity > best['similarity']:
- x = self.O_GREEN_MARK_AREA.roi[0] + ret.box[0, 0] + 5
- y = self.O_GREEN_MARK_AREA.roi[1] + ret.box[0, 1] + 30
- best = {
- 'name': ret.ocr_text,
- 'x': min(1279, x),
- 'y': min(719, y),
- 'similarity': similarity,
- }
- if best['similarity'] > 0.5:
- logger.info(
- f'Green name success, text: {best["name"]}'
- f'[{best["similarity"]:.2f}]'
- )
- self.device.click(
- best['x'],
- best['y'],
- control_name=best['name'],
- )
- break
- else:
- logger.warning(
- f'Green name failed, best text: {best["name"]}'
- f'[{best["similarity"]:.2f}]'
- )
- else:
- x, y = None, None
- match pri_options.green_mark:
- case GreenMarkType.GREEN_LEFT1:
- x, y = self.C_GREEN_LEFT_1.coord()
- logger.info("Green left 1")
- case GreenMarkType.GREEN_LEFT2:
- x, y = self.C_GREEN_LEFT_2.coord()
- logger.info("Green left 2")
- case GreenMarkType.GREEN_LEFT3:
- x, y = self.C_GREEN_LEFT_3.coord()
- logger.info("Green left 3")
- case GreenMarkType.GREEN_LEFT4:
- x, y = self.C_GREEN_LEFT_4.coord()
- logger.info("Green left 4")
- case GreenMarkType.GREEN_LEFT5:
- x, y = self.C_GREEN_LEFT_5.coord()
- logger.info("Green left 5")
- case GreenMarkType.GREEN_MAIN:
- x, y = self.C_GREEN_MAIN.coord()
- logger.info("Green main")
- # 判断有无坐标的偏移
- self.appear_then_click(self.I_LOCAL)
- time.sleep(0.3)
- # 点击绿标
- self.device.click(x, y)
- state.done = True
- return runtime.hook_enabled_update(
- enable=(),
- disable=('green',),
- )
- def _bw_red_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- """
- 红标:点击对手的式神,暂为空壳
- """
- state = pri.per_battle
- state.done = True
- return runtime.hook_enabled_update(
- enable=(),
- disable=('red',),
- )
- def _bw_echo_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- """
- 应声虫:战斗中进入聊天界面复制粘贴,暂为空壳
- """
- state = pri.per_battle
- state.done = True
- return runtime.hook_enabled_update(
- enable=(),
- disable=('echo',),
- )
- @randomclick_gate
- def _bw_randomclick_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- match random.randint(0, 2):
- case 0:
- self.click(self.C_RANDOM_CLICK, interval=20)
- case 1:
- self.swipe(self.S_BATTLE_RANDOM_LEFT, interval=20)
- case 2:
- self.swipe(self.S_BATTLE_RANDOM_RIGHT, interval=20)
- return HookSignal.CONTINUE
- # custom
- # ------------------------------------------------------------------------------------------------------------------
- def _bw_success_soul(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- state = pri.per_battle
- options = pri.options
- if not isinstance(state, PerBattleSuccess) or not isinstance(options, OptionSuccessDefault):
- raise TypeError("battle wait option 'success' must be an OptionSuccessDefault")
- if state.click_stage_1 is None:
- state.click_stage_1 = PerBattleSuccess.reward_exclude_click(self, options.excludes_1, name='success_exclude_click')
- action_click = state.click_stage_1
- if self.appear_then_click(self.I_WIN, interval=0.8):
- return HookSignal.CONTINUE
- appear_ghost, appear_reward, appear_gold, appear_skin = (
- self.appear(self.I_GREED_GHOST),
- self.appear(self.I_REWARD),
- self.appear(self.I_REWARD_GOLD),
- self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
- )
- if not any([appear_ghost, appear_reward, appear_gold, appear_skin]):
- return HookSignal.CONTINUE
- logger.info('Win battle')
- timer = Timer(20).start()
- while 1:
- self.screenshot()
- _appear_ghost, _appear_reward, _appear_gold, _appear_skin = (
- self.appear(self.I_GREED_GHOST, threshold=0.6),
- self.appear(self.I_REWARD),
- self.appear(self.I_REWARD_GOLD),
- self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
- )
- # logger.info(f'_appear_ghost: {_appear_ghost} _appear_reward: {_appear_reward} _appear_gold: {_appear_gold} _appear_skin: {_appear_skin}')
- if any([_appear_ghost, _appear_reward, _appear_gold, _appear_skin]):
- self.click(action_click, interval=1.5)
- else:
- logger.info('Get all reward')
- pub.per_battle.success = BattleResult.SUCCESS
- return runtime.hook_enabled_update(
- enable=('completion',),
- disable=tuple(['success', 'failure']),
- )
- if timer.reached_and_reset():
- logger.warning('battle ')
- break
- return HookSignal.CONTINUE
- @cached_property
- def exclude_click_activity(self, areas: list[str] = None) -> RuleClickExclude:
- inputs = []
- for area in ['C_END_MESSAGE_RIGHT_TOP', 'C_END_ACTIVITY_REWARD']:
- click = getattr(self, area, None)
- if click is None:
- raise ValueError(f'Unknown success exclusion click: {area!r}')
- inputs.append(click)
- return RuleClickExclude(inputs, name='exclude_click_activity', strategy='rejection', distribution='uniform')
- def _bw_success_activity(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
- """
- 战斗结算是有 “获得奖励” 的适用
- """
- if not self.appear(self.I_UI_REWARD):
- return HookSignal.CONTINUE
- self.screenshot()
- if not self.appear(self.I_UI_REWARD):
- return HookSignal.CONTINUE
- logger.info('Win battle')
- timer = Timer(20).start()
- while 1:
- self.screenshot()
- # 不小心点到了具体的奖励,他会弹出这个物品的详细描述 里面必定包含有“获取途径”
- if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2) or self.appear(self.I_END_FIX_3):
- self.screenshot()
- if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2) or self.appear(self.I_END_FIX_3):
- self.click(self.C_REWARD_2, interval=2.5)
- continue
- if self.appear(self.I_UI_REWARD):
- if random.random() < 0.02:
- # 有一定的概率专门点击具体的奖励物品
- x, y = self.exclude_click_activity.coord_in_excluded(['C_END_ACTIVITY_REWARD'])
- self.device.click(x=x, y=y, control_name='reward_item')
- continue
- self.click(self.exclude_click_activity, interval=2.5)
- elif not self.appear(self.I_END_FIX_2):
- self.screenshot()
- if any([self.appear(self.I_UI_REWARD), self.appear(self.I_END_FIX_1), self.appear(self.I_END_FIX_2), self.appear(self.I_END_FIX_3)]):
- continue
- logger.info('Get all reward')
- pub.per_battle.success = BattleResult.SUCCESS
- return runtime.hook_enabled_update(
- enable=('completion', ),
- disable=tuple(['success', 'failure']),
- )
- if timer.reached_and_reset():
- logger.warning('battle ')
- break
- return HookSignal.CONTINUE
- # ------------------------------------------------------------------------------------------------------------------
- def battle_wait_with_strategy(self, *args, **kwargs) -> bool:
- """
- 理解 event + strategy 概念: 把战斗过程抽象为一系列触发事件以及对应的实现函数,也称hook。
- event + strategy 拼成了一个hook, 一个 event 在一次战斗过程中只能挂载一个 strategy
- 默认定义的 hook 有 BattleWaitPlan.HOOKS_DEFAULT = ('setup', 'completion', 'interrupt', 'success', 'failure', 'idle', 'prepare', 'preset', 'green', 'red', 'echo') 如果你填的没有,会使用默认的补全去的
- 这些 hook 跑在一个 while 里面,默认的调用顺序 BattleWaitPlan.SEQUENCE_DEFAULT = 'completion > interrupt > prepare > preset > green > red > echo > success > failure > idle'
- setup 没有跑在 while里面 而是在 while之前, 比如一个战斗过程可以表示为:
- setup_default()
- while 1:
- completion_default()
- interrupt_default()
- success_default()
- failure_default()
- idle_default()
- 围绕hook从两个维度来构建一个战斗系统, options 表示每一个hook的配置选项, public 和 private 表示每一个hook的共享和私有状态。分别有两个生命周期
- | 自定义 /生命周期 | 跨任务 | 任务共享 | 单次战斗 |
- | ------------- | ----- | --------------------- | ------------ |
- | strategy | 不做 | @battle_wait_strategy | with 上下文 |
- | options | 不做 | @battle_wait_options | with 上下文 |
- | public | cross | per_task | per_battle |
- | private | cross | per_task | per_battle |
- 三种自定义策略方法见 battle_wait_strategy 的 docstring。
- 自定义options方法见 battle_wait_options 的 docstring
- """
- battle_wait_plan = kwargs.get('battle_wait_plan')
- if battle_wait_plan is None:
- battle_wait_plan = BattleWaitPlan()
- setup_func = getattr(self, battle_wait_plan.function_setup_name, self._bw_setup_default)
- setup_func()
- runtime.hook_enabled_update(
- enable=(),
- disable=('setup',),
- )
- handlers = [getattr(self, func_name, None) for func_name in battle_wait_plan.sequence_function_names()]
- self.setup_hook(handlers=handlers)
- while True:
- self.screenshot()
- hook_enabled = runtime.hook_enabled()
- # self.state_show()
- for handler in handlers:
- if runtime.hook2event(handler.__name__) not in hook_enabled:
- continue
- result = handler()
- if handler.__name__.startswith('_bw_completion') and result == HookSignal.DONE:
- return runtime.pub_ctx.per_battle.success == BattleResult.SUCCESS
- if result == HookSignal.CONTINUE:
- continue
- @classmethod
- def setup_hook(cls, handlers: list[Callable]):
- """
- 默认的: 'setup', 'completion', 'interrupt', 'prepare', 'preset', 'green', 'red', 'echo', 'success', 'failure', 'idle'
- 战斗开始下关闭的 completion, 'preset', 'green', 'red', 'echo'
- 检测到进入准备阶段后开启 `preset` 来进入切换阵容,准备阶段结束后开启 'green', 'red', 'echo'
- """
- _hook_enabled = tuple(runtime.hook2event(h.__name__) for h in handlers if h)
- _hook_disabled = ('completion', 'preset', 'green', 'red', 'echo')
- runtime.hook_enabled_update(enable=_hook_enabled, disable=_hook_disabled)
- if __name__ == '__main__':
- from module.config.config import Config
- from module.device.device import Device
- from tasks.Component.GeneralBattle.general_battle import GeneralBattle
- c = Config('oas1')
- d = Device(c)
|