battle_wait.py 66 KB

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