battle_wait.py 68 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644
  1. """
  2. ╔══════════════════════════════════════════════════════════════════════════════════╗
  3. ║ battle_wait.py 调用链地图 ║
  4. ╚══════════════════════════════════════════════════════════════════════════════════╝
  5. 装饰器双层栈(任务级,配置保存在当前上下文)
  6. ───────────────────────────────────────────────────────────────────
  7. @battle_wait_options(excludes=[...]) ← 覆盖 options
  8. @battle_wait_strategy(success='activity') ← 覆盖 plan
  9. ↓
  10. script_task.battle_wait()
  11. ↓
  12. ┌─────────────────────────────────────────────────────────┐
  13. │ battle_wait_options.__call__.inner │
  14. │ options → pub.options │
  15. │ finally: 还原上下文 options │
  16. └───────────────────────────┬─────────────────────────────┘
  17. ↓
  18. ┌─────────────────────────────────────────────────────────┐
  19. │ battle_wait_strategy.__call__.inner │
  20. │ current_plan = deepcopy(当前上下文或装饰器 plan).override(kwargs) │
  21. │ runtime.reset_per_battle() ← 每场新状态 │
  22. │ runtime.update_options() ← 按事件切片到各 pri │
  23. └───────────────────────────┬─────────────────────────────┘
  24. ↓
  25. ┌─────────────────────────────────────────────────────────┐
  26. │ battle_wait_with_strategy(plan) │
  27. │ │
  28. │ setup hook ──────────────────────── run 一次 │
  29. │ hook_enabled = sequence events − {completion} │
  30. │ │
  31. │ ┌─── while True ─────────────────────────────────┐ │
  32. │ │ screenshot() │ │
  33. │ │ for handler in sequence顺序: │ │
  34. │ │ if event not in hook_enabled: skip │ │
  35. │ │ result = handler() ──┐ │ │
  36. │ │ ↓ │ │ │
  37. │ │ DONE ────────────────┤ 结束循环 │ │
  38. │ │ CONTINUE ──→ 下一个 handler │ │
  39. │ │ │ │
  40. │ │ success/failure 结算后: │ │
  41. │ │ per_battle['success'] = BattleResult.X │ │
  42. │ │ enable=('completion',) ← completion 开门 │ │
  43. │ └───────────────────────────────────────────────────┘ │
  44. │ │
  45. │ return per_battle['success'] == BattleResult.SUCCESS │
  46. └─────────────────────────────────────────────────────────┘
  47. ┌──────────────────── Hook 调用 ────────────────────────────┐
  48. │ BattleWait.__new__ 遍历 MRO, _bw_* → runtime 包装 │
  49. │ handler() │
  50. │ → runtime.__call__(owner) │
  51. │ → func(owner, pub=pub_ctx, pri=pri_ctx[hook_name]) │
  52. └───────────────────────────────────────────────────────────────┘
  53. ┌──────────────────── 数据流 ─────────────────────────────────┐
  54. │ │
  55. │ battle_wait_options.current() (默认值 + 装饰器 + with) │
  56. │ ↓ pub.options = 上面整个 │
  57. │ ↓ pri[hook].options = 按事件名切片 │
  58. │ │
  59. │ pub (全局) pri (每个 hook 各一份) │
  60. │ ├─ cross ├─ cross │
  61. │ ├─ per_task ├─ per_task │
  62. │ ├─ per_battle ├─ per_battle │
  63. │ │ ├─ success │ │
  64. │ │ └─ hook_enabled │ │
  65. │ └─ options └─ options(本事件切片) │
  66. │ │
  67. │ 生命周期: │
  68. │ reset_per_task runtime 首次遇到新 task_owner │
  69. │ reset_per_battle 每次 battle_wait_strategy.__call__ │
  70. └─────────────────────────────────────────────────────────────┘
  71. """
  72. import random
  73. import time
  74. import math
  75. import difflib
  76. from copy import deepcopy
  77. from functools import wraps, update_wrapper
  78. from contextvars import ContextVar
  79. from dataclasses import dataclass, field, fields
  80. from typing import TypeVar, ParamSpec, Callable
  81. from enum import Enum, auto
  82. from cached_property import cached_property
  83. from module.logger import logger
  84. from module.base.timer import Timer
  85. from module.atom.click import RuleClickExclude
  86. from module.atom.image import RuleImage
  87. from module.base.utils import get_color, color_similar
  88. from tasks.base_task import BaseTask
  89. from tasks.Component.GeneralBattle.assets import GeneralBattleAssets
  90. from tasks.Component.GeneralBattle.config_general_battle import GreenMarkType, GreenMarkEnum
  91. P = ParamSpec('P')
  92. T = TypeVar('T')
  93. class HookSignal(Enum):
  94. CONTINUE = auto() # 无事发生
  95. BUSY = auto() # 处理了,继续
  96. DONE = auto() # 流程结束
  97. class BattleResult(Enum):
  98. SUCCESS = auto()
  99. FAILURE = auto()
  100. # ─── 默认值常量 ───────────────────────────────────
  101. # 战斗 hook 事件列表 & 默认调用顺序
  102. _HOOKS_DEFAULT: tuple[str, ...] = (
  103. 'setup', 'completion', 'interrupt', 'prepare', 'preset', 'green', 'red', 'echo', 'success', 'failure', 'idle',
  104. )
  105. _SEQUENCE_DEFAULT: str = 'completion > interrupt > prepare > preset > green > red > echo > success > failure >'
  106. # 跨任务/跨战斗状态的初始
  107. @dataclass
  108. class PerTaskState:
  109. """跨任务状态, 单个任务全程共享, reset_per_task 时重建"""
  110. count: int = 0
  111. @dataclass
  112. class PerBattleState:
  113. """跨战斗状态, 每场战斗独立, reset_per_battle 时重建"""
  114. success: BattleResult = BattleResult.FAILURE
  115. hook_enabled: set = field(default_factory=lambda: set(_HOOKS_DEFAULT) - {'completion'})
  116. # 每个 hook 事件的 options 数据类: pri[hook].options 就是这个实例。
  117. # 按 event 建模 —— 不管 success 挂的是什么 strategy, OptionSuccessDefault 都是它的配置。
  118. @dataclass
  119. class OptionSetupDefault:
  120. excludes: list | None = None
  121. @dataclass
  122. class OptionCompletionDefault:
  123. # 这里是为了, 确认结束战斗后退回到 “fire” 的界面
  124. check_imgs: list[RuleImage] = None
  125. # 兜底:check_imgs 都检测不到时,间隔点击的排除位
  126. excludes: list[str] = field(default_factory=list)
  127. @dataclass
  128. class OptionInterruptDefault:
  129. pass
  130. @dataclass
  131. class OptionSuccessDefault:
  132. excludes_1: list[str] = field(default_factory=lambda:
  133. [
  134. 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
  135. 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
  136. ])
  137. excludes_2: list[str] = field(default_factory=lambda:
  138. [
  139. 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
  140. 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
  141. 'C_END_1_1', 'C_END_1_2', 'C_END_1_3', 'C_END_1_4',
  142. 'C_END_1_5', 'C_END_1_6',
  143. ])
  144. @dataclass
  145. class OptionFailureDefault:
  146. pass
  147. @dataclass
  148. class OptionIdleDefault:
  149. pass
  150. @dataclass
  151. class OptionPrepareDefault:
  152. lock_team: bool = False
  153. @dataclass
  154. class OptionPresetDefault:
  155. preset_enable: bool = False
  156. preset_group: int = 1
  157. preset_team: int = 1
  158. @dataclass
  159. class OptionGreenDefault:
  160. green_enable: bool = False
  161. green_mark: GreenMarkType = GreenMarkType.GREEN_LEFT1
  162. green_mark_type: GreenMarkEnum = GreenMarkEnum.CHOOSE
  163. green_mark_name: str = ''
  164. @dataclass
  165. class OptionRedDefault:
  166. pass
  167. @dataclass
  168. class OptionEchoDefault:
  169. pass
  170. @dataclass
  171. class OptionRandomclickDefault:
  172. # 战斗开始后,首次允许执行前等待多久 每次战斗重抽存状态到 per_battle.start_delay_resolved
  173. start_delay: tuple[float, float] = (5.0, 10.0)
  174. # 两次执行之间的最小间隔, 每次执行的时候随机选一个,不存状态, 这个时间包括战斗结束后到下一轮的时间哈
  175. cooldown: tuple[float, float] = (30.0, 60.0)
  176. # 到达可执行时间后,本次实际执行的概率
  177. trigger_probability: float = 0.6
  178. # 本场战斗最多执行几次;元组表示开场时随机取一个上限, 每次战斗重抽一次,存状态到per_battle.execution_limit_resolved
  179. execution_limit: tuple[int, int] = (1, 2)
  180. def expected_random_clicks(
  181. self,
  182. battle_seconds: float = 30.0,
  183. gap_seconds: float = 10.0,
  184. battles: int = 100
  185. ) -> float:
  186. """估算多场战斗累计的期望随机动作执行次数(稳态解析模型)。
  187. 实际触发 14/115 ≈ 12.2% swipe 8 + random_click 6,平均约每 8.2 场实操一次
  188. 模型预测 单场 0.125 → 115 场 ≈ 14.4 次 (12.5%) expected_random_clicks(8.75, 6.24, 115)
  189. 这行是统计数据: 实际战斗时间,约 7.0 ~ 7.7 s:约 30 场,约 8.9 ~ 10.2 s:约 85 场。gap时间平均gap 约 6.24 s。 整体周期均值8.75 + 6.24 ≈ 15.0 s
  190. Args:
  191. battle_seconds: 单场战斗的持续时间(秒)。
  192. gap_seconds: 战斗结束到下一轮战斗的间隔(秒),冷却在该时段内持续流逝。
  193. battles: 统计的战斗场数。
  194. Returns:
  195. 累计 battles 场的期望随机动作执行次数。
  196. """
  197. cooldown_low, cooldown_high = self.cooldown
  198. cooldown_window_mean = cooldown_low + (math.sqrt(math.pi) / 2) * math.sqrt(cooldown_high - cooldown_low)
  199. start_delay_low, start_delay_high = self.start_delay
  200. start_delay_mean = (start_delay_low + start_delay_high) / 2
  201. attempts_per_battle = (battle_seconds + gap_seconds - start_delay_mean) / cooldown_window_mean
  202. attempts_can_execute = self.trigger_probability * attempts_per_battle
  203. attempts_can_execute_exp = math.exp(-attempts_can_execute)
  204. # 这里建模成泊松分布
  205. limit_low, limit_high = self.execution_limit
  206. per_battle = 0.0
  207. for limit in range(limit_low, limit_high + 1):
  208. probability_below = attempts_can_execute_exp # P(成功次数 < k)
  209. expected_with_limit = 0.0
  210. # E[min(H, limit)] = Σ_{k=1}^{limit} P(成功次数 ≥ k)
  211. for k in range(1, limit + 1):
  212. expected_with_limit += 1 - probability_below
  213. probability_below += attempts_can_execute_exp * attempts_can_execute ** k / math.factorial(k)
  214. per_battle += expected_with_limit
  215. per_battle /= limit_high - limit_low + 1
  216. return per_battle * battles
  217. # event → options 数据类, update_options 靠它按 hook2event 自动实例化分发
  218. _OPTION_CLASSES: dict[str, type] = {
  219. 'setup': OptionSetupDefault,
  220. 'completion': OptionCompletionDefault,
  221. 'interrupt': OptionInterruptDefault,
  222. 'success': OptionSuccessDefault,
  223. 'failure': OptionFailureDefault,
  224. 'idle': OptionIdleDefault,
  225. 'prepare': OptionPrepareDefault,
  226. 'preset': OptionPresetDefault,
  227. 'green': OptionGreenDefault,
  228. 'red': OptionRedDefault,
  229. 'echo': OptionEchoDefault,
  230. 'randomclick': OptionRandomclickDefault,
  231. }
  232. def _options_to_instances(raw: dict) -> dict:
  233. """把按 event 分组的原始 dict 转成对应的 Option 数据类实例(未知 key 过滤)"""
  234. result = {}
  235. for event, value in (raw or {}).items():
  236. opt_cls = _OPTION_CLASSES.get(event)
  237. if opt_cls is not None and isinstance(value, opt_cls):
  238. result[event] = value
  239. elif opt_cls is not None and isinstance(value, dict):
  240. known = {k: v for k, v in value.items() if k in opt_cls.__dataclass_fields__}
  241. result[event] = opt_cls(**known)
  242. else:
  243. result[event] = deepcopy(value)
  244. return result
  245. # pri 层的私有状态, 同样按 event 建模: pri[hook].per_task / per_battle 就是这个实例。
  246. # 字段按需声明 —— 有自定义私有状态的 strategy 往自己 event 的类里加字段。
  247. @dataclass
  248. class PerTaskSetup:
  249. pass
  250. @dataclass
  251. class PerTaskCompletion:
  252. pass
  253. @dataclass
  254. class PerTaskInterrupt:
  255. pass
  256. @dataclass
  257. class PerTaskSuccess:
  258. pass
  259. @dataclass
  260. class PerTaskFailure:
  261. pass
  262. @dataclass
  263. class PerTaskIdle:
  264. pass
  265. @dataclass
  266. class PerTaskPrepare:
  267. pass
  268. @dataclass
  269. class PerTaskPreset:
  270. # 一次任务类型触发一次,想要再次触发把done设置False
  271. done: bool = False
  272. @dataclass
  273. class PerTaskGreen:
  274. pass
  275. @dataclass
  276. class PerTaskRed:
  277. pass
  278. @dataclass
  279. class PerTaskEcho:
  280. pass
  281. @dataclass
  282. class PerTaskRandomclick:
  283. # 上一次点击的时间
  284. last_attempt_time: float = 0.0
  285. @dataclass
  286. class PerBattleSetup:
  287. pass
  288. @dataclass
  289. class PerBattleCompletion:
  290. click_stage_2: RuleClickExclude | None = None
  291. # 兜底点击节拍器:进入 completion 起算,满 8s 才首次点击,之后每 8s 一次
  292. fallback_timer: Timer | None = None
  293. @dataclass
  294. class PerBattleInterrupt:
  295. pass
  296. @dataclass
  297. class PerBattleSuccess:
  298. click_stage_1: RuleClickExclude | None = None
  299. click_stage_2: RuleClickExclude | None = None
  300. @classmethod
  301. def reward_exclude_click(
  302. cls,
  303. onwer,
  304. areas: list[str] = None,
  305. name: str = 'success_exclude_click'
  306. ) -> RuleClickExclude:
  307. inputs = []
  308. for area in areas:
  309. click = getattr(onwer, area, None)
  310. if click is None:
  311. raise ValueError(f'Unknown success exclusion click: {area!r}')
  312. inputs.append(click)
  313. return RuleClickExclude(inputs, name=name)
  314. @dataclass
  315. class PerBattleFailure:
  316. pass
  317. @dataclass
  318. class PerBattleIdle:
  319. pass
  320. @dataclass
  321. class PerBattlePrepare:
  322. done: bool = False
  323. timer: Timer = None
  324. @dataclass
  325. class PerBattlePreset:
  326. pass
  327. @dataclass
  328. class PerBattleGreen:
  329. # 本场战斗完成
  330. done: bool = False
  331. @dataclass
  332. class PerBattleRed:
  333. pass
  334. @dataclass
  335. class PerBattleEcho:
  336. pass
  337. @dataclass
  338. class PerBattleRandomclick:
  339. # 本场战斗已执行的随机动作次数
  340. execution_count: int = 0
  341. # 本场战斗的执行次数上限,首次拦截时从 execution_limit 随机解析
  342. execution_limit_resolved: int = 0
  343. # 本场战斗的首次执行延迟,首次拦截时从 start_delay 随机解析
  344. start_delay_resolved: float = 0.0
  345. # 首次允许执行的时间戳(0.0 表示尚未解析,首次拦截时写入)
  346. first_allowed_time: float = 0.0
  347. # event → pri 私有状态数据类
  348. _PER_TASK_CLASSES: dict[str, type] = {
  349. 'setup': PerTaskSetup,
  350. 'completion': PerTaskCompletion,
  351. 'interrupt': PerTaskInterrupt,
  352. 'success': PerTaskSuccess,
  353. 'failure': PerTaskFailure,
  354. 'idle': PerTaskIdle,
  355. 'prepare': PerTaskPrepare,
  356. 'preset': PerTaskPreset,
  357. 'green': PerTaskGreen,
  358. 'red': PerTaskRed,
  359. 'echo': PerTaskEcho,
  360. 'randomclick': PerTaskRandomclick,
  361. }
  362. _PER_BATTLE_CLASSES: dict[str, type] = {
  363. 'setup': PerBattleSetup,
  364. 'completion': PerBattleCompletion,
  365. 'interrupt': PerBattleInterrupt,
  366. 'success': PerBattleSuccess,
  367. 'failure': PerBattleFailure,
  368. 'idle': PerBattleIdle,
  369. 'prepare': PerBattlePrepare,
  370. 'preset': PerBattlePreset,
  371. 'green': PerBattleGreen,
  372. 'red': PerBattleRed,
  373. 'echo': PerBattleEcho,
  374. 'randomclick': PerBattleRandomclick,
  375. }
  376. # ────────────────────────────────────────────
  377. class BattleWaitPlan:
  378. """
  379. 就是一个超级大的状态机,这里拆成了很多hook
  380. """
  381. HOOKS_DEFAULT = _HOOKS_DEFAULT
  382. SEQUENCE_DEFAULT = _SEQUENCE_DEFAULT
  383. def __init__(self, *arg, **kwargs):
  384. extra_sequence: str = ''
  385. #
  386. for event_strategy in arg:
  387. if not isinstance(event_strategy, str):
  388. raise TypeError(
  389. 'Battle wait hook must be a string in '
  390. '"event_strategy" format; '
  391. f'got {event_strategy!r}'
  392. )
  393. if not event_strategy:
  394. raise ValueError(
  395. 'Battle wait hook cannot be empty; '
  396. 'expected "event_strategy" format'
  397. )
  398. event, separator, strategy = event_strategy.partition('_')
  399. if not separator or not event or not strategy:
  400. raise ValueError(
  401. 'Invalid battle wait hook '
  402. f'{event_strategy!r}; expected "event_strategy" format'
  403. )
  404. setattr(self, event, strategy)
  405. if event not in self.HOOKS_DEFAULT:
  406. extra_sequence += f'{event} > '
  407. #
  408. for event, strategy in kwargs.items():
  409. if not event or not isinstance(event, str) or not isinstance(strategy, str):
  410. raise TypeError(f'{event} or {strategy} is not a string')
  411. if getattr(self, event, None) is not None:
  412. raise ValueError(
  413. f'Battle wait event {event!r} was configured more than once'
  414. )
  415. setattr(self, event, strategy)
  416. if event not in self.HOOKS_DEFAULT:
  417. extra_sequence += f'{event} > '
  418. # 补齐默认的
  419. for event in self.HOOKS_DEFAULT:
  420. if getattr(self, event, None) is None:
  421. setattr(self, event, 'default')
  422. #
  423. self.sequence = kwargs.get('sequence', None)
  424. if self.sequence is None:
  425. self.sequence = f'{BattleWaitPlan.SEQUENCE_DEFAULT} {extra_sequence} idle'
  426. if not isinstance(self.sequence, str):
  427. raise TypeError(
  428. 'Battle wait sequence must be a string containing event names '
  429. "separated by '>'; "
  430. f'got {self.sequence!r}'
  431. )
  432. self.sequence: str = self.sequence.replace(' ', '').replace('\n', '').replace('\r', '').replace('setup', '')
  433. for event_name in self.sequence.split('>'):
  434. event_name = event_name.strip()
  435. if event_name == "sequence":
  436. continue
  437. if getattr(self, event_name, None) is None:
  438. raise ValueError(
  439. f'Unknown battle wait event {event_name!r} in '
  440. f'sequence {self.sequence!r}'
  441. )
  442. for event in self.HOOKS_DEFAULT:
  443. if event != 'setup' and event not in self.sequence:
  444. raise ValueError(
  445. f'Battle wait sequence is missing required event {event!r}; '
  446. f'got {self.sequence!r}'
  447. )
  448. def __str__(self):
  449. lines = [f"{self.__class__.__name__}:", f" sequence: {self.sequence}", " hooks:"]
  450. for event_name in self.HOOKS_DEFAULT:
  451. strategy_name = getattr(self, event_name, None)
  452. if callable(strategy_name):
  453. if hasattr(strategy_name, '__name__'):
  454. func_name = strategy_name.__name__
  455. else:
  456. func_name = repr(strategy_name)
  457. val_str = f"<function {func_name}>"
  458. else:
  459. val_str = repr(strategy_name)
  460. lines.append(f" {event_name}: {val_str}")
  461. return "\n".join(lines)
  462. def __repr__(self):
  463. return self.__str__()
  464. @property
  465. def function_setup_name(self) -> str:
  466. if getattr(self, 'setup', None) is None:
  467. self.setup = 'default'
  468. return f'_bw_setup_{self.setup}'
  469. def sequence_function_names(self) -> list[str]:
  470. """
  471. 注意,这里是没有setup的
  472. """
  473. function_names = []
  474. for event_name in self.sequence.split('>'):
  475. event_name = event_name.strip()
  476. if not event_name:
  477. continue
  478. if not hasattr(self, event_name):
  479. raise ValueError(f'Unknown battle wait event: {event_name}')
  480. strategy_name = getattr(self, event_name)
  481. if not isinstance(strategy_name, str) or not strategy_name:
  482. raise ValueError(
  483. f'Invalid strategy for battle wait event {event_name}: '
  484. f'{strategy_name!r}'
  485. )
  486. function_names.append(f'_bw_{event_name}_{strategy_name}')
  487. return function_names
  488. def override(self, *arg, **kwargs):
  489. if kwargs:
  490. raise TypeError(
  491. 'sequence is not supported' if 'sequence' in kwargs else f'Unexpected keyword arguments: {tuple(kwargs)}')
  492. if not arg:
  493. return self
  494. events = [event for event in self.sequence.split('>') if event]
  495. if 'idle' not in events:
  496. raise ValueError(f'Sequence {self.sequence!r} must contain "idle"')
  497. idle_index = events.index('idle')
  498. for event_strategy in arg:
  499. if not isinstance(event_strategy, str):
  500. raise TypeError(f'event_strategy must be a string, got {event_strategy!r}')
  501. event, separator, strategy = event_strategy.partition('_')
  502. if not separator or not event or not strategy:
  503. raise ValueError(f'Invalid event_strategy: {event_strategy!r}')
  504. if event == 'sequence':
  505. raise ValueError('sequence cannot be overridden')
  506. is_new = not hasattr(self, event)
  507. setattr(self, event, strategy)
  508. if is_new:
  509. events.insert(idle_index, event)
  510. idle_index += 1
  511. self.sequence = '>'.join(events)
  512. return self
  513. class battle_wait_strategy:
  514. """每个装饰器保存自己的策略,with 在当前上下文内临时覆盖。
  515. Options are provided independently by battle_wait_options. Dynamic
  516. random_click_swipt_enable remains scoped to one call for legacy tasks.
  517. """
  518. _context = ContextVar('battle_wait_strategy_context', default=None)
  519. def __init__(self, *arg, **kwargs):
  520. self.battle_wait_plan = BattleWaitPlan(*arg, **kwargs)
  521. self._context_tokens = ContextVar('battle_wait_strategy_tokens', default=())
  522. def __enter__(self):
  523. token = self._context.set(self.battle_wait_plan)
  524. self._context_tokens.set(self._context_tokens.get() + (token,))
  525. return self
  526. def __exit__(self, *exc):
  527. tokens = self._context_tokens.get()
  528. self._context.reset(tokens[-1])
  529. self._context_tokens.set(tokens[:-1])
  530. return False
  531. def __str__(self):
  532. scope = 'temporary' if self._context_tokens.get() else 'decorator'
  533. return (
  534. f'{type(self).__name__}(scope={scope}, '
  535. f'plan={self.battle_wait_plan}, active_plan={self._context.get()})'
  536. )
  537. def __repr__(self):
  538. return self.__str__()
  539. def _recreate_cm(self):
  540. return self
  541. def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
  542. @wraps(func)
  543. def inner(owner, *args: P.args, **kwargs: P.kwargs) -> T:
  544. current_plan = self._context.get() or self.battle_wait_plan
  545. if kwargs.get('random_click_swipt_enable'):
  546. current_plan = deepcopy(current_plan)
  547. current_plan.override('randomclick_default')
  548. options = battle_wait_options.current()
  549. runtime.reset_per_battle()
  550. runtime.update_options(options, plan=current_plan)
  551. return func(owner, battle_wait_plan=current_plan, options=options)
  552. return inner
  553. class battle_wait_options:
  554. """按事件设置 options;with 覆盖装饰器值,退出后恢复调用前的上下文。
  555. Both dict values and the corresponding Option dataclass instances are
  556. accepted. Defaults and overrides are copied for every battle.
  557. """
  558. options: dict = {event: cls() for event, cls in _OPTION_CLASSES.items()}
  559. _context = ContextVar('battle_wait_options_context', default=None)
  560. _decorator_options = ContextVar('battle_wait_decorator_options', default=None)
  561. def __init__(self, **kwargs):
  562. self._overrides = deepcopy(_options_to_instances(kwargs))
  563. self._context_tokens = ContextVar('battle_wait_options_tokens', default=())
  564. @classmethod
  565. def current(cls) -> dict:
  566. merged = deepcopy(cls.options)
  567. merged.update(deepcopy(cls._decorator_options.get() or {}))
  568. merged.update(deepcopy(cls._context.get() or {}))
  569. return merged
  570. def __enter__(self):
  571. merged = deepcopy(self._context.get() or {})
  572. merged.update(deepcopy(self._overrides))
  573. token = self._context.set(merged)
  574. self._context_tokens.set(self._context_tokens.get() + (token,))
  575. return self
  576. def __exit__(self, *exc):
  577. tokens = self._context_tokens.get()
  578. self._context.reset(tokens[-1])
  579. self._context_tokens.set(tokens[:-1])
  580. return False
  581. def __str__(self):
  582. scope = 'temporary' if self._context_tokens.get() else 'decorator'
  583. return (
  584. f'{type(self).__name__}(scope={scope}, '
  585. f'overrides={self._overrides}, options={self.current()})'
  586. )
  587. def __repr__(self):
  588. return self.__str__()
  589. def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
  590. @wraps(func)
  591. def inner(owner, *args: P.args, **kwargs: P.kwargs) -> T:
  592. token = self._decorator_options.set(deepcopy(self._overrides))
  593. try:
  594. return func(owner, *args, **kwargs)
  595. finally:
  596. self._decorator_options.reset(token)
  597. return inner
  598. @dataclass
  599. class PublicContext:
  600. cross: dict = field(default_factory=dict)
  601. per_task: PerTaskState = field(default_factory=PerTaskState)
  602. per_battle: PerBattleState = field(default_factory=PerBattleState)
  603. options: dict = field(default_factory=dict) # 所有hook的options
  604. @dataclass
  605. class PrivateContext:
  606. cross: dict = field(default_factory=dict)
  607. per_task: dict = field(default_factory=dict)
  608. per_battle: dict = field(default_factory=dict)
  609. options: dict = field(default_factory=dict) # 单个hook的options
  610. class runtime:
  611. task_owner = None
  612. pri_ctx: dict[str, PrivateContext] = {}
  613. pub_ctx: PublicContext = None
  614. def __init__(self, func: Callable):
  615. self.func = func
  616. self.hook_name = func.__name__
  617. update_wrapper(self, func)
  618. def __get__(self, obj, objtype=None):
  619. if obj is None:
  620. return self
  621. runtime._ensure_pub_default()
  622. runtime._ensure_pri_default(self.hook_name)
  623. @wraps(self.func)
  624. def bound(*args, **kwargs):
  625. return self(obj, *args, **kwargs)
  626. return bound
  627. def __call__(self, owner, *args, **kwargs):
  628. # 新任务重置一下
  629. if runtime.task_owner is None or owner is not runtime.task_owner:
  630. runtime.task_owner = owner
  631. runtime.reset_per_task()
  632. runtime._ensure_pub_default()
  633. runtime._ensure_pri_default(self.hook_name)
  634. return self.func(owner, pub=runtime.pub_ctx, pri=runtime.pri_ctx[self.hook_name])
  635. def __str__(self):
  636. pub = runtime.pub_ctx or PublicContext()
  637. pri = runtime.pri_ctx.get(self.hook_name) or PrivateContext()
  638. def _keys(d):
  639. if isinstance(d, dict):
  640. return ','.join(d.keys()) or '-'
  641. 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)):
  642. return ','.join(d.__dataclass_fields__) or '-'
  643. return str(d)
  644. return (
  645. f'runtime({self.hook_name}) '
  646. f'pub[c:{_keys(pub.cross)},t:{_keys(pub.per_task)},b:{_keys(pub.per_battle)},o:{_keys(pub.options)}] '
  647. f'pri[c:{_keys(pri.cross)},t:{_keys(pri.per_task)},b:{_keys(pri.per_battle)},o:{_keys(pri.options)}]'
  648. )
  649. def __repr__(self):
  650. return self.__str__()
  651. @classmethod
  652. def reset_per_task(cls):
  653. cls._ensure_pub_default()
  654. cls.pub_ctx.per_task = PerTaskState()
  655. for hook_name, ctx in cls.pri_ctx.items():
  656. event = cls.hook2event(hook_name)
  657. cls_type = _PER_TASK_CLASSES.get(event, dict)
  658. ctx.per_task = cls_type()
  659. @classmethod
  660. def reset_per_battle(cls):
  661. cls._ensure_pub_default()
  662. cls.pub_ctx.per_battle = PerBattleState()
  663. for hook_name, ctx in cls.pri_ctx.items():
  664. event = cls.hook2event(hook_name)
  665. cls_type = _PER_BATTLE_CLASSES.get(event, dict)
  666. ctx.per_battle = cls_type()
  667. @classmethod
  668. def _ensure_pub_default(cls):
  669. if cls.pub_ctx is None:
  670. cls.pub_ctx = PublicContext()
  671. @classmethod
  672. def _ensure_pri_default(cls, name):
  673. if name not in cls.pri_ctx:
  674. event = cls.hook2event(name)
  675. cls.pri_ctx[name] = PrivateContext(
  676. per_task=_PER_TASK_CLASSES.get(event, dict)(),
  677. per_battle=_PER_BATTLE_CLASSES.get(event, dict)(),
  678. )
  679. @classmethod
  680. def hook2event(cls, func_name: str) -> str:
  681. # '_bw_success_soul' -> 'success'(strategy 名里带下划线也能正确切出事件名)
  682. return func_name[len('_bw_'):].split('_', 1)[0]
  683. @classmethod
  684. def event2hook(cls, event_name: str, strategy_name: str) -> str:
  685. return f'_bw_{event_name}_{strategy_name}'
  686. @classmethod
  687. def update_options(cls, options: dict[str, object] | None, plan: BattleWaitPlan):
  688. """
  689. 输入 options = {
  690. 'setup': OptionSetupDefault(excludes=None),
  691. 'completion': OptionCompletionDefault(),
  692. 'prepare': OptionPrepareDefault(lock_team=True),
  693. 'preset': OptionPresetDefault(preset_enable=True, preset_group=1, preset_team=2),
  694. 'success': OptionSuccessDefault(), # 没传字段 → 全默认
  695. ... # 其余 event 都有
  696. }
  697. 设置值, 这里key没有直接使用 event 而是 _bw_event_strategy 是因为可能这场战斗和下一场战斗的options不同,需要区分开来
  698. cls.pub_ctx.options = options // 直接的一个引用
  699. runtime.pri_ctx['_bw_prepare_default'].options == OptionPrepareDefault(lock_team=True)
  700. runtime.pri_ctx['_bw_preset_default'].options == OptionPresetDefault(preset_enable=True, preset_group=1, preset_team=2)
  701. runtime.pri_ctx['_bw_success_default'].options == OptionSuccessDefault()
  702. """
  703. cls._ensure_pub_default()
  704. if not isinstance(options, dict):
  705. raise
  706. cls.pub_ctx.options = options
  707. if plan is not None:
  708. for hook in [plan.function_setup_name] + plan.sequence_function_names():
  709. cls._ensure_pri_default(hook)
  710. opt = options.get(cls.hook2event(hook))
  711. ctx = cls.pri_ctx[hook]
  712. ctx.options = opt if isinstance(opt, cls._option_class(hook)) \
  713. else cls._option_class(hook)()
  714. @classmethod
  715. def _option_class(cls, hook_name: str) -> type:
  716. return _OPTION_CLASSES.get(cls.hook2event(hook_name)) or dict
  717. @classmethod
  718. def hook_enabled(cls) -> set:
  719. _hook_enabled = cls.pub_ctx.per_battle.hook_enabled
  720. if not _hook_enabled:
  721. raise
  722. return _hook_enabled
  723. @classmethod
  724. def hook_enabled_update(cls, enable: tuple[str, ...], disable: tuple[str, ...]) -> HookSignal:
  725. """
  726. hook_enabled 的更新只能在 BattleWait 上。不可以在 battle_wait_options 或者 battle_wait_strategy 上
  727. """
  728. if enable:
  729. cls.pub_ctx.per_battle.hook_enabled.update(enable)
  730. if disable:
  731. cls.pub_ctx.per_battle.hook_enabled.difference_update(disable)
  732. return HookSignal.CONTINUE
  733. def randomclick_gate(func: Callable) -> Callable:
  734. """
  735. randomclick 专属拦截装饰器,零自身状态。全部状态读写透传进来的 pri:
  736. - per_battle(PerBattleRandomclick): 开场 delay/上限/次数,每场重置
  737. - per_task (PerTaskRandomclick): cooldown 上次尝试时刻,跨战斗
  738. 四道门全过才放行 func 真正执行随机动作。
  739. """
  740. @wraps(func)
  741. def wrapper(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  742. options = pub.options.get('randomclick')
  743. state_battle = pri.per_battle
  744. state_task = pri.per_task
  745. if not isinstance(options, OptionRandomclickDefault):
  746. raise TypeError(f"randomclick options must be OptionRandomclickDefault, got {type(options)!r}")
  747. if not isinstance(state_battle, PerBattleRandomclick):
  748. raise TypeError(f"randomclick per_battle state must be PerBattleRandomclick, got {type(state_battle)!r}")
  749. if not isinstance(state_task, PerTaskRandomclick):
  750. raise TypeError(f"randomclick per_task state must be PerTaskRandomclick, got {type(state_task)!r}")
  751. if not self.is_in_battle(is_screenshot=False):
  752. return HookSignal.CONTINUE
  753. now = time.time()
  754. # 第一次调用:解析 start_delay 和 execution_limit(只解析一次)
  755. if state_battle.first_allowed_time == 0.0:
  756. state_battle.start_delay_resolved = random.uniform(*options.start_delay)
  757. state_battle.execution_limit_resolved = random.randint(*options.execution_limit)
  758. state_battle.first_allowed_time = now + state_battle.start_delay_resolved
  759. return HookSignal.CONTINUE
  760. # Gate 1: start_delay 未到
  761. if now < state_battle.first_allowed_time:
  762. return HookSignal.CONTINUE
  763. # Gate 2: execution_limit 已满
  764. if state_battle.execution_count >= state_battle.execution_limit_resolved:
  765. return HookSignal.CONTINUE
  766. # Gate 3: cooldown 未到(记在 per_task 跨战斗,秒掉的小战斗也能续上间隔)
  767. if now - state_task.last_attempt_time < random.uniform(*options.cooldown):
  768. return HookSignal.CONTINUE
  769. # 记录本次尝试时间(无论概率是否通过,都算一次 cooldown 周期)
  770. state_task.last_attempt_time = now
  771. # Gate 4: trigger_probability 概率判定
  772. if random.random() >= options.trigger_probability:
  773. return HookSignal.CONTINUE
  774. # 通过全部四道门,放行真正执行随机动作
  775. state_battle.execution_count += 1
  776. return func(self, pub, pri)
  777. return wrapper
  778. class BattleWait(BaseTask, GeneralBattleAssets):
  779. def __new__(cls, *args, **kwargs):
  780. for klass in reversed(cls.__mro__):
  781. # 找遍整个继承链,从父到子
  782. if klass is object:
  783. continue
  784. if klass.__dict__.get('_runtime_auto_decorated'):
  785. continue
  786. klass._runtime_auto_decorated = True
  787. for name, attr in list(vars(klass).items()):
  788. if name.startswith('_bw_') and callable(attr) and not isinstance(attr, runtime):
  789. setattr(klass, name, runtime(attr))
  790. return super().__new__(cls)
  791. # ----------------------------------------------------------------------------------------------------------------
  792. # loadout:一行一个 event(event + strategy + options),全量快照,默认值来源 battle_wait.py,不裸写:
  793. # strategies: dict[event -> strategy],有序,key 是 hook 名,支持 prepare='default' 这类逐 hook 设置
  794. # options: dict[event -> Option 实例],全部字段可见
  795. # 跑法:
  796. # with battle_wait_strategy(**strategies), battle_wait_options(**options):
  797. # self.battle_wait()
  798. # ----------------------------------------------------------------------------------------------------------------
  799. @classmethod
  800. def loadout_default(cls) -> tuple[dict, dict]:
  801. """
  802. 默认策略 + 默认 options 的全量快照(不是 diff,是完整的)。
  803. 策略来源 BattleWaitPlan()(battle_wait.py),按 sequence 顺序展开成 dict;
  804. options 来源 battle_wait_options.current()(含当前上下文覆盖)。
  805. """
  806. plan = BattleWaitPlan()
  807. strategies = {e: getattr(plan, e) for e in plan.sequence.replace(' ', '').split('>') if e}
  808. options = battle_wait_options.current()
  809. return strategies, options
  810. @classmethod
  811. def loadout_show(cls, loadout: tuple[dict, dict] | None = None) -> None:
  812. """
  813. 输出类似:
  814. event strategy options
  815. idle default OptionIdleDefault()
  816. prepare default OptionPrepareDefault(lock_team=False)
  817. preset default OptionPresetDefault(preset_enable=False, preset_group=1, preset_team=1)
  818. green default OptionGreenDefault(green_enable=False, green_mark=<GreenMarkType.GREEN_LEFT1: 'green_left1'>)
  819. """
  820. strategies, options = loadout if loadout is not None else cls.loadout_default()
  821. order = []
  822. seen = set()
  823. for event in options:
  824. order.append(event)
  825. seen.add(event)
  826. for event in strategies:
  827. if event not in seen:
  828. order.append(event)
  829. print('=' * 64)
  830. print(f'{"event":<12}{"strategy":<12}options')
  831. for event in order:
  832. print(f'{event:<12}{strategies.get(event, "default"):<12}{options.get(event)!r}')
  833. print('=' * 64)
  834. @classmethod
  835. def state_show(cls) -> None:
  836. """
  837. 输出类似:
  838. event strategy enabled per_task | per_battle
  839. completion default True {} | {}
  840. idle default True {} | {}
  841. prepare default False {} | {'done': True}
  842. ----------------------------------------------------------------
  843. pub per_task count 等全局跨任务状态
  844. pub per_battle success / hook_enabled 等全局跨战斗状态
  845. """
  846. runtime._ensure_pub_default()
  847. enabled = runtime.hook_enabled()
  848. def _nondefault(o):
  849. if isinstance(o, dict):
  850. return dict(o)
  851. return {f.name: getattr(o, f.name) for f in fields(o) if getattr(o, f.name) != f.default}
  852. options = cls.loadout_default()[1]
  853. order = list(options)
  854. hooks = sorted(
  855. runtime.pri_ctx,
  856. key=lambda h: order.index(runtime.hook2event(h)) if runtime.hook2event(h) in order else len(order),
  857. )
  858. print('=' * 64)
  859. print(f'{"event":<12}{"strategy":<12}{"enabled":<10}per_task | per_battle')
  860. for hook in hooks:
  861. event = runtime.hook2event(hook)
  862. strategy = hook[len(f'_bw_{event}_'):]
  863. ctx = runtime.pri_ctx[hook]
  864. print(f'{event:<12}{strategy:<12}{str(event in enabled):<10}'
  865. f'{_nondefault(ctx.per_task)} | {_nondefault(ctx.per_battle)}')
  866. print('-' * 64)
  867. pub = runtime.pub_ctx
  868. print(f'{"pub":<12}{"":<12}{"per_task":<10}{_nondefault(pub.per_task)}')
  869. print(f'{"pub":<12}{"":<12}{"per_battle":<10}{_nondefault(pub.per_battle)}')
  870. print('=' * 64)
  871. time.sleep(0.6)
  872. # ------------------------------------------------------------------------------------------------------------------
  873. # build in
  874. # ------------------------------------------------------------------------------------------------------------------
  875. def _bw_setup_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  876. self.C_REWARD_1.name = 'C_REWARD'
  877. self.C_REWARD_2.name = 'C_REWARD'
  878. self.C_REWARD_3.name = 'C_REWARD'
  879. self.device.stuck_record_add('BATTLE_STATUS_S')
  880. self.device.click_record_clear()
  881. logger.info('Start battle process')
  882. return HookSignal.DONE
  883. def _bw_completion_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  884. logger.info('Battle completion process')
  885. state = pri.per_battle
  886. options = pri.options
  887. if not isinstance(state, PerBattleCompletion) or not isinstance(options, OptionCompletionDefault):
  888. raise
  889. if options.check_imgs is None:
  890. pub.per_task.count += 1
  891. # self.current_count += 1 # 兼容旧的计数
  892. return HookSignal.DONE
  893. # 如果需要进一步确认
  894. if not isinstance(options.check_imgs, list):
  895. raise
  896. appears = [self.appear(check) for check in options.check_imgs]
  897. if any(appears):
  898. pub.per_task.count += 1
  899. # self.current_count += 1 # 兼容旧的计数
  900. return HookSignal.DONE
  901. # check_imgs 全没出现 → 兜底点击回退界面:进入 completion 满 8s 才首次点击,之后每 8s 一次
  902. if state.fallback_timer is None:
  903. state.fallback_timer = Timer(8).start()
  904. if not isinstance(state.fallback_timer, Timer):
  905. raise
  906. if not state.fallback_timer.reached():
  907. return HookSignal.CONTINUE
  908. state.fallback_timer.reset()
  909. if state.click_stage_2 is None:
  910. state.click_stage_2 = PerBattleSuccess.reward_exclude_click(self, options.excludes, name='completion_exclude_click')
  911. x, y = state.click_stage_2.coord()
  912. self.device.click(x=x, y=y, control_name='completion_exclude_click')
  913. return HookSignal.CONTINUE
  914. def _bw_interrupt_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  915. # 比如 御魂溢出
  916. return HookSignal.CONTINUE
  917. def _bw_success_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  918. state = pri.per_battle
  919. options = pri.options
  920. if not isinstance(state, PerBattleSuccess) or not isinstance(options, OptionSuccessDefault):
  921. raise
  922. if state.click_stage_1 is None:
  923. state.click_stage_1 = PerBattleSuccess.reward_exclude_click(self, pri.options.excludes_1, name='reward_exclude_click_1')
  924. if state.click_stage_2 is None:
  925. state.click_stage_2 = PerBattleSuccess.reward_exclude_click(self, pri.options.excludes_2, name='reward_exclude_click_2')
  926. if self.appear_then_click(self.I_WIN, interval=0.8):
  927. self.click(state.click_stage_1)
  928. return HookSignal.CONTINUE
  929. appear_ghost, appear_reward, appear_gold, appear_skin = (
  930. self.appear(self.I_GREED_GHOST),
  931. self.appear(self.I_REWARD),
  932. self.appear(self.I_REWARD_GOLD),
  933. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  934. )
  935. if not any([appear_ghost, appear_reward, appear_gold, appear_skin]):
  936. return HookSignal.CONTINUE
  937. logger.info('Win battle')
  938. timer = Timer(20).start()
  939. while 1:
  940. self.screenshot()
  941. # 不小心点到了具体的奖励,他会弹出这个物品的详细描述 里面必定包含有“获取途径”
  942. if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2):
  943. self.click(self.C_REWARD_2, interval=1.5)
  944. _appear_ghost, _appear_reward, _appear_gold, _appear_skin = (
  945. self.appear(self.I_GREED_GHOST, threshold=0.6),
  946. self.appear(self.I_REWARD),
  947. self.appear(self.I_REWARD_GOLD),
  948. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  949. )
  950. # logger.info(f'_appear_ghost: {_appear_ghost} _appear_reward: {_appear_reward} _appear_gold: {_appear_gold} _appear_skin: {_appear_skin}')
  951. if any([_appear_ghost, _appear_reward, _appear_gold, _appear_skin]):
  952. if random.random() < 0.02:
  953. # 有一定的概率专门点击具体的奖励物品
  954. x, y = state.click_stage_2.coord_in_excluded(None)
  955. self.device.click(x=x, y=y, control_name='reward_item')
  956. continue
  957. self.click(state.click_stage_2, interval=1.5)
  958. else:
  959. logger.info('Get all reward')
  960. pub.per_battle.success = BattleResult.SUCCESS
  961. return runtime.hook_enabled_update(
  962. enable=('completion',),
  963. disable=tuple(['success', 'failure']),
  964. )
  965. if timer.reached_and_reset():
  966. logger.warning('battle')
  967. break
  968. return HookSignal.CONTINUE
  969. def _bw_failure_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  970. if self.appear(self.I_FALSE, threshold=0.8):
  971. logger.warning('False battle')
  972. self.ui_click_until_disappear(self.I_FALSE)
  973. pub.per_battle.success = BattleResult.FAILURE
  974. return runtime.hook_enabled_update(
  975. enable=('completion', ),
  976. disable=tuple(['success', 'failure']),
  977. )
  978. return HookSignal.CONTINUE
  979. def _bw_idle_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  980. return HookSignal.CONTINUE
  981. def _bw_prepare_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  982. pri_options = pri.options if isinstance(pri.options, OptionPrepareDefault) else None
  983. state = pri.per_battle if isinstance(pri.per_battle, PerBattlePrepare) else None
  984. if pri_options is None or state is None:
  985. return HookSignal.CONTINUE
  986. if state.done:
  987. return HookSignal.CONTINUE
  988. # 活动直接进入新战斗流程,不再经过 GeneralBattle.battle_before。
  989. # 先关闭御魂不一致提示,避免遮挡准备按钮或误触绿标。
  990. if self.appear_then_click(self.I_DISABLE_7DAYS_DIFF_SOUL, interval=0.6):
  991. return HookSignal.CONTINUE
  992. if self.appear_then_click(self.I_CONFIRM_CLOSE_DIFF_SOUL, interval=0.6):
  993. return HookSignal.CONTINUE
  994. # 如果是锁队伍的,就直接跳过, 开启后面的 绿标,红标,应声虫
  995. # 如果确定进入正式战斗中了 也是同样的操作
  996. if pri_options.lock_team or self.is_in_real_battle(False):
  997. logger.info('Prepare stage finish')
  998. state.done = True
  999. return runtime.hook_enabled_update(
  1000. enable=('green', 'red', 'echo'),
  1001. disable=('prepare', 'preset'),
  1002. )
  1003. # 如果开启了切阵容,就等执行切阵容完成(切阵容操作会自动把准备按钮给按消失), 这里会等8秒钟,时间一到自动关闭准备阶段
  1004. # 切阵容按 per_task 是一次性的:本任务已切过(done)就不再开定时器等,直接按准备开打
  1005. preset_done = next((
  1006. ctx.per_task.done
  1007. for hook, ctx in runtime.pri_ctx.items()
  1008. if runtime.hook2event(hook) == 'preset' and isinstance(ctx.per_task, PerTaskPreset)
  1009. ), False)
  1010. if pub.options.get('preset', OptionPresetDefault).preset_enable and not preset_done:
  1011. if state.timer is None:
  1012. state.timer = Timer(6).start()
  1013. # return HookSignal.CONTINUE
  1014. return runtime.hook_enabled_update(
  1015. enable=('preset',),
  1016. disable=(),
  1017. )
  1018. # 时间没到就一直等吧
  1019. if not state.timer.reached():
  1020. return HookSignal.CONTINUE
  1021. # 计时8秒时间到了, 那就一直按 准备按钮 直到消失去
  1022. # 不要把这行代码合并到下面去
  1023. self.appear_then_click(self.I_PREPARE_HIGHLIGHT, interval=0.8)
  1024. return HookSignal.CONTINUE
  1025. # 没有切阵容那就一直按 准备按钮 直到消失去]
  1026. self.appear_then_click(self.I_PREPARE_HIGHLIGHT, interval=1)
  1027. return HookSignal.CONTINUE
  1028. def _bw_preset_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1029. """
  1030. 切阵容:切换预设队伍,每个任务只执行一次
  1031. """
  1032. pri_options = pri.options if isinstance(pri.options, OptionPresetDefault) else None
  1033. state = pri.per_task if isinstance(pri.per_task, PerTaskPreset) else None
  1034. if pri_options is None or state is None:
  1035. return HookSignal.CONTINUE
  1036. if not pri_options.preset_enable or state.done:
  1037. return HookSignal.CONTINUE
  1038. logger.info("Preset is enable")
  1039. # 点击预设按钮
  1040. while 1:
  1041. self.screenshot()
  1042. if self.appear(self.I_PRESET_ENSURE):
  1043. break
  1044. # 首个队伍没有满足5个式神,未出现预设按钮的情况下跳出循环
  1045. if self.appear(self.I_PRESENT_LESS_THAN_5):
  1046. break
  1047. if self.appear_then_click(self.I_PRESET, threshold=0.8, interval=1):
  1048. continue
  1049. if self.appear_then_click(self.I_PRESET_WIT_NUMBER, threshold=0.8, interval=1):
  1050. continue
  1051. if self.ocr_appear(self.O_PRESET):
  1052. self.click(self.O_PRESET, interval=1)
  1053. continue
  1054. if self.ocr_appear(self.O_PRESET_FULL):
  1055. self.click(self.O_PRESET_FULL, interval=1)
  1056. continue
  1057. logger.info("Click preset button")
  1058. def get_unselect_color(tmp1, tmp2, tmp3, size):
  1059. # 获取未选择分组的颜色,3组之中必定存在两个颜色相似
  1060. color_1 = get_color(self.device.image,
  1061. (tmp1.roi_back[0], tmp1.roi_back[1],
  1062. tmp1.roi_back[0] + size[0], tmp1.roi_back[1] + size[1]))
  1063. color_2 = get_color(self.device.image,
  1064. (tmp2.roi_back[0], tmp2.roi_back[1],
  1065. tmp2.roi_back[0] + size[0], tmp2.roi_back[1] + size[1]))
  1066. color_3 = get_color(self.device.image,
  1067. (tmp3.roi_back[0], tmp3.roi_back[1],
  1068. tmp3.roi_back[0] + size[0], tmp3.roi_back[1] + size[1]))
  1069. if color_similar(color_1, color_2):
  1070. return color_1
  1071. if color_similar(color_2, color_3):
  1072. return color_2
  1073. return color_3
  1074. # 选择预设组
  1075. tmp = self.__getattribute__("C_PRESET_GROUP_" + str(pri_options.preset_group))
  1076. if tmp is None:
  1077. tmp = self.C_PRESET_GROUP_1
  1078. color_size = [self.C_PRESET_GROUP_1.roi_back[2],
  1079. self.C_PRESET_GROUP_1.roi_back[3]]
  1080. unselected_color = (224.9, 208.3, 187.4)
  1081. while True:
  1082. self.screenshot()
  1083. color_tmp = get_color(self.device.image,
  1084. (tmp.roi_back[0], tmp.roi_back[1], tmp.roi_back[0] + color_size[0],
  1085. tmp.roi_back[1] + color_size[1]))
  1086. if color_similar(color_tmp, unselected_color):
  1087. self.click(tmp, interval=0.2)
  1088. continue
  1089. break
  1090. logger.info("Select preset group")
  1091. # 选择预设的队伍
  1092. time.sleep(0.5)
  1093. tmp = self.__getattribute__("C_PRESET_TEAM_" + str(pri_options.preset_team))
  1094. if tmp is None:
  1095. tmp = self.C_PRESET_TEAM_1
  1096. color_size = [5, 5]
  1097. unselected_color = (216.8, 185.0, 146.8)
  1098. while True:
  1099. self.screenshot()
  1100. color_tmp = get_color(self.device.image,
  1101. (tmp.roi_back[0], tmp.roi_back[1], tmp.roi_back[0] + color_size[0],
  1102. tmp.roi_back[1] + color_size[1]))
  1103. if color_similar(color_tmp, unselected_color):
  1104. self.click(tmp, interval=0.2)
  1105. continue
  1106. break
  1107. self.click(tmp)
  1108. logger.info("Select preset team")
  1109. # 点击预设确认
  1110. self.wait_until_appear(self.I_PRESET_ENSURE, wait_time=1)
  1111. click_timer = Timer(4).start()
  1112. while 1:
  1113. self.screenshot()
  1114. if click_timer.reached():
  1115. logger.warning("Switch preset failure")
  1116. if not self.appear(self.I_PRESET_ENSURE):
  1117. break
  1118. if self.appear_then_click(self.I_PRESET_ENSURE, threshold=0.8, interval=1):
  1119. continue
  1120. logger.info("Click preset ensure")
  1121. state.done = True
  1122. return runtime.hook_enabled_update(
  1123. enable=(),
  1124. disable=('preset',),
  1125. )
  1126. def _bw_green_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1127. """
  1128. 绿标:标记己方式神,每场战斗只执行一次
  1129. """
  1130. pri_options = pri.options if isinstance(pri.options, OptionGreenDefault) else None
  1131. state = pri.per_battle if isinstance(pri.per_battle, PerBattleGreen) else None
  1132. if pri_options is None or state is None:
  1133. return HookSignal.CONTINUE
  1134. if not pri_options.green_enable or state.done:
  1135. return runtime.hook_enabled_update(
  1136. enable=(),
  1137. disable=('green',),
  1138. )
  1139. # 等待那个准备的消失
  1140. while 1:
  1141. self.screenshot()
  1142. if not self.appear(self.I_PREPARE_HIGHLIGHT):
  1143. break
  1144. if pri_options.green_mark_type == GreenMarkEnum.NAME:
  1145. name = pri_options.green_mark_name
  1146. if not name:
  1147. logger.warning("Green mark name is empty")
  1148. else:
  1149. timeout_timer = Timer(6).start()
  1150. best = {
  1151. 'name': '',
  1152. 'x': -1,
  1153. 'y': -1,
  1154. 'similarity': 0.0,
  1155. }
  1156. while not timeout_timer.reached():
  1157. self.screenshot()
  1158. results = self.O_GREEN_MARK_AREA.detect_and_ocr(self.device.image)
  1159. for ret in results:
  1160. similarity = difflib.SequenceMatcher(
  1161. None,
  1162. ret.ocr_text,
  1163. name,
  1164. ).ratio()
  1165. if similarity > best['similarity']:
  1166. x = self.O_GREEN_MARK_AREA.roi[0] + ret.box[0, 0] + 5
  1167. y = self.O_GREEN_MARK_AREA.roi[1] + ret.box[0, 1] + 30
  1168. best = {
  1169. 'name': ret.ocr_text,
  1170. 'x': min(1279, x),
  1171. 'y': min(719, y),
  1172. 'similarity': similarity,
  1173. }
  1174. if best['similarity'] > 0.5:
  1175. logger.info(
  1176. f'Green name success, text: {best["name"]}'
  1177. f'[{best["similarity"]:.2f}]'
  1178. )
  1179. self.device.click(
  1180. best['x'],
  1181. best['y'],
  1182. control_name=best['name'],
  1183. )
  1184. break
  1185. else:
  1186. logger.warning(
  1187. f'Green name failed, best text: {best["name"]}'
  1188. f'[{best["similarity"]:.2f}]'
  1189. )
  1190. else:
  1191. x, y = None, None
  1192. match pri_options.green_mark:
  1193. case GreenMarkType.GREEN_LEFT1:
  1194. x, y = self.C_GREEN_LEFT_1.coord()
  1195. logger.info("Green left 1")
  1196. case GreenMarkType.GREEN_LEFT2:
  1197. x, y = self.C_GREEN_LEFT_2.coord()
  1198. logger.info("Green left 2")
  1199. case GreenMarkType.GREEN_LEFT3:
  1200. x, y = self.C_GREEN_LEFT_3.coord()
  1201. logger.info("Green left 3")
  1202. case GreenMarkType.GREEN_LEFT4:
  1203. x, y = self.C_GREEN_LEFT_4.coord()
  1204. logger.info("Green left 4")
  1205. case GreenMarkType.GREEN_LEFT5:
  1206. x, y = self.C_GREEN_LEFT_5.coord()
  1207. logger.info("Green left 5")
  1208. case GreenMarkType.GREEN_MAIN:
  1209. x, y = self.C_GREEN_MAIN.coord()
  1210. logger.info("Green main")
  1211. # 判断有无坐标的偏移
  1212. self.appear_then_click(self.I_LOCAL)
  1213. time.sleep(0.3)
  1214. # 点击绿标
  1215. self.device.click(x, y)
  1216. state.done = True
  1217. return runtime.hook_enabled_update(
  1218. enable=(),
  1219. disable=('green',),
  1220. )
  1221. def _bw_red_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1222. """
  1223. 红标:点击对手的式神,暂为空壳
  1224. """
  1225. state = pri.per_battle
  1226. state.done = True
  1227. return runtime.hook_enabled_update(
  1228. enable=(),
  1229. disable=('red',),
  1230. )
  1231. def _bw_echo_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1232. """
  1233. 应声虫:战斗中进入聊天界面复制粘贴,暂为空壳
  1234. """
  1235. state = pri.per_battle
  1236. state.done = True
  1237. return runtime.hook_enabled_update(
  1238. enable=(),
  1239. disable=('echo',),
  1240. )
  1241. @randomclick_gate
  1242. def _bw_randomclick_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1243. match random.randint(0, 2):
  1244. case 0:
  1245. self.click(self.C_RANDOM_CLICK, interval=20)
  1246. case 1:
  1247. self.swipe(self.S_BATTLE_RANDOM_LEFT, interval=20)
  1248. case 2:
  1249. self.swipe(self.S_BATTLE_RANDOM_RIGHT, interval=20)
  1250. return HookSignal.CONTINUE
  1251. # custom
  1252. # ------------------------------------------------------------------------------------------------------------------
  1253. def _bw_success_soul(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1254. state = pri.per_battle
  1255. options = pri.options
  1256. if not isinstance(state, PerBattleSuccess) or not isinstance(options, OptionSuccessDefault):
  1257. raise TypeError("battle wait option 'success' must be an OptionSuccessDefault")
  1258. if state.click_stage_1 is None:
  1259. state.click_stage_1 = PerBattleSuccess.reward_exclude_click(self, options.excludes_1, name='success_exclude_click')
  1260. action_click = state.click_stage_1
  1261. if self.appear_then_click(self.I_WIN, interval=0.8):
  1262. return HookSignal.CONTINUE
  1263. appear_ghost, appear_reward, appear_gold, appear_skin = (
  1264. self.appear(self.I_GREED_GHOST),
  1265. self.appear(self.I_REWARD),
  1266. self.appear(self.I_REWARD_GOLD),
  1267. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  1268. )
  1269. if not any([appear_ghost, appear_reward, appear_gold, appear_skin]):
  1270. return HookSignal.CONTINUE
  1271. logger.info('Win battle')
  1272. timer = Timer(20).start()
  1273. while 1:
  1274. self.screenshot()
  1275. _appear_ghost, _appear_reward, _appear_gold, _appear_skin = (
  1276. self.appear(self.I_GREED_GHOST, threshold=0.6),
  1277. self.appear(self.I_REWARD),
  1278. self.appear(self.I_REWARD_GOLD),
  1279. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  1280. )
  1281. # logger.info(f'_appear_ghost: {_appear_ghost} _appear_reward: {_appear_reward} _appear_gold: {_appear_gold} _appear_skin: {_appear_skin}')
  1282. if any([_appear_ghost, _appear_reward, _appear_gold, _appear_skin]):
  1283. self.click(action_click, interval=1.5)
  1284. else:
  1285. logger.info('Get all reward')
  1286. pub.per_battle.success = BattleResult.SUCCESS
  1287. return runtime.hook_enabled_update(
  1288. enable=('completion',),
  1289. disable=tuple(['success', 'failure']),
  1290. )
  1291. if timer.reached_and_reset():
  1292. logger.warning('battle ')
  1293. break
  1294. return HookSignal.CONTINUE
  1295. @cached_property
  1296. def exclude_click_activity(self, areas: list[str] = None) -> RuleClickExclude:
  1297. inputs = []
  1298. for area in ['C_END_MESSAGE_RIGHT_TOP', 'C_END_ACTIVITY_REWARD']:
  1299. click = getattr(self, area, None)
  1300. if click is None:
  1301. raise ValueError(f'Unknown success exclusion click: {area!r}')
  1302. inputs.append(click)
  1303. return RuleClickExclude(inputs, name='exclude_click_activity', strategy='rejection', distribution='uniform')
  1304. def _bw_success_activity(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  1305. """
  1306. 战斗结算是有 “获得奖励” 的适用
  1307. """
  1308. if not self.appear(self.I_UI_REWARD):
  1309. return HookSignal.CONTINUE
  1310. self.screenshot()
  1311. if not self.appear(self.I_UI_REWARD):
  1312. return HookSignal.CONTINUE
  1313. logger.info('Win battle')
  1314. timer = Timer(20).start()
  1315. while 1:
  1316. self.screenshot()
  1317. # 不小心点到了具体的奖励,他会弹出这个物品的详细描述 里面必定包含有“获取途径”
  1318. if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2) or self.appear(self.I_END_FIX_3):
  1319. self.screenshot()
  1320. if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2) or self.appear(self.I_END_FIX_3):
  1321. self.click(self.C_REWARD_2, interval=2.5)
  1322. continue
  1323. if self.appear(self.I_UI_REWARD):
  1324. if random.random() < 0.02:
  1325. # 有一定的概率专门点击具体的奖励物品
  1326. x, y = self.exclude_click_activity.coord_in_excluded(['C_END_ACTIVITY_REWARD'])
  1327. self.device.click(x=x, y=y, control_name='reward_item')
  1328. continue
  1329. self.click(self.exclude_click_activity, interval=2.5)
  1330. elif not self.appear(self.I_END_FIX_2):
  1331. self.screenshot()
  1332. 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)]):
  1333. continue
  1334. logger.info('Get all reward')
  1335. pub.per_battle.success = BattleResult.SUCCESS
  1336. return runtime.hook_enabled_update(
  1337. enable=('completion', ),
  1338. disable=tuple(['success', 'failure']),
  1339. )
  1340. if timer.reached_and_reset():
  1341. logger.warning('battle ')
  1342. break
  1343. return HookSignal.CONTINUE
  1344. # ------------------------------------------------------------------------------------------------------------------
  1345. def battle_wait_with_strategy(self, *args, **kwargs) -> bool:
  1346. """
  1347. 理解 event + strategy 概念: 把战斗过程抽象为一系列触发事件以及对应的实现函数,也称hook。
  1348. event + strategy 拼成了一个hook, 一个 event 在一次战斗过程中只能挂载一个 strategy
  1349. 默认定义的 hook 有 BattleWaitPlan.HOOKS_DEFAULT = ('setup', 'completion', 'interrupt', 'success', 'failure', 'idle', 'prepare', 'preset', 'green', 'red', 'echo') 如果你填的没有,会使用默认的补全去的
  1350. 这些 hook 跑在一个 while 里面,默认的调用顺序 BattleWaitPlan.SEQUENCE_DEFAULT = 'completion > interrupt > prepare > preset > green > red > echo > success > failure > idle'
  1351. setup 没有跑在 while里面 而是在 while之前, 比如一个战斗过程可以表示为:
  1352. setup_default()
  1353. while 1:
  1354. completion_default()
  1355. interrupt_default()
  1356. success_default()
  1357. failure_default()
  1358. idle_default()
  1359. 围绕hook从两个维度来构建一个战斗系统, options 表示每一个hook的配置选项, public 和 private 表示每一个hook的共享和私有状态。分别有两个生命周期
  1360. | 自定义 /生命周期 | 跨任务 | 任务共享 | 单次战斗 |
  1361. | ------------- | ----- | --------------------- | ------------ |
  1362. | strategy | 不做 | @battle_wait_strategy | with 上下文 |
  1363. | options | 不做 | @battle_wait_options | with 上下文 |
  1364. | public | cross | per_task | per_battle |
  1365. | private | cross | per_task | per_battle |
  1366. 三种自定义策略方法见 battle_wait_strategy 的 docstring。
  1367. 自定义options方法见 battle_wait_options 的 docstring
  1368. """
  1369. battle_wait_plan = kwargs.get('battle_wait_plan')
  1370. if battle_wait_plan is None:
  1371. battle_wait_plan = BattleWaitPlan()
  1372. setup_func = getattr(self, battle_wait_plan.function_setup_name, self._bw_setup_default)
  1373. setup_func()
  1374. runtime.hook_enabled_update(
  1375. enable=(),
  1376. disable=('setup',),
  1377. )
  1378. handlers = [getattr(self, func_name, None) for func_name in battle_wait_plan.sequence_function_names()]
  1379. self.setup_hook(handlers=handlers)
  1380. while True:
  1381. self.screenshot()
  1382. hook_enabled = runtime.hook_enabled()
  1383. # self.state_show()
  1384. for handler in handlers:
  1385. if runtime.hook2event(handler.__name__) not in hook_enabled:
  1386. continue
  1387. result = handler()
  1388. if handler.__name__.startswith('_bw_completion') and result == HookSignal.DONE:
  1389. return runtime.pub_ctx.per_battle.success == BattleResult.SUCCESS
  1390. if result == HookSignal.CONTINUE:
  1391. continue
  1392. @classmethod
  1393. def setup_hook(cls, handlers: list[Callable]):
  1394. """
  1395. 默认的: 'setup', 'completion', 'interrupt', 'prepare', 'preset', 'green', 'red', 'echo', 'success', 'failure', 'idle'
  1396. 战斗开始下关闭的 completion, 'preset', 'green', 'red', 'echo'
  1397. 检测到进入准备阶段后开启 `preset` 来进入切换阵容,准备阶段结束后开启 'green', 'red', 'echo'
  1398. """
  1399. _hook_enabled = tuple(runtime.hook2event(h.__name__) for h in handlers if h)
  1400. _hook_disabled = ('completion', 'preset', 'green', 'red', 'echo')
  1401. runtime.hook_enabled_update(enable=_hook_enabled, disable=_hook_disabled)
  1402. if __name__ == '__main__':
  1403. from module.config.config import Config
  1404. from module.device.device import Device
  1405. from tasks.Component.GeneralBattle.general_battle import GeneralBattle
  1406. c = Config('oas1')
  1407. d = Device(c)