battle_wait.py 44 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067
  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: 还原 class 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.options (类槽, 装饰器/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 copy
  75. from copy import deepcopy
  76. from functools import wraps, update_wrapper
  77. from dataclasses import dataclass, field
  78. from typing import TypeVar, ParamSpec, Callable
  79. from enum import Enum, auto
  80. from cached_property import cached_property
  81. from module.logger import logger
  82. from module.base.timer import Timer
  83. from module.atom.click import RuleClickExclude
  84. from tasks.base_task import BaseTask
  85. from tasks.Component.GeneralBattle.assets import GeneralBattleAssets
  86. P = ParamSpec('P')
  87. T = TypeVar('T')
  88. class HookSignal(Enum):
  89. CONTINUE = auto() # 无事发生
  90. BUSY = auto() # 处理了,继续
  91. DONE = auto() # 流程结束
  92. class BattleResult(Enum):
  93. SUCCESS = auto()
  94. FAILURE = auto()
  95. # ─── 默认值常量 ───────────────────────────────────
  96. # 战斗 hook 事件列表 & 默认调用顺序
  97. _HOOKS_DEFAULT: tuple[str, ...] = (
  98. 'setup', 'completion', 'interrupt', 'success', 'failure', 'idle',
  99. )
  100. _SEQUENCE_DEFAULT: str = 'completion > interrupt > success > failure >'
  101. # 跨任务/跨战斗状态的初始
  102. @dataclass
  103. class PerTaskState:
  104. """跨任务状态, 单个任务全程共享, reset_per_task 时重建"""
  105. count: int = 0
  106. @dataclass
  107. class PerBattleState:
  108. """跨战斗状态, 每场战斗独立, reset_per_battle 时重建"""
  109. success: BattleResult = BattleResult.FAILURE
  110. hook_enabled: set = field(default_factory=lambda: set(_HOOKS_DEFAULT) - {'completion'})
  111. # 每个 hook 事件的 options 数据类: pri[hook].options 就是这个实例。
  112. # 按 event 建模 —— 不管 success 挂的是什么 strategy, OptionSuccessDefault 都是它的配置。
  113. @dataclass
  114. class OptionSetupDefault:
  115. excludes: list | None = None
  116. @dataclass
  117. class OptionCompletionDefault:
  118. reward_exclude_click_1 = [
  119. 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
  120. 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
  121. ]
  122. reward_exclude_click_2 = [
  123. 'C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1',
  124. 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
  125. 'C_END_1_1', 'C_END_1_2', 'C_END_1_3', 'C_END_1_4',
  126. 'C_END_1_5', 'C_END_1_6',
  127. ]
  128. @dataclass
  129. class OptionInterruptDefault:
  130. pass
  131. @dataclass
  132. class OptionSuccessDefault:
  133. excludes: list | None = None
  134. @dataclass
  135. class OptionFailureDefault:
  136. pass
  137. @dataclass
  138. class OptionIdleDefault:
  139. pass
  140. # event → options 数据类, update_options 靠它按 hook2event 自动实例化分发
  141. _OPTION_CLASSES: dict[str, type] = {
  142. 'setup': OptionSetupDefault,
  143. 'completion': OptionCompletionDefault,
  144. 'interrupt': OptionInterruptDefault,
  145. 'success': OptionSuccessDefault,
  146. 'failure': OptionFailureDefault,
  147. 'idle': OptionIdleDefault,
  148. }
  149. def _options_to_instances(raw: dict) -> dict:
  150. """把按 event 分组的原始 dict 转成对应的 Option 数据类实例(未知 key 过滤)"""
  151. result = {}
  152. for event, value in (raw or {}).items():
  153. opt_cls = _OPTION_CLASSES.get(event)
  154. if opt_cls is not None and isinstance(value, opt_cls):
  155. result[event] = value
  156. elif opt_cls is not None and isinstance(value, dict):
  157. known = {k: v for k, v in value.items() if k in opt_cls.__dataclass_fields__}
  158. result[event] = opt_cls(**known)
  159. else:
  160. result[event] = deepcopy(value)
  161. return result
  162. # pri 层的私有状态, 同样按 event 建模: pri[hook].per_task / per_battle 就是这个实例。
  163. # 字段按需声明 —— 有自定义私有状态的 strategy 往自己 event 的类里加字段。
  164. @dataclass
  165. class PerTaskSetup:
  166. pass
  167. @dataclass
  168. class PerTaskCompletion:
  169. pass
  170. @dataclass
  171. class PerTaskInterrupt:
  172. pass
  173. @dataclass
  174. class PerTaskSuccess:
  175. pass
  176. @dataclass
  177. class PerTaskFailure:
  178. pass
  179. @dataclass
  180. class PerTaskIdle:
  181. pass
  182. @dataclass
  183. class PerBattleSetup:
  184. pass
  185. @dataclass
  186. class PerBattleCompletion:
  187. pass
  188. @dataclass
  189. class PerBattleInterrupt:
  190. pass
  191. @dataclass
  192. class PerBattleSuccess:
  193. pass
  194. @dataclass
  195. class PerBattleFailure:
  196. pass
  197. @dataclass
  198. class PerBattleIdle:
  199. pass
  200. # event → pri 私有状态数据类
  201. _PER_TASK_CLASSES: dict[str, type] = {
  202. 'setup': PerTaskSetup,
  203. 'completion': PerTaskCompletion,
  204. 'interrupt': PerTaskInterrupt,
  205. 'success': PerTaskSuccess,
  206. 'failure': PerTaskFailure,
  207. 'idle': PerTaskIdle,
  208. }
  209. _PER_BATTLE_CLASSES: dict[str, type] = {
  210. 'setup': PerBattleSetup,
  211. 'completion': PerBattleCompletion,
  212. 'interrupt': PerBattleInterrupt,
  213. 'success': PerBattleSuccess,
  214. 'failure': PerBattleFailure,
  215. 'idle': PerBattleIdle,
  216. }
  217. # ────────────────────────────────────────────
  218. class BattleWaitPlan:
  219. """
  220. 就是一个超级大的状态机,这里拆成了很多hook
  221. """
  222. HOOKS_DEFAULT = _HOOKS_DEFAULT
  223. SEQUENCE_DEFAULT = _SEQUENCE_DEFAULT
  224. def __init__(self, *arg, **kwargs):
  225. extra_sequence: str = ''
  226. #
  227. for event_strategy in arg:
  228. if not isinstance(event_strategy, str):
  229. raise TypeError(
  230. 'Battle wait hook must be a string in '
  231. '"event_strategy" format; '
  232. f'got {event_strategy!r}'
  233. )
  234. if not event_strategy:
  235. raise ValueError(
  236. 'Battle wait hook cannot be empty; '
  237. 'expected "event_strategy" format'
  238. )
  239. event, separator, strategy = event_strategy.partition('_')
  240. if not separator or not event or not strategy:
  241. raise ValueError(
  242. 'Invalid battle wait hook '
  243. f'{event_strategy!r}; expected "event_strategy" format'
  244. )
  245. setattr(self, event, strategy)
  246. if event not in self.HOOKS_DEFAULT:
  247. extra_sequence += f'{event} > '
  248. #
  249. for event, strategy in kwargs.items():
  250. if not event or not isinstance(event, str) or not isinstance(strategy, str):
  251. raise TypeError(f'{event} or {strategy} is not a string')
  252. if getattr(self, event, None) is not None:
  253. raise ValueError(
  254. f'Battle wait event {event!r} was configured more than once'
  255. )
  256. setattr(self, event, strategy)
  257. if event not in self.HOOKS_DEFAULT:
  258. extra_sequence += f'{event} > '
  259. # 补齐默认的
  260. for event in self.HOOKS_DEFAULT:
  261. if getattr(self, event, None) is None:
  262. setattr(self, event, 'default')
  263. #
  264. self.sequence = kwargs.get('sequence', None)
  265. if self.sequence is None:
  266. self.sequence = f'{BattleWaitPlan.SEQUENCE_DEFAULT} {extra_sequence} idle'
  267. if not isinstance(self.sequence, str):
  268. raise TypeError(
  269. 'Battle wait sequence must be a string containing event names '
  270. "separated by '>'; "
  271. f'got {self.sequence!r}'
  272. )
  273. self.sequence: str = self.sequence.replace(' ', '').replace('\n', '').replace('\r', '').replace('setup', '')
  274. for event_name in self.sequence.split('>'):
  275. event_name = event_name.strip()
  276. if event_name == "sequence":
  277. continue
  278. if getattr(self, event_name, None) is None:
  279. raise ValueError(
  280. f'Unknown battle wait event {event_name!r} in '
  281. f'sequence {self.sequence!r}'
  282. )
  283. for event in self.HOOKS_DEFAULT:
  284. if event != 'setup' and event not in self.sequence:
  285. raise ValueError(
  286. f'Battle wait sequence is missing required event {event!r}; '
  287. f'got {self.sequence!r}'
  288. )
  289. def __str__(self):
  290. lines = [f"{self.__class__.__name__}:", f" sequence: {self.sequence}", " hooks:"]
  291. for event_name in self.HOOKS_DEFAULT:
  292. strategy_name = getattr(self, event_name, None)
  293. if callable(strategy_name):
  294. if hasattr(strategy_name, '__name__'):
  295. func_name = strategy_name.__name__
  296. else:
  297. func_name = repr(strategy_name)
  298. val_str = f"<function {func_name}>"
  299. else:
  300. val_str = repr(strategy_name)
  301. lines.append(f" {event_name}: {val_str}")
  302. return "\n".join(lines)
  303. def __repr__(self):
  304. return self.__str__()
  305. @property
  306. def function_setup_name(self) -> str:
  307. if getattr(self, 'setup', None) is None:
  308. self.setup = 'default'
  309. return f'_bw_setup_{self.setup}'
  310. def sequence_function_names(self) -> list[str]:
  311. """
  312. 注意,这里是没有setup的
  313. """
  314. function_names = []
  315. for event_name in self.sequence.split('>'):
  316. event_name = event_name.strip()
  317. if not event_name:
  318. continue
  319. if not hasattr(self, event_name):
  320. raise ValueError(f'Unknown battle wait event: {event_name}')
  321. strategy_name = getattr(self, event_name)
  322. if not isinstance(strategy_name, str) or not strategy_name:
  323. raise ValueError(
  324. f'Invalid strategy for battle wait event {event_name}: '
  325. f'{strategy_name!r}'
  326. )
  327. function_names.append(f'_bw_{event_name}_{strategy_name}')
  328. return function_names
  329. def override(self, *arg, **kwargs):
  330. if kwargs:
  331. raise TypeError(
  332. 'sequence is not supported' if 'sequence' in kwargs else f'Unexpected keyword arguments: {tuple(kwargs)}')
  333. if not arg:
  334. return self
  335. events = [event for event in self.sequence.split('>') if event]
  336. if 'idle' not in events:
  337. raise ValueError(f'Sequence {self.sequence!r} must contain "idle"')
  338. idle_index = events.index('idle')
  339. for event_strategy in arg:
  340. if not isinstance(event_strategy, str):
  341. raise TypeError(f'event_strategy must be a string, got {event_strategy!r}')
  342. event, separator, strategy = event_strategy.partition('_')
  343. if not separator or not event or not strategy:
  344. raise ValueError(f'Invalid event_strategy: {event_strategy!r}')
  345. if event == 'sequence':
  346. raise ValueError('sequence cannot be overridden')
  347. is_new = not hasattr(self, event)
  348. setattr(self, event, strategy)
  349. if is_new:
  350. events.insert(idle_index, event)
  351. idle_index += 1
  352. self.sequence = '>'.join(events)
  353. return self
  354. class battle_wait_strategy:
  355. battle_wait_plan: BattleWaitPlan = None
  356. def __init__(self, *arg, **kwargs):
  357. self._scope = 'decorator'
  358. self._battle_wait_plan = BattleWaitPlan(*arg, **kwargs)
  359. def __enter__(self):
  360. self._scope = 'temporary'
  361. self._previous_plan = battle_wait_strategy.battle_wait_plan
  362. battle_wait_strategy.battle_wait_plan = self._battle_wait_plan
  363. return self
  364. def __exit__(self, *exc):
  365. battle_wait_strategy.battle_wait_plan = self._previous_plan
  366. return False
  367. def __str__(self):
  368. plan = getattr(self, '_battle_wait_plan', None)
  369. scope = getattr(self, '_scope', 'decorator')
  370. active_plan = battle_wait_strategy.battle_wait_plan
  371. return (
  372. f'{type(self).__name__}('
  373. f'scope={scope}, '
  374. f'plan=\n{plan}, '
  375. f'active_plan=\n{active_plan}'
  376. f')'
  377. )
  378. def __repr__(self):
  379. return self.__str__()
  380. def _recreate_cm(self):
  381. return self
  382. def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
  383. # 跨任务重置配置和策略,但是不重置状态
  384. battle_wait_strategy.battle_wait_plan = self._battle_wait_plan
  385. @wraps(func)
  386. def inner(owner, *args: P.args, **kwargs: P.kwargs) -> T:
  387. # 兼容性处理
  388. #-----------------------------------------------------------------------
  389. if kwargs:
  390. override_kwargs = {}
  391. override_args = list()
  392. for key, value in kwargs.items():
  393. if key == 'random_click_swipt_enable' and value:
  394. override_kwargs['randomclick'] = 'default'
  395. override_args.append('randomclick_default')
  396. current_plan = copy.deepcopy(battle_wait_strategy.battle_wait_plan)
  397. current_plan = current_plan.override(*override_args)
  398. else:
  399. current_plan = battle_wait_strategy.battle_wait_plan
  400. # -----------------------------------------------------------------------
  401. # kwargs.setdefault(
  402. # 'battle_wait_plan',
  403. # self.battle_wait_plan,
  404. # )
  405. options = battle_wait_options.options or None
  406. runtime.reset_per_battle()
  407. runtime.update_options(options)
  408. return func(owner, battle_wait_plan=current_plan, options=options) \
  409. if options else func(owner, battle_wait_plan=current_plan)
  410. return inner
  411. class battle_wait_options:
  412. """
  413. 用法(输入为按 hook 名的 kwargs, 每个值必须是 dict[str, dict]):
  414. 1) 装饰器 = 永久覆盖(任务级):
  415. @battle_wait_options(success={'excludes': [...]}) # 参数
  416. @battle_wait_strategy(success='activity') # 策略, 只管 hook 与顺序
  417. def battle_wait(self, *args, **kwargs):
  418. return self.battle_wait_with_strategy(*args, **kwargs)
  419. 2) with = 临时覆盖(本次调用, 退出还原):
  420. with battle_wait_options(failure={'excludes': [...]}):
  421. task.battle_wait()
  422. """
  423. options: dict = {event: cls() for event, cls in _OPTION_CLASSES.items()}
  424. def __init__(self, *arg, **kwargs):
  425. self._scope = 'decorator'
  426. self._overrides = _options_to_instances(dict(kwargs))
  427. def __enter__(self):
  428. self._scope = 'temporary'
  429. self._prev = type(self).options
  430. merged = deepcopy(self._prev) or {}
  431. merged.update(self._overrides)
  432. type(self).options = merged
  433. return self
  434. def __exit__(self, *exc):
  435. type(self).options = self._prev
  436. return False
  437. def __str__(self):
  438. scope = getattr(self, '_scope', 'decorator')
  439. return (
  440. f'{type(self).__name__}('
  441. f'scope={scope}, '
  442. f'overrides={self._overrides}, '
  443. f'options={battle_wait_options.options or {}}'
  444. f')'
  445. )
  446. def __repr__(self):
  447. return self.__str__()
  448. def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
  449. # 装饰器 = 永久覆盖(任务级); 调用结束后还原,避免跨任务污染
  450. self._options_saved = type(self).options
  451. @wraps(func)
  452. def inner(owner, *args: P.args, **kwargs: P.kwargs) -> T:
  453. type(self).options = deepcopy(self._overrides)
  454. try:
  455. return func(owner, *args, **kwargs)
  456. finally:
  457. type(self).options = self._options_saved
  458. return inner
  459. @dataclass
  460. class PublicContext:
  461. cross: dict = field(default_factory=dict)
  462. per_task: PerTaskState = field(default_factory=PerTaskState)
  463. per_battle: PerBattleState = field(default_factory=PerBattleState)
  464. options: dict = field(default_factory=dict) # 所有hook的options
  465. @dataclass
  466. class PrivateContext:
  467. cross: dict = field(default_factory=dict)
  468. per_task: dict = field(default_factory=dict)
  469. per_battle: dict = field(default_factory=dict)
  470. options: dict = field(default_factory=dict) # 单个hook的options
  471. class runtime:
  472. task_owner = None
  473. pri_ctx: dict[str, PrivateContext] = {}
  474. pub_ctx: PublicContext = None
  475. def __init__(self, func: Callable):
  476. self.func = func
  477. self.hook_name = func.__name__
  478. update_wrapper(self, func)
  479. def __get__(self, obj, objtype=None):
  480. if obj is None:
  481. return self
  482. runtime._ensure_pub()
  483. runtime._ensure_pri(self.hook_name)
  484. @wraps(self.func)
  485. def bound(*args, **kwargs):
  486. return self(obj, *args, **kwargs)
  487. return bound
  488. def __call__(self, owner, *args, **kwargs):
  489. # 新任务重置一下
  490. if runtime.task_owner is None or owner is not runtime.task_owner:
  491. runtime.task_owner = owner
  492. runtime.reset_per_task()
  493. runtime._ensure_pub()
  494. runtime._ensure_pri(self.hook_name)
  495. return self.func(owner, pub=runtime.pub_ctx, pri=runtime.pri_ctx[self.hook_name])
  496. def __str__(self):
  497. pub = runtime.pub_ctx or PublicContext()
  498. pri = runtime.pri_ctx.get(self.hook_name) or PrivateContext()
  499. def _keys(d):
  500. if isinstance(d, dict):
  501. return ','.join(d.keys()) or '-'
  502. 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)):
  503. return ','.join(d.__dataclass_fields__) or '-'
  504. return str(d)
  505. return (
  506. f'runtime({self.hook_name}) '
  507. f'pub[c:{_keys(pub.cross)},t:{_keys(pub.per_task)},b:{_keys(pub.per_battle)},o:{_keys(pub.options)}] '
  508. f'pri[c:{_keys(pri.cross)},t:{_keys(pri.per_task)},b:{_keys(pri.per_battle)},o:{_keys(pri.options)}]'
  509. )
  510. def __repr__(self):
  511. return self.__str__()
  512. @classmethod
  513. def reset_per_task(cls):
  514. cls._ensure_pub()
  515. cls.pub_ctx.per_task = PerTaskState()
  516. for hook_name, ctx in cls.pri_ctx.items():
  517. event = cls.hook2event(hook_name)
  518. cls_type = _PER_TASK_CLASSES.get(event, dict)
  519. ctx.per_task = cls_type()
  520. @classmethod
  521. def reset_per_battle(cls):
  522. cls._ensure_pub()
  523. cls.pub_ctx.per_battle = PerBattleState()
  524. for hook_name, ctx in cls.pri_ctx.items():
  525. event = cls.hook2event(hook_name)
  526. cls_type = _PER_BATTLE_CLASSES.get(event, dict)
  527. ctx.per_battle = cls_type()
  528. @classmethod
  529. def _ensure_pub(cls):
  530. if cls.pub_ctx is None:
  531. cls.pub_ctx = PublicContext()
  532. @classmethod
  533. def _ensure_pri(cls, name):
  534. if name not in cls.pri_ctx:
  535. event = cls.hook2event(name)
  536. cls.pri_ctx[name] = PrivateContext(
  537. per_task=_PER_TASK_CLASSES.get(event, dict)(),
  538. per_battle=_PER_BATTLE_CLASSES.get(event, dict)(),
  539. )
  540. @classmethod
  541. def hook2event(cls, func_name: str) -> str:
  542. # '_bw_success_soul' -> 'success'(strategy 名里带下划线也能正确切出事件名)
  543. return func_name[len('_bw_'):].rsplit('_', 1)[0]
  544. @classmethod
  545. def update_options(cls, options: dict[str, object] | None):
  546. """options 是 dict[str, OptionXxx] 实例(由 battle_wait_options 转好),直接按 event 分发"""
  547. cls._ensure_pub()
  548. if not isinstance(options, dict):
  549. cls.pub_ctx.options = {}
  550. for hook_name, ctx in cls.pri_ctx.items():
  551. ctx.options = cls._option_class(hook_name)()
  552. return
  553. cls.pub_ctx.options = options
  554. for hook_name, ctx in cls.pri_ctx.items():
  555. event = cls.hook2event(hook_name)
  556. opt = options.get(event)
  557. ctx.options = opt if isinstance(opt, cls._option_class(hook_name)) else cls._option_class(hook_name)()
  558. @classmethod
  559. def _option_class(cls, hook_name: str) -> type:
  560. return _OPTION_CLASSES.get(cls.hook2event(hook_name)) or dict
  561. @classmethod
  562. def hook_enabled(cls) -> set:
  563. _hook_enabled = cls.pub_ctx.per_battle.hook_enabled
  564. if not _hook_enabled:
  565. raise
  566. return _hook_enabled
  567. @classmethod
  568. def hook_enabled_update(cls, enable: tuple[str, ...], disable: tuple[str, ...]) -> HookSignal:
  569. """
  570. hook_enabled 的更新只能在 BattleWait 上。不可以在 battle_wait_options 或者 battle_wait_strategy 上
  571. """
  572. cls.pub_ctx.per_battle.hook_enabled.update(enable)
  573. cls.pub_ctx.per_battle.hook_enabled.difference_update(disable)
  574. return HookSignal.CONTINUE
  575. class BattleWait(BaseTask, GeneralBattleAssets):
  576. def __new__(cls, *args, **kwargs):
  577. for klass in reversed(cls.__mro__):
  578. # 找遍整个继承链,从父到子
  579. if klass is object:
  580. continue
  581. if klass.__dict__.get('_runtime_auto_decorated'):
  582. continue
  583. klass._runtime_auto_decorated = True
  584. for name, attr in list(vars(klass).items()):
  585. if name.startswith('_bw_') and callable(attr) and not isinstance(attr, runtime):
  586. setattr(klass, name, runtime(attr))
  587. return super().__new__(cls)
  588. # ------------------------------------------------------------------------------------------------------------------
  589. @cached_property
  590. def exclude_button_stage_1(self):
  591. return ['C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1', 'C_END_BUFF_AREA_2',
  592. 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
  593. ]
  594. @cached_property
  595. def exclude_button_stage_2(self):
  596. return ['C_END_MESSAGE_RIGHT_TOP', 'C_END_BUFF_AREA_1', 'C_END_BUFF_AREA_2', 'C_END_SOUL_RECORD', 'C_END_SOUL_DETAILS',
  597. 'C_END_1_1', 'C_END_1_2', 'C_END_1_3', 'C_END_1_4', 'C_END_1_5', 'C_END_1_6',
  598. ]
  599. def reward_exclude_click(self, areas: list[str] = None, name: str = 'success_exclude_click') -> RuleClickExclude:
  600. inputs = []
  601. for area in areas:
  602. click = getattr(self, area, None)
  603. if click is None:
  604. raise ValueError(f'Unknown success exclusion click: {area!r}')
  605. inputs.append(click)
  606. return RuleClickExclude(inputs, name=name)
  607. def reward_exclude_click_1(self, areas: list[str] = None) -> RuleClickExclude:
  608. return self.reward_exclude_click(areas, name='reward_exclude_click_1')
  609. def reward_exclude_click_2(self, areas: list[str] = None) -> RuleClickExclude:
  610. return self.reward_exclude_click(areas, name='reward_exclude_click_2')
  611. # build in
  612. # ------------------------------------------------------------------------------------------------------------------
  613. def _bw_setup_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  614. """
  615. options: dict = {
  616. ‘excludes’
  617. }
  618. """
  619. self.C_REWARD_1.name = 'C_REWARD'
  620. self.C_REWARD_2.name = 'C_REWARD'
  621. self.C_REWARD_3.name = 'C_REWARD'
  622. self.device.stuck_record_add('BATTLE_STATUS_S')
  623. self.device.click_record_clear()
  624. logger.info('Start battle process')
  625. pri_options = pri.options if isinstance(pri.options, dict) else {}
  626. success_options = pri_options.get('success') or {}
  627. if not isinstance(success_options, dict):
  628. raise TypeError("battle wait option 'success' must be a dict")
  629. excludes = success_options.get('excludes')
  630. exclude_stage_1 = excludes if excludes is not None else self.exclude_button_stage_1
  631. exclude_stage_2 = excludes if excludes is not None else self.exclude_button_stage_2
  632. self._reward_exclude_click_1 = self.reward_exclude_click_1(exclude_stage_1)
  633. self._reward_exclude_click_2 = self.reward_exclude_click_2(exclude_stage_2)
  634. # print(self._reward_exclude_click_1)
  635. # print(self._reward_exclude_click_2)
  636. return HookSignal.DONE
  637. def _bw_completion_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  638. logger.info('Battle completion process')
  639. pub.per_task.count += 1
  640. return HookSignal.DONE
  641. def _bw_interrupt_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  642. # 比如 御魂溢出
  643. return HookSignal.CONTINUE
  644. def _bw_success_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  645. if self.appear_then_click(self.I_WIN, interval=0.8):
  646. self.click(self._reward_exclude_click_1)
  647. return HookSignal.CONTINUE
  648. appear_ghost, appear_reward, appear_gold, appear_skin = (
  649. self.appear(self.I_GREED_GHOST),
  650. self.appear(self.I_REWARD),
  651. self.appear(self.I_REWARD_GOLD),
  652. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  653. )
  654. if not any([appear_ghost, appear_reward, appear_gold, appear_skin]):
  655. return HookSignal.CONTINUE
  656. logger.info('Win battle')
  657. timer = Timer(20).start()
  658. while 1:
  659. self.screenshot()
  660. # 不小心点到了具体的奖励,他会弹出这个物品的详细描述 里面必定包含有“获取途径”
  661. if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2):
  662. self.click(self.C_REWARD_2, interval=1.5)
  663. _appear_ghost, _appear_reward, _appear_gold, _appear_skin = (
  664. self.appear(self.I_GREED_GHOST, threshold=0.6),
  665. self.appear(self.I_REWARD),
  666. self.appear(self.I_REWARD_GOLD),
  667. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  668. )
  669. # logger.info(f'_appear_ghost: {_appear_ghost} _appear_reward: {_appear_reward} _appear_gold: {_appear_gold} _appear_skin: {_appear_skin}')
  670. if any([_appear_ghost, _appear_reward, _appear_gold, _appear_skin]):
  671. if random.random() < 0.02:
  672. # 有一定的概率专门点击具体的奖励物品
  673. x, y = self._reward_exclude_click_2.coord_in_excluded(None)
  674. self.device.click(x=x, y=y, control_name='reward_item')
  675. continue
  676. self.click(self._reward_exclude_click_2, interval=1.5)
  677. else:
  678. logger.info('Get all reward')
  679. pub.success = True
  680. pub.completion = True
  681. return HookSignal.CONTINUE
  682. if timer.reached_and_reset():
  683. logger.warning('battle')
  684. break
  685. return HookSignal.CONTINUE
  686. def _bw_failure_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  687. if self.appear(self.I_FALSE, threshold=0.8):
  688. logger.warning('False battle')
  689. self.ui_click_until_disappear(self.I_FALSE)
  690. pub.per_battle.success = BattleResult.FAILURE
  691. return runtime.hook_enabled_update(
  692. enable=('completion', ),
  693. disable=tuple(['success', 'failure']),
  694. )
  695. return HookSignal.CONTINUE
  696. def _bw_idle_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  697. return HookSignal.CONTINUE
  698. def _bw_randomclick_default(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  699. return HookSignal.CONTINUE
  700. done = pri.per_battle.get('_bw_randomclick_state', False)
  701. if done:
  702. return HookSignal.CONTINUE
  703. if not self.is_in_battle(is_screenshot=False):
  704. return HookSignal.CONTINUE
  705. if random.random() < 0.005 : # 低概率
  706. rand_type = random.randint(0, 2)
  707. match rand_type:
  708. case 0:
  709. self.click(self.C_RANDOM_CLICK, interval=20)
  710. case 1:
  711. self.swipe(self.S_BATTLE_RANDOM_LEFT, interval=20)
  712. case 2:
  713. self.swipe(self.S_BATTLE_RANDOM_RIGHT, interval=20)
  714. pri.per_battle['_bw_randomclick_state'] = True
  715. # 重新设置为长战斗
  716. # self.device.stuck_record_add('BATTLE_STATUS_S')
  717. else:
  718. time.sleep(0.4) # 这样的好像不对
  719. return HookSignal.CONTINUE
  720. # custom
  721. # ------------------------------------------------------------------------------------------------------------------
  722. def _bw_success_soul(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  723. success_options = pub.options.get('success') if isinstance(pub.options, dict) else {}
  724. if isinstance(success_options, OptionSuccessDefault):
  725. excludes = success_options.excludes
  726. elif isinstance(success_options, dict):
  727. excludes = success_options.get('excludes')
  728. else:
  729. raise TypeError("battle wait option 'success' must be an OptionSuccessDefault")
  730. action_click = self.reward_exclude_click(excludes)
  731. if self.appear_then_click(self.I_WIN, interval=0.8):
  732. return HookSignal.CONTINUE
  733. appear_ghost, appear_reward, appear_gold, appear_skin = (
  734. self.appear(self.I_GREED_GHOST),
  735. self.appear(self.I_REWARD),
  736. self.appear(self.I_REWARD_GOLD),
  737. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  738. )
  739. if not any([appear_ghost, appear_reward, appear_gold, appear_skin]):
  740. return HookSignal.CONTINUE
  741. logger.info('Win battle')
  742. timer = Timer(20).start()
  743. while 1:
  744. self.screenshot()
  745. _appear_ghost, _appear_reward, _appear_gold, _appear_skin = (
  746. self.appear(self.I_GREED_GHOST, threshold=0.6),
  747. self.appear(self.I_REWARD),
  748. self.appear(self.I_REWARD_GOLD),
  749. self.appear(self.I_REWARD_GOLD_SNAKE_SKIN)
  750. )
  751. # logger.info(f'_appear_ghost: {_appear_ghost} _appear_reward: {_appear_reward} _appear_gold: {_appear_gold} _appear_skin: {_appear_skin}')
  752. if any([_appear_ghost, _appear_reward, _appear_gold, _appear_skin]):
  753. self.click(action_click, interval=1.5)
  754. else:
  755. logger.info('Get all reward')
  756. pub.success = True
  757. pub.completion = True
  758. return HookSignal.CONTINUE
  759. if timer.reached_and_reset():
  760. logger.warning('battle ')
  761. break
  762. return HookSignal.CONTINUE
  763. @cached_property
  764. def exclude_click_activity(self, areas: list[str] = None) -> RuleClickExclude:
  765. inputs = []
  766. for area in ['C_END_MESSAGE_RIGHT_TOP', 'C_END_ACTIVITY_REWARD']:
  767. click = getattr(self, area, None)
  768. if click is None:
  769. raise ValueError(f'Unknown success exclusion click: {area!r}')
  770. inputs.append(click)
  771. return RuleClickExclude(inputs, name='exclude_click_activity', strategy='rejection', distribution='uniform')
  772. def _bw_success_activity(self, pub: PublicContext, pri: PrivateContext) -> HookSignal:
  773. """
  774. 战斗结算是有 “获得奖励” 的适用
  775. """
  776. if not self.appear(self.I_UI_REWARD):
  777. return HookSignal.CONTINUE
  778. self.screenshot()
  779. if not self.appear(self.I_UI_REWARD):
  780. return HookSignal.CONTINUE
  781. logger.info('Win battle')
  782. timer = Timer(20).start()
  783. while 1:
  784. self.screenshot()
  785. # 不小心点到了具体的奖励,他会弹出这个物品的详细描述 里面必定包含有“获取途径”
  786. if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2) or self.appear(self.I_END_FIX_3):
  787. self.screenshot()
  788. if self.appear(self.I_END_FIX_1) or self.appear(self.I_END_FIX_2) or self.appear(self.I_END_FIX_3):
  789. self.click(self.C_REWARD_2, interval=2.5)
  790. continue
  791. if self.appear(self.I_UI_REWARD):
  792. if random.random() < 0.02:
  793. # 有一定的概率专门点击具体的奖励物品
  794. x, y = self.exclude_click_activity.coord_in_excluded(['C_END_ACTIVITY_REWARD'])
  795. self.device.click(x=x, y=y, control_name='reward_item')
  796. continue
  797. self.click(self.exclude_click_activity, interval=2.5)
  798. elif not self.appear(self.I_END_FIX_2):
  799. self.screenshot()
  800. 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)]):
  801. continue
  802. logger.info('Get all reward')
  803. pub.per_battle.success = BattleResult.SUCCESS
  804. return runtime.hook_enabled_update(
  805. enable=('completion', ),
  806. disable=tuple(['success', 'failure']),
  807. )
  808. if timer.reached_and_reset():
  809. logger.warning('battle ')
  810. break
  811. return HookSignal.CONTINUE
  812. # ------------------------------------------------------------------------------------------------------------------
  813. def battle_wait_with_strategy(self, *args, **kwargs) -> bool:
  814. """
  815. 理解 event + strategy 概念: 把战斗过程抽象为一系列触发事件以及对应的实现函数,也称hook。
  816. event + strategy 拼成了一个hook, 一个 event 在一次战斗过程中只能挂载一个 strategy
  817. 默认定义的 hook 有 BattleWaitPlan.HOOKS_DEFAULT = ('setup', 'completion', 'interrupt', 'success', 'failure', 'idle')
  818. 这些 hook 跑在一个 while 里面,默认的调用顺序 BattleWaitPlan.SEQUENCE_DEFAULT = 'completion > interrupt > success > failure > idle'
  819. setup 没有跑在 while里面 而是在 while之前, 比如一个战斗过程可以表示为:
  820. setup_default()
  821. while 1:
  822. completion_default()
  823. interrupt_default()
  824. success_default()
  825. failure_default()
  826. idle_default()
  827. 围绕hook从两个维度来构建一个战斗系统, options 表示每一个hook的配置选项, public 和 private 表示每一个hook的共享和私有状态。分别有两个生命周期
  828. | 自定义 /生命周期 | 跨任务 | 任务共享 | 单次战斗 |
  829. | ------------- | ----- | --------------------- | ------------ |
  830. | strategy | 不做 | @battle_wait_strategy | with 上下文 |
  831. | options | 不做 | @battle_wait_options | with 上下文 |
  832. | public | cross | per_task | per_battle |
  833. | private | cross | per_task | per_battle |
  834. ----------------------------------------------------------------------------------------------------------------
  835. 三种自定义策略方法:
  836. 1. 使用装饰器battle_wait_strategy, 将会覆盖掉类变量
  837. @battle_wait_strategy( 'reserve_default', 'idle_default', failure='default')
  838. def battle_wait(self, *args, **kwargs):
  839. return self.battle_wait_with_strategy(*args, **kwargs)
  840. 2. 使用 with 上下文 (!在1基础上), 将会临时覆盖掉原先的类变量,退出后恢复
  841. with battle_wait_strategy('reserve_default'):
  842. test_battle_wait.battle_wait()
  843. 3. 调用时动态传参 (!在1基础上), 不覆盖,就临时更新策略
  844. obj.battle_wait(random_click_swipt_enable=1) # 详细参数看 battle_wait_strategy.__call__()
  845. 自定义hook就是字符串拼起来: battle_wait_strategy的入参可以有 ‘event_strategy’ 或者 'event=strategy'
  846. 可以添加任意 event 以及其对应的 strategy。比如 ‘yyy_default’ 'abcd_edf'
  847. 但是必须要实现对应的hook 上面的比如 _bw_yyy_default() 以及 _bw_abcd_edf()
  848. hook 可以自定义顺序,比如 battle_wait_strategy(sequence='completion > interrupt > success > failure > idle')
  849. 如果没有指定sequence, 新增的event会按照传参时候从左到右排序,左边高优先级,新增的会插入到 failure 和 idle 之间
  850. ----------------------------------------------------------------------------------------------------------------
  851. 如果希望每一个hook带上参数:
  852. 1. 在 battle_wait_strategy 定义了一组默认的 options
  853. 2. 可以在装饰器定义 @battle_wait_strategy(options = options),这里将会覆盖掉原先的 battle_wait_strategy.options
  854. 3. 上下文带上 with battle_wait_strategy(...).with_options(options),同样也是临时覆盖掉 battle_wait_strategy.options
  855. 4.
  856. options: dict[str: dict] = {
  857. "setup": {...}
  858. ...
  859. }
  860. ----------------------------------------------------------------------------------------------------------------
  861. 跨战斗,考虑把状态挂到方法上,而不是挂到类对象上。】
  862. 我突然感觉 一个类里面装了 策略和参数,这样不好,考虑拆分成两个装饰器
  863. """
  864. battle_wait_plan = kwargs.get('battle_wait_plan')
  865. if battle_wait_plan is None:
  866. battle_wait_plan = BattleWaitPlan()
  867. print(battle_wait_plan)
  868. # print(battle_wait_plan.sequence_function_names())
  869. options = runtime.pub_ctx.options
  870. logger.info('options: {}'.format(options))
  871. setup_func = getattr(self, battle_wait_plan.function_setup_name, self._bw_setup_default)
  872. setup_func()
  873. handlers = [getattr(self, func_name, None) for func_name in battle_wait_plan.sequence_function_names()]
  874. _hook_enabled = tuple(runtime.hook2event(h.__name__) for h in handlers if h)
  875. _hook_disabled = ('completion', )
  876. runtime.hook_enabled_update(enable=_hook_enabled, disable=_hook_disabled)
  877. print(f'first runtime.hook_enabled(): {runtime.hook_enabled()}')
  878. while True:
  879. self.screenshot()
  880. hook_enabled = runtime.hook_enabled()
  881. for handler in handlers:
  882. if runtime.hook2event(handler.__name__) not in hook_enabled:
  883. continue
  884. result = handler()
  885. if handler.__name__.startswith('_bw_completion') and result == HookSignal.DONE:
  886. return runtime.pub_ctx.per_battle.success == BattleResult.SUCCESS
  887. if result == HookSignal.CONTINUE:
  888. continue
  889. if __name__ == '__main__':
  890. from module.config.config import Config
  891. from module.device.device import Device
  892. from tasks.Component.GeneralBattle.general_battle import GeneralBattle
  893. c = Config('oas1')
  894. d = Device(c)