From eb36c44dd57a19a2a385c4ffc4132eb214b429f0 Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:05 +0800 Subject: [PATCH 1/8] =?UTF-8?q?refactor(ui):=20=E6=94=AF=E6=8C=81=E4=B8=AD?= =?UTF-8?q?=E6=AD=A2=E7=AD=89=E5=BE=85=E5=B9=B6=E5=A4=8D=E7=94=A8=E6=96=B0?= =?UTF-8?q?=E5=B8=A7=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- autowsgr/emulator/frame.py | 21 +++++++++--- autowsgr/ui/battle/fleet_change/_selection.py | 11 +++++-- autowsgr/ui/utils/navigation.py | 33 +++++++++++++++---- tools/decisive/recording.py | 10 ++++++ 4 files changed, 62 insertions(+), 13 deletions(-) diff --git a/autowsgr/emulator/frame.py b/autowsgr/emulator/frame.py index ec52efe4d..5861b2f3d 100644 --- a/autowsgr/emulator/frame.py +++ b/autowsgr/emulator/frame.py @@ -2,12 +2,9 @@ from __future__ import annotations -from dataclasses import dataclass -from typing import TYPE_CHECKING +from dataclasses import dataclass, replace - -if TYPE_CHECKING: - import numpy as np +import numpy as np @dataclass(frozen=True, slots=True) @@ -21,3 +18,17 @@ class CapturedFrame: image: np.ndarray sequence: int | None captured_at: float + + def snapshot(self) -> CapturedFrame: + """保留观察时的像素,防止无解码序号的控制器复用缓冲区。""" + return self if self.sequence is not None else replace(self, image=self.image.copy()) + + def is_newer_than(self, previous: CapturedFrame | None, *, allow_static: bool) -> bool: + """优先比较解码序号。无序号时,只有允许静态复核才能接受相同像素。""" + if previous is None: + return True + if self.sequence is not None and previous.sequence is not None: + return self.sequence > previous.sequence + return self.captured_at > previous.captured_at and ( + allow_static or not np.array_equal(previous.image, self.image) + ) diff --git a/autowsgr/ui/battle/fleet_change/_selection.py b/autowsgr/ui/battle/fleet_change/_selection.py index 8fdc446ae..8071050f6 100644 --- a/autowsgr/ui/battle/fleet_change/_selection.py +++ b/autowsgr/ui/battle/fleet_change/_selection.py @@ -19,6 +19,7 @@ if TYPE_CHECKING: from collections.abc import Sequence + from threading import Event from autowsgr.ui.choose_ship_page import ChooseShipPage @@ -49,30 +50,36 @@ def _search_options(self, option: ShipSelector) -> tuple[ShipSelector, ...]: search_names = aliases if option.name in aliases else (*aliases, option.name) return tuple(replace(option, search_name=name) for name in search_names) - def _open_choose_page(self, slot: int) -> ChooseShipPage: + def _open_choose_page(self, slot: int, *, stop_event: Event | None = None) -> ChooseShipPage: """打开指定物理槽位的选船页面。""" from autowsgr.ui.choose_ship_page import ChooseShipPage from autowsgr.ui.utils import wait_for_page + from autowsgr.ui.utils.navigation import check_stop + check_stop(stop_event) self.click_ship_slot(slot) wait_for_page( self._ctrl, ChooseShipPage.is_current_page, timeout=_CHOOSE_PAGE_TIMEOUT, + stop_event=stop_event, source='编队', target='编队选船', ) return ChooseShipPage(self._ctx) - def _cancel_choose_page(self) -> None: + def _cancel_choose_page(self, *, stop_event: Event | None = None) -> None: """规则未命中时退出选船页,恢复到编队准备页。""" from autowsgr.ui.utils import wait_for_page + from autowsgr.ui.utils.navigation import check_stop + check_stop(stop_event) self._ctrl.click(*CLICK_BACK) wait_for_page( self._ctrl, self.is_current_page, timeout=_CHOOSE_PAGE_TIMEOUT, + stop_event=stop_event, source='编队选船', target='编队', ) diff --git a/autowsgr/ui/utils/navigation.py b/autowsgr/ui/utils/navigation.py index 4f8676e49..9d470e466 100644 --- a/autowsgr/ui/utils/navigation.py +++ b/autowsgr/ui/utils/navigation.py @@ -21,6 +21,7 @@ if TYPE_CHECKING: from collections.abc import Callable + from threading import Event import numpy as np @@ -83,6 +84,12 @@ class NavConfig: # --------------------------------------------------------------------------- +def check_stop(stop_event: Event | None) -> None: + """在下一次截屏或触摸前响应任务停止请求。""" + if stop_event is not None and stop_event.is_set(): + raise InterruptedError('收到停止请求') + + def wait_for_page( ctrl: AndroidController, checker: Callable[[np.ndarray], bool], @@ -93,10 +100,12 @@ def wait_for_page( source: str = '', target: str = '', candidates: set[str] | None = None, + stop_event: Event | None = None, + timeout_error: type[Exception] = NavigationError, ) -> np.ndarray: """反复截图,直到 ``checker`` 返回 ``True``。 - 内置浮层消除。遇到可消除浮层时立即处理并继续轮询(不计入睡眠延迟)。 + 设置 stop_event 时,停止请求可打断截图间隔。 Parameters ---------- @@ -107,7 +116,7 @@ def wait_for_page( Raises ------ NavigationError - 超时仍未匹配。 + 超时仍未匹配。传入 timeout_error 时改用该异常报告超时。 """ from autowsgr.ui.page import get_current_page @@ -116,9 +125,10 @@ def wait_for_page( _log.debug('[UI] 等待到达: {} -> {} (超时 {:.1f}s)', source or '?', target or '?', timeout) while True: + check_stop(stop_event) attempt += 1 screen = ctrl.screenshot() - + check_stop(stop_event) if checker(screen): _log.debug( '[UI] 已到达: {} -> {} (第 {} 次截图)', source or '?', target or '?', attempt @@ -140,9 +150,15 @@ def wait_for_page( f'{attempt} 次截图后仍未到达, 当前: {current or "未知"}' ) _log.error('[UI] {}', msg) - raise NavigationError(msg, screen=screen) + error = NavigationError(msg, screen=screen) + if timeout_error is NavigationError: + raise error + raise timeout_error(msg) from error - time.sleep(interval) + if stop_event is None: + time.sleep(interval) + else: + stop_event.wait(interval) def wait_leave_page( @@ -238,8 +254,10 @@ def click_and_wait_for_page( target: str = '', config: NavConfig = DEFAULT_NAV_CONFIG, candidates: set[str] | None = None, + stop_event: Event | None = None, + timeout_error: type[Exception] = NavigationError, ) -> np.ndarray: - """点击 + 等待到达目标页面,内置重试。 + """点击一次,随后反复截图验证是否到达目标页。 Raises ------ @@ -247,6 +265,7 @@ def click_and_wait_for_page( 点击后未到达目标页面。 """ + check_stop(stop_event) ctrl.click(*click_coord) return wait_for_page( ctrl, @@ -257,6 +276,8 @@ def click_and_wait_for_page( source=source, target=target, candidates=candidates, + stop_event=stop_event, + timeout_error=timeout_error, ) diff --git a/tools/decisive/recording.py b/tools/decisive/recording.py index f197daeaf..1e695df0f 100644 --- a/tools/decisive/recording.py +++ b/tools/decisive/recording.py @@ -33,6 +33,16 @@ def is_set(self) -> bool: self.set() return super().is_set() + def wait(self, timeout: float | None = None) -> bool: + """维修可能等待数分钟,等待期间也要响应采集器的停止文件。""" + deadline = None if timeout is None else time.monotonic() + timeout + while not self.is_set(): + interval = 0.25 if deadline is None else min(0.25, deadline - time.monotonic()) + if interval <= 0: + return False + super().wait(interval) + return True + class SampleArchive: """逐条落盘;进程中断时已保存的 PNG 与 JSONL 仍可使用。""" From 76d18876a7df71d2a5d4096b8133996102274a8f Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:13 +0800 Subject: [PATCH 2/8] =?UTF-8?q?feat(decisive):=20=E4=BD=BF=E7=94=A8=20EX?= =?UTF-8?q?=20=E6=8B=93=E6=89=91=E4=B8=8E=E6=9C=89=E5=BA=8F=E6=95=8C?= =?UTF-8?q?=E6=96=B9=E7=BC=96=E9=98=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../data/map/decisive_battle/enemy_spec.yaml | 135 -------- .../silent_warrior/EX-1-1.yaml | 27 ++ .../silent_warrior/EX-1-2.yaml | 36 ++ .../silent_warrior/EX-1-3.yaml | 35 ++ .../silent_warrior/EX-2-1.yaml | 27 ++ .../silent_warrior/EX-2-2.yaml | 36 ++ .../silent_warrior/EX-2-3.yaml | 37 +++ .../silent_warrior/EX-3-1.yaml | 35 ++ .../silent_warrior/EX-3-2.yaml | 34 ++ .../silent_warrior/EX-3-3.yaml | 44 +++ .../silent_warrior/EX-4-1.yaml | 34 ++ .../silent_warrior/EX-4-2.yaml | 35 ++ .../silent_warrior/EX-4-3.yaml | 43 +++ .../silent_warrior/EX-5-1.yaml | 35 ++ .../silent_warrior/EX-5-2.yaml | 41 +++ .../silent_warrior/EX-5-3.yaml | 42 +++ .../silent_warrior/EX-6-1.yaml | 43 +++ .../silent_warrior/EX-6-2.yaml | 44 +++ .../silent_warrior/EX-6-3.yaml | 43 +++ autowsgr/ops/decisive/config.py | 313 +++++++++++------- testing/ops/test_decisive_metadata.py | 124 +++---- 21 files changed, 927 insertions(+), 316 deletions(-) delete mode 100644 autowsgr/data/map/decisive_battle/enemy_spec.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-1-1.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-1-2.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-1-3.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-2-1.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-2-2.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-2-3.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-3-1.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-3-2.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-3-3.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-4-1.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-4-2.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-4-3.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-5-1.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-5-2.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-5-3.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-6-1.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-6-2.yaml create mode 100644 autowsgr/data/map/decisive_battle/silent_warrior/EX-6-3.yaml diff --git a/autowsgr/data/map/decisive_battle/enemy_spec.yaml b/autowsgr/data/map/decisive_battle/enemy_spec.yaml deleted file mode 100644 index fd482eb71..000000000 --- a/autowsgr/data/map/decisive_battle/enemy_spec.yaml +++ /dev/null @@ -1,135 +0,0 @@ -key_points: - 1: - - "" - 2: - - - 3: - - "" - 4: - - "" - - "CFH" - - "BFH" - - "DHJ" - 5: - - "" - - "DFH" - - "DGJ" - - "CGJ" - 6: - - "" - - "BGJ" - - "CHJ" - - "DGJ" -map_end: - - "" - - " FHH" - - " FHH" - - " HHJ" - - " HHJ" - - " HJJ" - - " JJJ" -enemy: - - "" - - "" - - "" - - "" - - - - "" - - - A: ['', '轻巡', '轻巡', '驱逐'] - B: ['', '重巡', '重巡', '驱逐', '驱逐'] - C: ['', "雷巡", "雷巡", "轻巡", "轻巡", "潜艇"] - D: ['', '战巡', '轻母', '轻母', '轻巡', '驱逐'] - E: ['', '战列', '重巡', '轻巡', '轻母', '轻巡', '驱逐'] - F: ['', '航母', '战巡', '轻巡', '驱逐', '驱逐', '防驱'] - G: ['', '战巡', '大巡', '重巡', '重巡', '轻巡', '驱逐'] - H: ['', '航母', '航母', '轻母', '轻巡', '航战', '航战'] - - - A: ['', '战巡', '航母', '航母', '轻巡', '驱逐', '驱逐'] - B: ['', '战列', '战巡', '战巡', '重巡', '驱逐', '潜艇'] - C: ['', '航母', '航母', '战列', '雷巡', '轻巡', '轻巡'] - D: ['', '战列', '航母', '大巡', '重巡', '驱逐', '防驱'] - E: ['', '战巡', '战巡', '航母', '轻巡', '轻巡', '导驱'] - F: ['', '战列', '战列', '战列', '重巡', '驱逐', '潜艇'] - G: ['', '战列', '战列', '航母', '轻母', '轻巡', '轻巡'] - H: ['', '机场', '战巡', '战列', '战列', '战列', '重巡'] - - - A: ['', '战列', '战巡', '战列', '重巡', '潜艇', '潜艇'] - B: ['', '航母', '战巡', '战巡', '轻母', '驱逐', '导驱'] - C: ['', '航母', '航母', '战列', '战巡', '驱逐', '驱逐'] - D: ['', '战列', '航母', '战巡', '重巡', '轻巡', '大巡'] - E: ['', '航母', '战巡', '战巡', '重巡', '潜艇', '轻巡'] - F: ['', '战列', '战列', '战巡', '战巡', '轻巡', '轻巡'] - G: ['', '战列', '战列', '重巡', '重巡', '重巡'] - H: ['', '战列', '航母', '战列', '战巡', '轻巡', '潜艇'] - I: ['', '战列', '导战', '航母', '重巡', '重巡', '轻巡'] - J: ['', '战列', '重巡', '航战', '航战', '潜艇', '战巡'] - - - - - "" - - - A: ['', '驱逐', '潜艇', '', '', '', ''] - B: ['', '重巡', '轻巡', '防驱', '', '', ''] - C: ['', '战列', '重巡', '驱逐', '', '', ''] - D: ['', '战巡', '重巡', '潜艇', '潜艇', '', ''] - E: ['', '战列', '轻母', '轻母', '驱逐', '驱逐', ''] - F: ['', '航母', '航母', '轻巡', '轻巡', '驱逐', '驱逐'] - G: ['', '战巡', '轻母', '重巡', '轻巡', '驱逐', '防驱'] - H: ['', '装母', '航母', '航母', '战列', '驱逐', '航战'] - - - A: ['', '战列', '航母', '航母', '轻母', '轻巡', '轻巡'] - B: ['', '航母', '战列', '战列', '重巡', '轻巡', '轻巡'] - C: ['', '战巡', '战列', '战列', '重巡', '轻巡', '潜艇'] - D: ['', '战列', '战列', '战巡', '潜艇', '潜艇', '潜艇'] - E: ['', '战列', '战列', '战列', '轻巡', '轻巡', '潜艇'] - F: ['', '战巡', '战巡', '战列', '重巡', '重巡', '防驱'] - G: ['', '战巡', '航母', '战列', '大巡', '轻巡', '轻巡'] - H: ['', '战列', '战列', '战列', '导驱', '轻巡', '轻巡'] - I: ['', '航母', '战列', '战列', '轻巡', '防驱', '防驱'] - J: ['', '装母', '机场', '战巡', '战列', '雷巡', '雷巡'] - - - A: ['', '航母', '航母', '战巡', '重巡', '轻巡', '潜艇'] - B: ['', '战列', '战列', '战巡', '轻巡', '轻巡', '导驱'] - C: ['', '战列', '导战', '战巡', '战巡', '轻巡', '轻巡'] - D: ['', '战列', '战巡', '战巡', '重巡', '重巡', '潜艇'] - E: ['', '战列', '战列', '轻母', '轻母', '轻巡', '防驱'] - F: ['', '航母', '轻母', '战列', '战巡', '重巡', '轻巡'] - G: ['', '航母', '航母', '战列', '战列', '重巡', '重巡'] - H: ['', '航母', '战巡', '战列', '战巡', '重巡', '轻巡'] - I: ['', '战列', '战列', '战列', '战列', '轻巡', '轻巡'] - J: ['', '战列', '战巡', '战巡', '重巡', '重巡', '驱逐'] - - - - - "" - - A : ['', '轻巡', '轻巡'] - B : ['', '雷巡', '潜艇', '潜艇'] - C : ['', '重巡', '重巡', '重巡', '重巡'] - D : ['', '战巡', '重巡', '重巡', '轻巡', '驱逐', '防驱'] - E : ['', '航母', '战巡', '重巡', '重巡', '驱逐', '驱逐'] - F : ['', '轻母', '战巡', '战巡', '轻巡', '驱逐', '潜艇'] - G : ['', '战列', '战列', '重巡', '轻巡', '轻巡', '防驱'] - H : ['', '战列', '战列', '战巡', '轻母', '轻巡', '驱逐'] - I : ['', '战巡', '战列', '航母', '轻母', '轻巡', '驱逐'] - J : ['', '机场', '战列', '驱逐', '战列', '战巡', '装母'] - - - A: ["", 战列, 战列, 战巡, 轻母, 轻巡, 轻巡] - B: ["", 航母, 战巡, 战列, 重巡, 重巡, 轻巡] - C: ["", 战巡, 战列, 战列, 战巡, 重巡, 潜艇] - D: ["", 航母, 航母, 战列, 重巡, 轻巡, 潜艇] - E: ["", 战巡, 战巡, 航母, 航母, 轻巡, 轻巡] - F: ["", 战列, 战列, 战列, 重巡, 重巡, 防驱] - G: ["", 航母, 导战, 航母, 重巡, 重巡, 重巡] - H: ["", 战列, 战列, 航母, 战巡, 重巡, 导驱] - I: ["", 航母, 轻母, 战列, 战列, 重巡, 潜艇] - J: ["", 装母, 航母, 航母, 机场, 轻母, 驱逐] - - - A: ["", 航母, 战巡, 战列, 战列, 轻巡, 防驱] - B: ["", 战列, 战巡, 战列, 战列, 重巡, 潜艇] - C: ["", 战列, 战巡, 战列, 大巡, 大巡, 轻巡] - D: ["", 战列, 战巡, 战列, 重巡, 导驱, 轻巡] - E: ["", 航母, 战列, 航母, 战列, 轻巡, 轻巡] - F: ["", 战列, 战巡, 战列, 战列, 重巡, 重巡] - G: ["", 战列, 航母, 战巡, 战列, 潜艇, 潜艇] - H: ["", 航母, 战列, 战列, 战巡, 轻巡, 防驱] - I: ["", 航母, 航母, 战列, 战列, 轻巡, 导战] - J: ["", 战列, 战列, 重巡, 航战, 航战, 战巡] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-1.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-1.yaml new file mode 100644 index 000000000..96bea94a5 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-1.yaml @@ -0,0 +1,27 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-1-1 +chapter: 1 +stage: 1 +key_points: [B, D, F] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E2]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F1]} + F1: {label: F, column: 6, index: 0, next: []} +enemy: + A: [CL] + B: [DD, DD] + C: [CL, DD, DD] + D: [DD, CL, SS] + E: [CA, CVL, DD, DD] + F: [CV, BC, SS, CLT, BBV, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-2.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-2.yaml new file mode 100644 index 000000000..c0ba0e06a --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-2.yaml @@ -0,0 +1,36 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-1-2 +chapter: 1 +stage: 2 +key_points: [B, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1]} + A1: {label: A, column: 1, index: 0, next: [B1, B2, B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + B3: {label: B, column: 2, index: 2, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + D2: {label: D, column: 4, index: 1, next: [E2, E3]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F2]} + E3: {label: E, column: 5, index: 2, next: [F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1, G2]} + F3: {label: F, column: 6, index: 2, next: [G2]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H1]} + H1: {label: H, column: 8, index: 0, next: []} +enemy: + A: [CL, DD, CL, CL, DD] + B: [CA, CA, CL, DD, DD, DD] + C: [BC, CL, DD, DD, DD, DD] + D: [CA, CVL, CL, CL, CL, DD] + E: [CVL, CA, CA, CL, DD, DD] + F: [CA, CL, CL, CL, DD, SS] + G: [BC, CVL, CL, CL, DD, DD] + H: [CVL, BB, BB, BBV, CLT, BC] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-3.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-3.yaml new file mode 100644 index 000000000..2720a777d --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-1-3.yaml @@ -0,0 +1,35 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-1-3 +chapter: 1 +stage: 3 +key_points: [D, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + D2: {label: D, column: 4, index: 1, next: [E2, E3]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F1, F2]} + E3: {label: E, column: 5, index: 2, next: [F2]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} +enemy: + A: [CA, CA, CA, CL, CL, DD] + B: [BC, CA, CL, DD, DD, SS] + C: [BB, CA, DD, CL, CL, CL] + D: [CV, CVL, CA, CL, DD, DD] + E: [CV, CA, CA, CL, DD, AADG] + F: [CV, BB, CA, CL, DD, DD] + G: [BB, BC, CVL, CL, CL, DD] + H: [BC, BBV, CLT, BBV, BBV, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-1.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-1.yaml new file mode 100644 index 000000000..5b2a9348f --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-1.yaml @@ -0,0 +1,27 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-2-1 +chapter: 2 +stage: 1 +key_points: [C, F] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2, D3]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E1]} + D3: {label: D, column: 4, index: 2, next: [E1]} + E1: {label: E, column: 5, index: 0, next: [F1]} + F1: {label: F, column: 6, index: 0, next: []} +enemy: + A: [DD, DD] + B: [DD, DD, AADG] + C: [CL, DD, CL, DD] + D: [CA, CL, CL, DD] + E: [CA, CL, AADG, SS] + F: [CV, CV, CV, BC, BBV, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-2.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-2.yaml new file mode 100644 index 000000000..d4571ec32 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-2.yaml @@ -0,0 +1,36 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-2-2 +chapter: 2 +stage: 2 +key_points: [B, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + A2: {label: A, column: 1, index: 1, next: [B2, B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C2]} + B3: {label: B, column: 2, index: 2, next: [C3]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D1, D2]} + C3: {label: C, column: 3, index: 2, next: [D2]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E1]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} +enemy: + A: [BC, BC, CVL, CL, DD, DD] + B: [BB, BC, CA, CL, DD, DD] + C: [BC, CA, CL, DD, SS, SS] + D: [BB, CVL, CA, CL, DD, ASDG] + E: [BB, BB, CVL, CVL, DD, DD] + F: [BB, CV, CVL, CA, CL, DD] + G: [BB, CV, CA, CL, DD, SS] + H: [AF, BC, BB, BB, SS, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-3.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-3.yaml new file mode 100644 index 000000000..fb19dc87b --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-2-3.yaml @@ -0,0 +1,37 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-2-3 +chapter: 2 +stage: 3 +key_points: [D, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + B1: {label: B, column: 2, index: 0, next: [C1, C2]} + B2: {label: B, column: 2, index: 1, next: [C2, C3]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D2]} + C3: {label: C, column: 3, index: 2, next: [D3]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E1, E2]} + D3: {label: D, column: 4, index: 2, next: [E2]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + E2: {label: E, column: 5, index: 1, next: [F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + F3: {label: F, column: 6, index: 2, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} +enemy: + A: [BB, BC, CVL, CL, CL, DD] + B: [CV, CV, CA, CL, CL, DD] + C: [BB, CV, CVL, CA, CL, CL] + D: [BB, BG, BC, CA, CA, DD] + E: [CV, BB, BC, DD, DD, SS] + F: [BB, BB, CV, CL, CL, SS] + G: [BB, BC, BB, CVL, CL, SS] + H: [BB, CVL, BC, CL, SS, CA] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-1.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-1.yaml new file mode 100644 index 000000000..86f1b32cd --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-1.yaml @@ -0,0 +1,35 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-3-1 +chapter: 3 +stage: 1 +key_points: [C, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1]} + A1: {label: A, column: 1, index: 0, next: [B1, B2, B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1, C2]} + B3: {label: B, column: 2, index: 2, next: [C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D2]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E1]} + E1: {label: E, column: 5, index: 0, next: [F1, F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + F3: {label: F, column: 6, index: 2, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} +enemy: + A: [CL, DD] + B: [DD, DD, SS] + C: [CVL, CA, CL, DD] + D: [CA, CVL, CA, CL, DD] + E: [CA, CA, CA, CA, DD, DD] + F: [CA, CA, CLT, CL, DD, SS] + G: [CV, CA, CA, CL, CL, DD] + H: [CV, CV, BC, CVL, CL, BB] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-2.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-2.yaml new file mode 100644 index 000000000..72568e0b9 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-2.yaml @@ -0,0 +1,34 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-3-2 +chapter: 3 +stage: 2 +key_points: [B, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2, D3]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E1, E2]} + D3: {label: D, column: 4, index: 2, next: [E2]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F1]} + F1: {label: F, column: 6, index: 0, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} +enemy: + A: [BB, BB, BC, DD, DD, CL] + B: [CV, BC, BC, CVL, DD, DD] + C: [BB, BB, BG, CA, CL, DD] + D: [BC, CV, CV, DD, DD, SS] + E: [BC, CV, CV, CVL, CL, CL] + F: [BB, BC, CV, CL, AADG, SS] + G: [BB, BB, BC, BC, CLT, DD] + H: [BB, BC, BC, CLT, SS, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-3.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-3.yaml new file mode 100644 index 000000000..7d9273c66 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-3-3.yaml @@ -0,0 +1,44 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-3-3 +chapter: 3 +stage: 3 +key_points: [D, H, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2, A3]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B2]} + A3: {label: A, column: 1, index: 2, next: [B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1, C2]} + B3: {label: B, column: 2, index: 2, next: [C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D2]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E1]} + E1: {label: E, column: 5, index: 0, next: [F1, F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1, G2]} + F3: {label: F, column: 6, index: 2, next: [G2]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H1]} + H1: {label: H, column: 8, index: 0, next: [I1, I2]} + I1: {label: I, column: 9, index: 0, next: [J1, J2]} + I2: {label: I, column: 9, index: 1, next: [J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [BC, CV, BC, CVL, CL, DD] + B: [BC, BC, BB, CA, CL, CL] + C: [BB, BB, BC, CL, CL, ASDG] + D: [CV, BB, BG, CA, CA, CA] + E: [BB, BC, BC, CV, CL, DD] + F: [BB, BB, BC, CA, CL, SS] + G: [BB, BB, CV, CVL, SS, SS] + H: [CV, CV, BB, CL, CL, AADG] + I: [BC, BB, BC, CV, CVL, DD] + J: [BC, BBV, BBV, BC, CA, BC] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-1.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-1.yaml new file mode 100644 index 000000000..db51c414f --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-1.yaml @@ -0,0 +1,34 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-4-1 +chapter: 4 +stage: 1 +key_points: [C, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D1]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + E2: {label: E, column: 5, index: 1, next: [F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1, G2]} + F3: {label: F, column: 6, index: 2, next: [G2]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H1]} + H1: {label: H, column: 8, index: 0, next: []} +enemy: + A: [CL, CL, DD] + B: [CA, CA, DD, DD] + C: [CLT, CLT, CL, CL, SS] + D: [BC, CVL, CVL, CL, DD] + E: [BB, CA, CL, CVL, CL, DD] + F: [CV, BC, CL, DD, DD, AADG] + G: [BB, BG, CA, CA, CL, DD] + H: [CV, CV, CVL, CL, BBV, BBV] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-2.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-2.yaml new file mode 100644 index 000000000..4168ff820 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-2.yaml @@ -0,0 +1,35 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-4-2 +chapter: 4 +stage: 2 +key_points: [B, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + A2: {label: A, column: 1, index: 1, next: [B2, B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1, C2]} + B3: {label: B, column: 2, index: 2, next: [C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D1]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F2]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} +enemy: + A: [BC, CV, CV, CL, DD, DD] + B: [BB, BC, BC, CA, DD, SS] + C: [CV, CV, BB, CLT, CL, CL] + D: [BB, CV, BG, CA, DD, AADG] + E: [BC, BC, CV, CL, CL, ASDG] + F: [BB, BB, BB, CA, DD, SS] + G: [BB, BB, CV, CVL, CL, CL] + H: [AF, BC, BB, BB, BB, CA] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-3.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-3.yaml new file mode 100644 index 000000000..06b695174 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-4-3.yaml @@ -0,0 +1,43 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-4-3 +chapter: 4 +stage: 3 +key_points: [D, H, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2, A3]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B1, B2]} + A3: {label: A, column: 1, index: 2, next: [B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D1]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + E2: {label: E, column: 5, index: 1, next: [F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1, G2]} + F3: {label: F, column: 6, index: 2, next: [G2]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H2]} + H1: {label: H, column: 8, index: 0, next: [I1]} + H2: {label: H, column: 8, index: 1, next: [I1]} + I1: {label: I, column: 9, index: 0, next: [J1, J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [BB, BC, BB, CA, SS, SS] + B: [CV, BC, BC, CVL, DD, ASDG] + C: [CV, CV, BB, BC, DD, DD] + D: [BB, CV, BC, CA, CL, BG] + E: [CV, BC, BC, CA, SS, CL] + F: [BB, BB, BC, BC, CL, CL] + G: [BB, BB, BB, CA, CA, CA] + H: [BB, CV, BB, BC, CL, SS] + I: [BB, BBG, CV, CA, CA, CL] + J: [BB, CA, BBV, BBV, SS, BC] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-1.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-1.yaml new file mode 100644 index 000000000..178c4b493 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-1.yaml @@ -0,0 +1,35 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-5-1 +chapter: 5 +stage: 1 +key_points: [D, F, H] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B1]} + B1: {label: B, column: 2, index: 0, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + D2: {label: D, column: 4, index: 1, next: [E2, E3]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F1, F2]} + E3: {label: E, column: 5, index: 2, next: [F2]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2, H3]} + H1: {label: H, column: 8, index: 0, next: []} + H2: {label: H, column: 8, index: 1, next: []} + H3: {label: H, column: 8, index: 2, next: []} +enemy: + A: [DD, SS] + B: [CA, CL, AADG] + C: [BB, CA, DD] + D: [BC, CA, SS, SS] + E: [BB, CVL, CVL, DD, DD] + F: [CV, CV, CL, CL, DD, DD] + G: [BC, CVL, CA, CL, DD, AADG] + H: [AV, CV, CV, BB, DD, BBV] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-2.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-2.yaml new file mode 100644 index 000000000..3468b2159 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-2.yaml @@ -0,0 +1,41 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-5-2 +chapter: 5 +stage: 2 +key_points: [D, G, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2, A3]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B1, B2]} + A3: {label: A, column: 1, index: 2, next: [B2]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + E2: {label: E, column: 5, index: 1, next: [F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1, G2]} + F3: {label: F, column: 6, index: 2, next: [G2]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H1]} + H1: {label: H, column: 8, index: 0, next: [I1]} + I1: {label: I, column: 9, index: 0, next: [J1, J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [BB, CV, CV, CVL, CL, CL] + B: [CV, BB, BB, CA, CL, CL] + C: [BC, BB, BB, CA, CL, SS] + D: [BB, BB, BC, SS, SS, SS] + E: [BB, BB, BB, CL, CL, SS] + F: [BC, BC, BB, CA, CA, AADG] + G: [BC, CV, BB, BG, CL, CL] + H: [BB, BB, BB, ASDG, CL, CL] + I: [CV, BB, BB, CL, AADG, AADG] + J: [AV, AF, BC, BB, CLT, CLT] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-3.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-3.yaml new file mode 100644 index 000000000..10e99c0f3 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-5-3.yaml @@ -0,0 +1,42 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-5-3 +chapter: 5 +stage: 3 +key_points: [C, G, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B2]} + B1: {label: B, column: 2, index: 0, next: [C1, C2]} + B2: {label: B, column: 2, index: 1, next: [C2, C3]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D1]} + C3: {label: C, column: 3, index: 2, next: [D1]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + E2: {label: E, column: 5, index: 1, next: [F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + F3: {label: F, column: 6, index: 2, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1]} + H1: {label: H, column: 8, index: 0, next: [I1, I2]} + I1: {label: I, column: 9, index: 0, next: [J1, J2]} + I2: {label: I, column: 9, index: 1, next: [J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [CV, CV, BC, CA, CL, SS] + B: [BB, BB, BC, CL, CL, ASDG] + C: [BB, BBG, BC, BC, CL, CL] + D: [BB, BC, BC, CA, CA, SS] + E: [BB, BB, CVL, CVL, CL, AADG] + F: [CV, CVL, BB, BC, CA, CL] + G: [CV, CV, BB, BB, CA, CA] + H: [CV, BC, BB, BC, CA, CL] + I: [BB, BB, BB, BB, CL, CL] + J: [BB, BC, BC, CA, CA, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-1.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-1.yaml new file mode 100644 index 000000000..6f9d024f0 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-1.yaml @@ -0,0 +1,43 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-6-1 +chapter: 6 +stage: 1 +key_points: [B, G, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2]} + A1: {label: A, column: 1, index: 0, next: [B1, B2]} + A2: {label: A, column: 1, index: 1, next: [B2, B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1]} + B3: {label: B, column: 2, index: 2, next: [C1]} + C1: {label: C, column: 3, index: 0, next: [D1, D2]} + D1: {label: D, column: 4, index: 0, next: [E1]} + D2: {label: D, column: 4, index: 1, next: [E2]} + E1: {label: E, column: 5, index: 0, next: [F1, F2]} + E2: {label: E, column: 5, index: 1, next: [F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1, G2]} + F3: {label: F, column: 6, index: 2, next: [G2]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H1]} + H1: {label: H, column: 8, index: 0, next: [I1, I2]} + I1: {label: I, column: 9, index: 0, next: [J1, J2]} + I2: {label: I, column: 9, index: 1, next: [J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [CL, CL] + B: [CLT, SS, SS] + C: [CA, CA, CA, CA] + D: [BC, CA, CA, CL, DD, AADG] + E: [CV, BC, CA, CA, DD, DD] + F: [CVL, BC, BC, CL, DD, SS] + G: [BB, BB, CA, CL, CL, AADG] + H: [BB, BB, BC, CVL, CL, DD] + I: [BC, BB, CV, CVL, CL, DD] + J: [AF, BB, DD, BB, BC, AV] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-2.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-2.yaml new file mode 100644 index 000000000..c9853f402 --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-2.yaml @@ -0,0 +1,44 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-6-2 +chapter: 6 +stage: 2 +key_points: [C, H, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2, A3]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B2]} + A3: {label: A, column: 1, index: 2, next: [B3]} + B1: {label: B, column: 2, index: 0, next: [C1]} + B2: {label: B, column: 2, index: 1, next: [C1, C2]} + B3: {label: B, column: 2, index: 2, next: [C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D1]} + D1: {label: D, column: 4, index: 0, next: [E1]} + E1: {label: E, column: 5, index: 0, next: [F1, F2, F3]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G2]} + F3: {label: F, column: 6, index: 2, next: [G3]} + G1: {label: G, column: 7, index: 0, next: [H1]} + G2: {label: G, column: 7, index: 1, next: [H1, H2]} + G3: {label: G, column: 7, index: 2, next: [H2]} + H1: {label: H, column: 8, index: 0, next: [I1]} + H2: {label: H, column: 8, index: 1, next: [I1]} + I1: {label: I, column: 9, index: 0, next: [J1, J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [BB, BB, BC, CVL, CL, CL] + B: [CV, BC, BB, CA, CA, CL] + C: [BC, BB, BB, BC, CA, SS] + D: [CV, CV, BB, CA, CL, SS] + E: [BC, BC, CV, CV, CL, CL] + F: [BB, BB, BB, CA, CA, AADG] + G: [CV, BBG, CV, CA, CA, CA] + H: [BB, BB, CV, BC, CA, ASDG] + I: [CV, CVL, BB, BB, CA, SS] + J: [AV, CV, CV, AF, CVL, DD] diff --git a/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-3.yaml b/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-3.yaml new file mode 100644 index 000000000..ad6ab8c2b --- /dev/null +++ b/autowsgr/data/map/decisive_battle/silent_warrior/EX-6-3.yaml @@ -0,0 +1,43 @@ +# 决战「沉默的战士」节点图。 +# 节点编号保留分支后缀(如 A1、A2)。坐标待实测后补入。 +schema_version: 1 +event: silent_warrior +mapping_type: node_graph +map_id: EX-6-3 +chapter: 6 +stage: 3 +key_points: [D, G, J] +nodes: + '0': {label: '0', column: 0, index: 0, next: [A1, A2, A3]} + A1: {label: A, column: 1, index: 0, next: [B1]} + A2: {label: A, column: 1, index: 1, next: [B1]} + A3: {label: A, column: 1, index: 2, next: [B1]} + B1: {label: B, column: 2, index: 0, next: [C1, C2]} + C1: {label: C, column: 3, index: 0, next: [D1]} + C2: {label: C, column: 3, index: 1, next: [D2]} + D1: {label: D, column: 4, index: 0, next: [E1, E2]} + D2: {label: D, column: 4, index: 1, next: [E2, E3]} + E1: {label: E, column: 5, index: 0, next: [F1]} + E2: {label: E, column: 5, index: 1, next: [F1, F2]} + E3: {label: E, column: 5, index: 2, next: [F2]} + F1: {label: F, column: 6, index: 0, next: [G1]} + F2: {label: F, column: 6, index: 1, next: [G1]} + G1: {label: G, column: 7, index: 0, next: [H1, H2]} + H1: {label: H, column: 8, index: 0, next: [I1]} + H2: {label: H, column: 8, index: 1, next: [I2]} + I1: {label: I, column: 9, index: 0, next: [J1, J2]} + I2: {label: I, column: 9, index: 1, next: [J2, J3]} + J1: {label: J, column: 10, index: 0, next: []} + J2: {label: J, column: 10, index: 1, next: []} + J3: {label: J, column: 10, index: 2, next: []} +enemy: + A: [CV, BC, BB, BB, CL, AADG] + B: [BB, BC, BB, BB, CA, SS] + C: [BB, BC, BB, BG, BG, CL] + D: [BB, BC, BB, CV, ASDG, CL] + E: [CV, BB, CV, BB, CL, CL] + F: [BB, BC, BB, BB, CA, CA] + G: [BB, CV, BC, BB, SS, SS] + H: [CV, BB, BB, BC, CL, AADG] + I: [CV, CV, BB, BB, CL, BBG] + J: [BB, BB, CA, BBV, BBV, BC] diff --git a/autowsgr/ops/decisive/config.py b/autowsgr/ops/decisive/config.py index b3197f30b..79d1d1dd6 100644 --- a/autowsgr/ops/decisive/config.py +++ b/autowsgr/ops/decisive/config.py @@ -1,164 +1,233 @@ -"""决战控制器配置与地图数据。""" +"""决战 EX 地图:分支路线 ID 与可观测的节点字母分别查询。""" from __future__ import annotations +from dataclasses import dataclass from functools import lru_cache from pathlib import Path +from typing import TYPE_CHECKING + +from autowsgr_native.vessel_type import VesselType from autowsgr.combat.node_fusion.map import SHIP_TYPES, TrackingMap from autowsgr.infra.file_utils import load_yaml -_ENEMY_SPEC_PATH = ( - Path(__file__).resolve().parents[2] / 'data' / 'map' / 'decisive_battle' / 'enemy_spec.yaml' +if TYPE_CHECKING: + from collections.abc import Sequence + + +_MAP_DATA_ROOT = ( + Path(__file__).resolve().parents[2] / 'data' / 'map' / 'decisive_battle' / 'silent_warrior' ) -# ═══════════════════════════════════════════════════════════════════════════════ -# 地图静态数据 -# ═══════════════════════════════════════════════════════════════════════════════ - -# 数据来源: autowsgr_legacy/data/map/decisive_battle/enemy_spec.yaml -# map_end[chapter][stage] → 该小关最后一个节点字母 -# chapter 索引 0 为占位; 有效章节 1-6; stage 索引 0 为占位, 有效小关 1-3。 -_MAP_END: list[str] = [ - '', # 0: 占位 - ' FHH', # chapter 1: stage1=F, stage2=H, stage3=H - ' FHH', # chapter 2 - ' HHJ', # chapter 3 - ' HHJ', # chapter 4 - ' HJJ', # chapter 5 - ' JJJ', # chapter 6 -] - -# key_points[chapter][stage] → 需要夜战的关键节点字母集合 -_KEY_POINTS: dict[int, list[str]] = { - 1: ['', 'BDF', 'BFH', 'DHJ'], - 2: ['', 'CFH', 'BFH', 'DHJ'], - 3: ['', 'CFH', 'BFH', 'DHJ'], - 4: ['', 'CFH', 'BFH', 'DHJ'], - 5: ['', 'DFH', 'DGJ', 'CGJ'], - 6: ['', 'BGJ', 'CHJ', 'DGJ'], -} - - -@lru_cache(maxsize=1) -def _load_enemy_spec_data() -> dict: - """加载决战 enemy_spec.yaml 数据。""" - return load_yaml(_ENEMY_SPEC_PATH) - - -def _enemy_slots(raw: object, location: str) -> list[str | None]: - """移除旧资料的首位占位,保留空槽位置并补足六槽;缺失资料不构造舰队。""" - if raw is None or raw == []: +@dataclass(frozen=True, slots=True) +class DecisiveRouteNode: + """一个路线卡片的位置;column/index 是拓扑索引,不是屏幕坐标。""" + + label: str + column: int + index: int + next_nodes: tuple[str, ...] + + +@dataclass(frozen=True, slots=True) +class _MapGraph: + nodes: dict[str, DecisiveRouteNode] + enemies: dict[str, tuple[str | None, ...]] + key_points: frozenset[str] + stage_end: str + + +def enemy_codes_to_slots(enemy: Sequence[str | None]) -> list[str | None]: + """按 EX 敌方编队顺序返回六个位置的中文舰种。空位记为 None,缺失敌情返回 []。 + + AF 是 EX 资料的机场代码,与 native 的 AP 补给舰不同。 + 遇到未知代码时报错,以便核对原始敌情。 + """ + if not isinstance(enemy, (list, tuple)) or len(enemy) > 6: + raise ValueError('决战敌情应为列表,最多容纳六艘舰船') + if not enemy: return [] - if not isinstance(raw, list) or not 1 <= len(raw) <= 7 or raw[0] not in ('', None): - raise ValueError(f'决战敌情必须包含首位占位和至多六槽: {location}') - slots = [ship if ship not in ('', None) else None for ship in raw[1:]] - if any( - ship is not None and (not isinstance(ship, str) or ship not in SHIP_TYPES) for ship in slots - ): - raise ValueError(f'决战敌情包含未知中文舰类: {location}: {slots!r}') + slots: list[str | None] = [] + for code in enemy: + if code is None or code == '': + slots.append(None) + continue + if not isinstance(code, str): + raise TypeError(f'决战敌情包含无效舰类: {code!r}') + if code in SHIP_TYPES: + slots.append(code) + continue + native_code = 'Airfield' if code.upper() == 'AF' else code.upper() + try: + native = VesselType.from_english(native_code) + except (AttributeError, ValueError) as exc: + raise ValueError(f'决战敌情包含未知舰类: {code!r}') from exc + if native is None or native.as_chinese() not in SHIP_TYPES: + raise ValueError(f'决战敌情包含未知舰类: {code!r}') + slots.append(native.as_chinese()) return slots + [None] * (6 - len(slots)) -class MapData: - """决战地图静态数据查询。 +def _check_map_id(chapter: int, stage: int) -> None: + if ( + type(chapter) is not int + or type(stage) is not int + or not 1 <= chapter <= 6 + or not 1 <= stage <= 3 + ): + raise ValueError(f'无效章节/小关: chapter={chapter}, stage={stage}') + + +@lru_cache(maxsize=18) +def _load_map_data(chapter: int, stage: int) -> _MapGraph: + _check_map_id(chapter, stage) + path = _MAP_DATA_ROOT / f'EX-{chapter}-{stage}.yaml' + data = load_yaml(path) + if not isinstance(data, dict) or data.get('chapter') != chapter or data.get('stage') != stage: + raise ValueError(f'决战地图编号不一致: {path}') + raw_nodes = data.get('nodes') + if not isinstance(raw_nodes, dict) or '0' not in raw_nodes: + raise ValueError(f'决战地图缺少路线图: {path}') + nodes = {} + for node_id, raw in raw_nodes.items(): + if not isinstance(node_id, str) or not isinstance(raw, dict): + raise TypeError(f'决战路线节点无效: {path}: {node_id!r}') + label, successors = raw.get('label'), raw.get('next') + if ( + not isinstance(label, str) + or not label + or not isinstance(successors, list) + or any(not isinstance(target, str) or target not in raw_nodes for target in successors) + or len(set(successors)) != len(successors) + or type(raw.get('column')) is not int + or type(raw.get('index')) is not int + or raw['column'] < 0 + or raw['index'] < 0 + ): + raise ValueError(f'决战路线数据无效: {path}: {node_id}') + nodes[node_id] = DecisiveRouteNode( + label.upper(), raw['column'], raw['index'], tuple(successors) + ) + terminal_labels = { + node.label for node_id, node in nodes.items() if node_id != '0' and not node.next_nodes + } + if len(terminal_labels) != 1: + raise ValueError(f'决战地图必须具有唯一终点字母: {path}') + labels = {node.label for node_id, node in nodes.items() if node_id != '0'} + raw_enemies = data.get('enemy', {}) + raw_keys = data.get('key_points', []) + if not isinstance(raw_enemies, dict) or any(label not in labels for label in raw_enemies): + raise ValueError(f'决战敌情节点无效: {path}') + if not isinstance(raw_keys, list) or any(label not in labels for label in raw_keys): + raise ValueError(f'决战关键节点无效: {path}') + enemies = {label: tuple(enemy_codes_to_slots(ships)) for label, ships in raw_enemies.items()} + return _MapGraph(nodes, enemies, frozenset(raw_keys), terminal_labels.pop()) - 封装 ``map_end`` 与 ``key_points``,提供按 *chapter / stage* 查询的方法。 - """ + +class MapData: + """唯一 EX 数据源;原生定位使用字母,路线选择使用带后缀的 ID。""" @staticmethod def get_stage_end_node(chapter: int, stage: int) -> str: - """获取指定章节、小关的终止节点字母。 - - Parameters - ---------- - chapter: - 章节编号 (1-6)。 - stage: - 小关编号 (1-3)。 - - Returns - ------- - str - 终止节点字母 (如 ``'H'``, ``'J'``)。 - 若 chapter/stage 超出范围,抛出 ``ValueError``。 - """ - if 1 <= chapter < len(_MAP_END) and 1 <= stage <= 3: - return _MAP_END[chapter][stage] - raise ValueError(f'无效章节/小关: chapter={chapter}, stage={stage}') + """返回共同终点字母;这是静态预测,不能代替实际通关画面。""" + return _load_map_data(chapter, stage).stage_end + + @staticmethod + def get_node_label(chapter: int, stage: int, node: str) -> str | None: + """接受节点字母或精确路线 ID,未知节点返回 None。""" + graph = _load_map_data(chapter, stage) + value = node.strip().upper() + route_node = graph.nodes.get(value) + if route_node is not None: + return route_node.label + return value if any(item.label == value for item in graph.nodes.values()) else None @staticmethod def is_stage_end(chapter: int, stage: int, node: str) -> bool: - """判断当前节点是否为该小关的终止节点。 - - Parameters - ---------- - chapter: - 章节编号 (1-6)。 - stage: - 小关编号 (1-3)。 - node: - 当前节点字母 (如 ``'A'``, ``'H'``)。 - """ - return node == MapData.get_stage_end_node(chapter, stage) + return MapData.get_node_label(chapter, stage, node) == MapData.get_stage_end_node( + chapter, stage + ) @staticmethod def get_key_points(chapter: int, stage: int) -> set[str]: - """获取指定章节、小关的关键节点集合 (需夜战)。 - - Parameters - ---------- - chapter: - 章节编号 (4-6)。 - stage: - 小关编号 (1-3)。 - - Returns - ------- - set[str] - 关键节点字母集合;未找到时返回空集。 - """ - kps = _KEY_POINTS.get(chapter, []) - if 1 <= stage < len(kps): - return set(kps[stage]) - return set() + """返回 EX 声明的夜战关键字母,非法编号不产生关键节点。""" + try: + _check_map_id(chapter, stage) + except ValueError: + return set() + return set(_load_map_data(chapter, stage).key_points) @staticmethod def is_key_point(chapter: int, stage: int, node: str) -> bool: - """判断当前节点是否为关键点 (需夜战)。""" - return node in MapData.get_key_points(chapter, stage) + return MapData.get_node_label(chapter, stage, node) in MapData.get_key_points( + chapter, stage + ) @staticmethod def get_enemy(chapter: int, stage: int, node: str) -> list[str | None]: - """获取有序六槽中文舰类;空槽为 None,缺失节点资料返回空列表。""" - if not 1 <= chapter < len(_MAP_END) or not 1 <= stage <= 3: - return [] + """按 EX 敌方编队顺序返回中文舰种,空位为 None。缺少该节点的记录时返回 []。""" try: - data = _load_enemy_spec_data() - enemy_data = data.get('enemy', []) - chapter_data = enemy_data[chapter] - stage_data = chapter_data[stage] - except (IndexError, TypeError): - return [] - if not isinstance(stage_data, dict): + _check_map_id(chapter, stage) + except ValueError: return [] - return _enemy_slots(stage_data.get(node.upper()), f'{chapter}-{stage} {node}') + graph = _load_map_data(chapter, stage) + label = MapData.get_node_label(chapter, stage, node) + return list(graph.enemies.get(label, ())) + + @staticmethod + def get_route_nodes(chapter: int, stage: int) -> dict[str, DecisiveRouteNode]: + """返回保留 A1/A2 等分支 ID 的路线快照,调用者不能修改缓存字典。""" + return dict(_load_map_data(chapter, stage).nodes) + + @staticmethod + def get_leftmost_choices(chapter: int, stage: int, source_node: str) -> list[str]: + """精确 ID 取其真实后继;裸字母沿始终选择首条边的路线定位。""" + nodes = _load_map_data(chapter, stage).nodes + source = source_node.strip().upper() + if source in {'', 'U'}: + source = '0' + if source in nodes: + return list(nodes[source].next_nodes) + current = '0' + visited: set[str] = set() + while current not in visited: + visited.add(current) + node = nodes[current] + if node.label == source: + return list(node.next_nodes) + if not node.next_nodes: + break + current = node.next_nodes[0] + return [] @staticmethod def tracking_map(chapter: int, stage: int) -> TrackingMap: - """构造小关顺序地图;不为未知阵型、坐标或敌情伪造观测。""" - end = MapData.get_stage_end_node(chapter, stage) - names = [chr(value) for value in range(ord('A'), ord(end) + 1)] + """将 EX 的真实边投影到可观测字母,保留 #580 的顺序小关生命周期。 + + 相同字母的路线卡必须具有相同的后继字母,才可合并为一个追踪节点。 + 分支索引不是屏幕坐标;EX 未提供的坐标、阵型、类型、迂回均保持未知。 + """ + graph = _load_map_data(chapter, stage) raw = {} - for index, name in enumerate(names): - ships = MapData.get_enemy(chapter, stage, name) - raw[name] = { + for node_id, node in graph.nodes.items(): + if node_id == '0': + continue + successors = list( + dict.fromkeys(graph.nodes[target].label for target in node.next_nodes) + ) + if len(successors) > 1 or (node.label in raw and raw[node.label]['next'] != successors): + raise ValueError( + f'决战路线不能无歧义地投影到顺序字母: {chapter}-{stage}: {node_id}' + ) + ships = list(graph.enemies.get(node.label, ())) + raw[node.label] = { 'position': None, - 'next': names[index + 1 : index + 2], - 'type': 'FIGHT', + 'next': successors, + 'type': None, 'detour': None, - 'enemy_formations': ([{'formation': None, 'ships': ships}] if any(ships) else None), + 'enemy_formations': [{'formation': None, 'ships': ships}] if ships else None, } - return TrackingMap.from_dict(raw, source=str(_ENEMY_SPEC_PATH)) + return TrackingMap.from_dict(raw, source=str(_MAP_DATA_ROOT / f'EX-{chapter}-{stage}.yaml')) diff --git a/testing/ops/test_decisive_metadata.py b/testing/ops/test_decisive_metadata.py index 13a9e0c1c..264776a6e 100644 --- a/testing/ops/test_decisive_metadata.py +++ b/testing/ops/test_decisive_metadata.py @@ -1,78 +1,84 @@ -"""决战中文迁移保留全部旧槽位及战术决策,未知资料不伪造信息。""" +"""验证 EX 地图迁移保留原图路线、敌方编队顺序和战术决策,资料缺失时保留未知。""" from __future__ import annotations import hashlib import json +from pathlib import Path import pytest -from autowsgr_native.vessel_type import VesselType +import yaml from autowsgr.infra import DecisiveConfig -from autowsgr.ops.decisive.config import MapData, _enemy_slots, _load_enemy_spec_data +from autowsgr.ops.decisive.config import MapData, enemy_codes_to_slots from autowsgr.ops.decisive.logic import DecisiveLogic, _count_anti_sub from autowsgr.ops.decisive.state import DecisiveState from autowsgr.types import Formation -# 282ca457 原始 84 节点列表的摘要;包含章、小关、节点、首位占位及空槽。 -_LEGACY_DIGEST = 'b495cbe91e764f4bf319b367837ae6465da2b5df698953fe39761b9f9b8d063b' -_LEGACY_ANTI_SUB = { - (4, 1): '32244322', - (4, 2): '31212130', - (4, 3): '0221120110', - (5, 1): '11104431', - (5, 2): '3210202210', - (5, 3): '1220320121', - (6, 1): '2002232331', - (6, 2): '3101200012', - (6, 3): '1011200110', -} - - -def test_all_84_migrated_fleets_preserve_order_and_placeholder() -> None: - legacy_codes = { - value.as_chinese(): value.as_english() - for name in dir(VesselType) - if isinstance(value := getattr(VesselType, name), VesselType) - } - legacy_codes.update({'机场': 'AF', '大巡': 'BG', '导战': 'BBG', '': ''}) - rows = [ - (chapter, stage, node, [legacy_codes[ship] for ship in ships]) - for chapter, chapters in enumerate(_load_enemy_spec_data()['enemy']) - if isinstance(chapters, list) - for stage, stages in enumerate(chapters) - if isinstance(stages, dict) - for node, ships in stages.items() - ] - assert len(rows) == 84 - payload = json.dumps(rows, ensure_ascii=False, separators=(',', ':')).encode() - assert hashlib.sha256(payload).hexdigest() == _LEGACY_DIGEST - - -@pytest.mark.parametrize(('chapter', 'stage'), _LEGACY_ANTI_SUB) -@pytest.mark.parametrize('submarine', [False, True]) -def test_all_84_formation_decisions_match_legacy(chapter: int, stage: int, submarine: bool) -> None: - state = DecisiveState(chapter=chapter, stage=stage, node='A') - if submarine: - state.fleet[1] = 'U-1206' - logic = DecisiveLogic(DecisiveConfig(chapter=chapter), state) - for index, count in enumerate(_LEGACY_ANTI_SUB[chapter, stage]): - node = chr(ord('A') + index) - slots = MapData.get_enemy(chapter, stage, node) - assert len(slots) == 6 - assert _count_anti_sub(slots) == int(count) - expected = Formation.wedge if int(count) <= int(submarine) else Formation.double_column - assert logic.get_formation(node) == expected - # 计算其它候选的战术不修改用于界面显示的当前节点。 - assert state.node == 'A' +# 18 份 ShiinaKuroko EX 原始 YAML 解析后的摘要,不受换行或字典顺序影响。 +_SOURCE_DIGEST = '749a8c66348b7f9ac41d2a0a3ca04550d1d3c4c7f1e21d8a8c2da53a0407539d' + + +def test_all_ex_maps_preserve_topology_enemy_order_and_tactics() -> None: + root = Path(__file__).resolve().parents[2] / 'autowsgr/data/map/decisive_battle/silent_warrior' + rows = [yaml.safe_load(path.read_bytes()) for path in sorted(root.glob('EX-*.yaml'))] + payload = json.dumps(rows, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode() + assert hashlib.sha256(payload).hexdigest() == _SOURCE_DIGEST + assert len(rows) == 18 + nodes = edges = records = 0 + for row in rows: + chapter, stage = row['chapter'], row['stage'] + routes = MapData.get_route_nodes(chapter, stage) + metadata = MapData.tracking_map(chapter, stage) + nodes += len(routes) + assert set(routes) == row['nodes'].keys() + assert MapData.get_key_points(chapter, stage) == set(row['key_points']) + state = DecisiveState(chapter=chapter, stage=stage) + logic = DecisiveLogic(DecisiveConfig(chapter=chapter), state) + for index, route in routes.items(): + assert route.next_nodes == tuple(row['nodes'][index]['next']) + edges += len(route.next_nodes) + if index != '0': + assert MapData.is_stage_end(chapter, stage, index) == (not route.next_nodes) + successors = tuple(dict.fromkeys(routes[item].label for item in route.next_nodes)) + assert metadata.nodes[route.label].next_nodes == successors + for label, raw in row['enemy'].items(): + records += 1 + slots = MapData.get_enemy(chapter, stage, label) + assert slots == enemy_codes_to_slots(raw) + assert len(slots) == 6 + assert metadata.nodes[label].enemy_formations[0].ships == tuple(slots) + for has_sub in (False, True): + state.fleet[1] = 'U-1206' if has_sub else '' + expected = ( + Formation.wedge + if _count_anti_sub(slots) <= has_sub + else Formation.double_column + ) + assert logic.get_formation(label) == expected + assert (nodes, edges, records) == (319, 401, 154) + + +@pytest.mark.parametrize( + ('chapter', 'stage', 'node', 'slots'), + [ + (4, 1, 'G', ['战列', '大巡', '重巡', '重巡', '轻巡', '驱逐']), + (4, 3, 'G', ['战列', '战列', '战列', '重巡', '重巡', '重巡']), + (6, 3, 'D', ['战列', '战巡', '战列', '航母', '导驱', '轻巡']), + ], +) +def test_conflicting_legacy_records_use_ex( + chapter: int, stage: int, node: str, slots: list[str] +) -> None: + assert MapData.get_enemy(chapter, stage, node) == slots def test_six_slot_loader_preserves_airport_and_internal_empty_slot() -> None: assert MapData.get_enemy(6, 1, 'A') == ['轻巡', '轻巡', None, None, None, None] assert MapData.get_enemy(6, 1, 'J')[0] == '机场' assert MapData.get_enemy(6, 2, 'J')[3] == '机场' - assert _enemy_slots(['', '大巡', '', '导战', '补给'], 'test') == [ + assert enemy_codes_to_slots(['大巡', '', '导战', '补给']) == [ '大巡', None, '导战', @@ -82,10 +88,10 @@ def test_six_slot_loader_preserves_airport_and_internal_empty_slot() -> None: ] -@pytest.mark.parametrize('raw', [['DD'], ['', 'AF'], ['', ['轻巡']], [''] * 8, '驱逐']) +@pytest.mark.parametrize('raw', [['INVALID'], [42], ['', ['轻巡']], [''] * 7, '驱逐']) def test_invalid_enemy_data_is_reported(raw: object) -> None: - with pytest.raises(ValueError, match='决战敌情'): - _enemy_slots(raw, '6-1 A') + with pytest.raises((ValueError, TypeError), match='决战敌情'): + enemy_codes_to_slots(raw) def test_decisive_metadata_preserves_unknown_geometry_and_formation() -> None: @@ -99,7 +105,7 @@ def test_decisive_metadata_preserves_unknown_geometry_and_formation() -> None: assert not metadata.capabilities['distance'] assert not metadata.capabilities['ray'] assert '0' not in metadata.nodes - assert MapData.tracking_map(1, 1).nodes['A'].enemy_formations is None + assert MapData.tracking_map(1, 1).nodes['A'].enemy_formations[0].ships[0] == '轻巡' assert MapData.get_enemy(6, 1, 'unknown') == [] From 52d2bdf2f597e1a9dc63428b29f36fd29c5662f4 Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:18 +0800 Subject: [PATCH 3/8] =?UTF-8?q?feat(repair):=20=E6=8C=89=E8=88=B0=E5=90=8D?= =?UTF-8?q?=E5=92=8C=E6=97=B6=E9=95=BF=E7=99=BB=E8=AE=B0=E7=BB=B4=E4=BF=AE?= =?UTF-8?q?=E7=8A=B6=E6=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 确认入浴后统一登记舰船与槽位;计时到期仍需观察实际伤情。 --- autowsgr/context/bathroom.py | 2 +- autowsgr/context/game_context.py | 10 +-- autowsgr/context/ship.py | 22 ++++++- autowsgr/infra/config.py | 6 +- autowsgr/ops/repair.py | 22 +++++-- autowsgr/ops/repair_policy.py | 77 ++++++++++++++++++++++++ autowsgr/types.py | 5 ++ autowsgr/ui/bath_page/page.py | 75 +++++++++++------------ autowsgr/ui/bath_page/recognition.py | 63 +++++++++---------- autowsgr/ui/battle/blood.py | 2 +- autowsgr/ui/battle/repair.py | 12 ++-- examples/usersettings.full.yaml | 3 +- testing/ops/test_repair_unit.py | 73 ++++++++++++++++++++-- testing/ui/bath_page/test_recognition.py | 60 ++++++++++++++++++ 14 files changed, 330 insertions(+), 102 deletions(-) create mode 100644 autowsgr/ops/repair_policy.py create mode 100644 testing/ui/bath_page/test_recognition.py diff --git a/autowsgr/context/bathroom.py b/autowsgr/context/bathroom.py index c14cde7ef..c4032ac21 100644 --- a/autowsgr/context/bathroom.py +++ b/autowsgr/context/bathroom.py @@ -9,7 +9,7 @@ ----------------------- ``available_time`` 仅跟踪**本脚本派出的修理**: :meth:`BathRoom.occupy` 在 成功派修后记录该槽释放时间。配合 ``BathPage`` 选择修理 overlay 的点击反馈 -(``_try_wait_overlay_close``: overlay 关闭 = 修成功 / 未关 = 浴场满) 实现: +(``wait_repair_accepted``: overlay 关闭 = 修成功 / 未关 = 浴场满) 实现: - 有空闲槽才派修 (:meth:`is_available`); - 跟踪已派修理的进度 (释放时间戳自然到期 = 槽回收); diff --git a/autowsgr/context/game_context.py b/autowsgr/context/game_context.py index f154427d1..4444cf0c8 100644 --- a/autowsgr/context/game_context.py +++ b/autowsgr/context/game_context.py @@ -7,6 +7,7 @@ from dataclasses import dataclass, field from typing import TYPE_CHECKING +from autowsgr.constants import normalize_ship_name from autowsgr.infra.logger import get_logger from autowsgr.types import ShipDamageState from autowsgr.ui.stack import UIStack @@ -136,10 +137,11 @@ def fleet(self, fleet_id: int) -> Fleet: return self.fleets[fleet_id - 1] def get_ship(self, name: str) -> Ship: - """按名称获取舰船, 不存在则自动注册。""" - if name not in self.ship_registry: - self.ship_registry[name] = Ship(name=name) - return self.ship_registry[name] + """首次实见时登记舰名,同船别名共用伤情和维修记录。""" + key = normalize_ship_name(name) or name + if key not in self.ship_registry: + self.ship_registry[key] = Ship(name=key) + return self.ship_registry[key] def is_ship_available(self, name: str) -> bool: """判断舰船是否可用 (非大破 且 非修理中)。""" diff --git a/autowsgr/context/ship.py b/autowsgr/context/ship.py index a6b251af2..189dd3aea 100644 --- a/autowsgr/context/ship.py +++ b/autowsgr/context/ship.py @@ -45,6 +45,9 @@ class Ship: repairing: bool = False """是否由上层标记为修理中 (手动设置/清除, 决战只读)。""" + repair_recheck_at: float = 0.0 + """看见维修标记但不知道结束时间时,下次核实该舰伤情的时刻。""" + # ── 计算属性 ── @property @@ -57,7 +60,11 @@ def health_ratio(self) -> float: @property def is_repairing(self) -> bool: """舰船是否正在修理中。""" - return self.repairing or time.time() < self.repair_end_time + return ( + self.repairing + or self.damage_state == ShipDamageState.REPAIRING + or time.time() < self.repair_end_time + ) @property def available(self) -> bool: @@ -74,8 +81,17 @@ def set_repair(self, duration_seconds: int) -> None: duration_seconds: 修理时长 (秒)。0 表示快修 (立即完成)。 """ - self.repair_end_time = time.time() + duration_seconds - self.damage_state = ShipDamageState.NORMAL + if duration_seconds > 0: + self.record_bath(time.time() + duration_seconds) + else: + self.repair_end_time = self.repair_recheck_at = 0.0 + self.damage_state = ShipDamageState.NORMAL + + def record_bath(self, deadline: float) -> None: + """确认入浴后记录结束时间,到期仍需观察这艘舰才能确认伤情。""" + self.repair_end_time = deadline + self.repair_recheck_at = 0.0 + self.damage_state = ShipDamageState.REPAIRING def needs_repair(self, mode: RepairMode) -> bool: """根据修理策略判断是否需要入浴。""" diff --git a/autowsgr/infra/config.py b/autowsgr/infra/config.py index 3bb54e691..529e5a968 100644 --- a/autowsgr/infra/config.py +++ b/autowsgr/infra/config.py @@ -90,7 +90,7 @@ def package_name(self) -> str: def resolve_ocr_gpu_enabled(configured: bool) -> bool: - """Apply the process OCR GPU override to one configured GPU preference.""" + """按当前进程的环境变量调整 OCR 的 GPU 设置。""" override = os.getenv('AUTOWSGR_OCR_GPU_MODE', '').lower() if override == 'cuda': return True @@ -382,7 +382,7 @@ def _validate_chapter(cls, v: int) -> int: class IntensifyConfig(BaseModel): - """Autonomous intensify material policy persisted in usersettings.yaml.""" + """用户设置中保存的自动强化素材策略。""" model_config = {'frozen': True} @@ -460,6 +460,8 @@ class UserConfig(BaseModel): """兼容旧版布尔字段 (仅当 ``dock_full_mode`` 为 None 时作为回退依据)""" repair_manually: bool = False """是否手动修理""" + quick_repair_threshold_seconds: int | None = Field(default=None, strict=True, ge=0) + """决战维修耗时阈值(秒)。短于阈值入浴,达到阈值先换船,缺员才用桶,未设置时沿用原策略。""" bathroom_count: int = 2 """修理位置总数 (≤12)。预留:智能浴场空位调度用。""" diff --git a/autowsgr/ops/repair.py b/autowsgr/ops/repair.py index 8180ba76d..2714c0768 100644 --- a/autowsgr/ops/repair.py +++ b/autowsgr/ops/repair.py @@ -11,6 +11,7 @@ from __future__ import annotations import time +from functools import partial from typing import TYPE_CHECKING from autowsgr.infra.logger import get_logger @@ -52,6 +53,13 @@ def repair_in_bath(ctx: GameContext) -> None: _log.info('[OPS] 浴室修理操作完成') +def _record_bath(ctx: GameContext, name: str, seconds: int) -> None: + """确认入浴后登记舰船与槽位。到期时还需查看舰船的实际伤情。""" + ctx.get_ship(name).record_bath(time.time() + seconds) + ctx.bathroom.slot_count = ctx.config.bathroom_count + ctx.bathroom.occupy(seconds) + + def repair_ship_by_name(ctx: GameContext, ship_name: str) -> int: """使用浴室修理指定名称的舰船。 @@ -74,8 +82,7 @@ def repair_ship_by_name(ctx: GameContext, ship_name: str) -> int: repair_secs = page.repair_ship(ship_name) if repair_secs >= 0: - ship = ctx.get_ship(ship_name) - ship.set_repair(repair_secs) + _record_bath(ctx, ship_name, repair_secs) _log.info('[OPS] 浴室修理操作完成: {} ({}s)', ship_name, repair_secs) else: _log.warning('[OPS] 浴场已满, 无法修理 {}', ship_name) @@ -122,25 +129,28 @@ def repair_one_available( goto_page(ctx, PageName.BATH) page = BathPage(ctx) repaired = 0 + record = partial(_record_bath, ctx) # 循环填满所有空闲槽: 每修一艘 overlay 即自动关闭, 故每轮需重开 overlay。 # 终止条件: 无空闲槽 (is_available False) / 无可修候选 (secs==-1) / # 浴场满 (secs==-2)。空闲槽数 = slot_count, 故循环上限即槽位数, 不会死循环。 while bath.is_available(): page.go_to_choose_repair() - secs = page.repair_longest(blacklist=blocked) + secs = page.repair_longest(blacklist=blocked, on_accepted=record) - if secs > 0: - bath.occupy(secs) + if secs >= 0: repaired += 1 _log.info('[OPS] 浴室修理派单成功 ({}s, 本轮已派 {} 艘)', secs, repaired) + if secs == 0: + # 实际读到零秒时槽位仍为空,下一轮触发时再选船。 + break continue if secs == -2: # 浴场满: 状态不可靠, 标记未知下次重试 bath.mark_unknown() _log.warning('[OPS] 浴场已满, 稍后重试 (本轮已派 {} 艘)', repaired) break - # secs == -1 (无可修候选) 或 == 0 (修理时间解析失败): 状态不变, 结束派单 + # 没有可修候选,结束本轮派单。 _log.debug('[OPS] 无可修理舰船, 结束派单 (本轮已派 {} 艘)', repaired) break diff --git a/autowsgr/ops/repair_policy.py b/autowsgr/ops/repair_policy.py new file mode 100644 index 000000000..ca4246463 --- /dev/null +++ b/autowsgr/ops/repair_policy.py @@ -0,0 +1,77 @@ +"""按可验证的伤情和时长判断维修方式。""" + +from __future__ import annotations + +import math +import re +from dataclasses import dataclass +from enum import StrEnum + + +BLIND_RECHECK_SECONDS = 180 + + +class RepairAction(StrEnum): + NONE = 'none' + QUICK = 'quick' + BATH = 'bath' + WAIT = 'wait' + RECHECK = 'recheck' + + +@dataclass(frozen=True, slots=True) +class RepairDecision: + action: RepairAction + wait_seconds: float | None = None + + +def parse_repair_duration(value: str) -> int | None: + """读取完整的时分秒,保留实际读出的零秒。""" + match = re.fullmatch(r'(\d+):([0-5]\d):([0-5]\d)', value.strip()) + if match is None: + return None + hours, minutes, seconds = map(int, match.groups()) + return hours * 3600 + minutes * 60 + seconds + + +def _validate_duration(value: float | None, name: str) -> None: + if value is not None and ( + isinstance(value, bool) + or not isinstance(value, (int, float)) + or not math.isfinite(value) + or value < 0 + ): + raise ValueError(f'{name} 必须是非负有限秒数或留空') + + +def decide_repair( + *, + required: bool | None, + repairing: bool | None, + repair_seconds: float | None, + quick_threshold_seconds: float | None, +) -> RepairDecision: + """将长修列为快修候选、短修列为入浴目标。计时到期需重新观察。""" + _validate_duration(repair_seconds, 'repair_seconds') + _validate_duration(quick_threshold_seconds, 'quick_threshold_seconds') + if any(value is not None and type(value) is not bool for value in (required, repairing)): + raise TypeError('需修、在修标志必须为布尔值或留空') + if repairing is True: + if repair_seconds is None: + return RepairDecision(RepairAction.WAIT, BLIND_RECHECK_SECONDS) + if repair_seconds is not None and repair_seconds > 0: + return RepairDecision(RepairAction.WAIT, float(repair_seconds)) + return RepairDecision(RepairAction.RECHECK) + if repairing is False and required is False: + return RepairDecision(RepairAction.NONE) + if ( + repairing is False + and required is True + and repair_seconds is not None + and quick_threshold_seconds is not None + ): + action = ( + RepairAction.QUICK if repair_seconds >= quick_threshold_seconds else RepairAction.BATH + ) + return RepairDecision(action) + return RepairDecision(RepairAction.RECHECK) diff --git a/autowsgr/types.py b/autowsgr/types.py index 467d3c7bf..416ab0aae 100644 --- a/autowsgr/types.py +++ b/autowsgr/types.py @@ -223,6 +223,8 @@ class ShipDamageState(IntEnum): """中破(黄血)。""" SEVERE = 2 """大破(红血或空血)。""" + REPAIRING = 3 + """准备页明确显示正在修理。""" NO_SHIP = -1 """无舰船(蓝色空位)。""" @@ -526,6 +528,9 @@ class DecisivePhase(enum.Enum): PREPARE_COMBAT = enum.auto() """出征准备页 — 编队、修理。""" + WAITING_FOR_REPAIR = enum.auto() + """保留本轮进度,等待派修或到期复查。""" + IN_COMBAT = enum.auto() """战斗引擎运行中。""" diff --git a/autowsgr/ui/bath_page/page.py b/autowsgr/ui/bath_page/page.py index 8d4f1432b..a04e78906 100644 --- a/autowsgr/ui/bath_page/page.py +++ b/autowsgr/ui/bath_page/page.py @@ -50,6 +50,8 @@ if TYPE_CHECKING: + from collections.abc import Callable + import numpy as np from autowsgr.context import GameContext @@ -86,32 +88,13 @@ class RepairShipInfo: @property def repair_seconds(self) -> int: - """将 repair_time (HH:MM:SS) 转换为秒数。解析失败返回 0。""" - return _time_str_to_seconds(self.repair_time) - + """读取完整修理时长。未读出时保留舰名并在点击前报告。""" + from autowsgr.ops.repair_policy import parse_repair_duration -def _time_str_to_seconds(time_str: str) -> int: - """将 HH:MM:SS 格式的时间字符串转换为秒数。 - - Parameters - ---------- - time_str: - 格式为 ``"HH:MM:SS"`` 的时间字符串。 - - Returns - ------- - int - 总秒数, 解析失败返回 0。 - """ - if not time_str: - return 0 - parts = time_str.split(':') - if len(parts) != 3: - return 0 - try: - return int(parts[0]) * 3600 + int(parts[1]) * 60 + int(parts[2]) - except ValueError: - return 0 + seconds = parse_repair_duration(self.repair_time) + if seconds is None: + raise ValueError(f'未能识别 {self.name} 的维修时长,本次未派修') + return seconds # ═══════════════════════════════════════════════════════════════════════════════ @@ -316,6 +299,8 @@ def repair_ship(self, ship_name: str) -> int: ------ NavigationError 选择修理 overlay 未打开,或舰船未找到。 + ValueError + 已找到目标舰船,但未能读出其修理时长。 """ from autowsgr.ui.utils import NavigationError @@ -328,12 +313,12 @@ def repair_ship(self, ship_name: str) -> int: ships = self.recognize_repair_ships() for ship in ships: if ship.name == ship_name: - _log.info('[UI] 选择修理: 找到 {} (耗时 {}),点击', ship_name, ship.repair_time) repair_secs = ship.repair_seconds + _log.info('[UI] 选择修理: 找到 {} (耗时 {}),点击', ship_name, ship.repair_time) self._ctrl.click(*ship.position) # 检测浴场是否已满: overlay 未关闭说明浴场满 - if self._try_wait_overlay_close(): + if self.wait_repair_accepted(): _log.info('[UI] 修理成功: {} ({}s)', ship_name, repair_secs) return repair_secs @@ -355,7 +340,12 @@ def repair_ship(self, ship_name: str) -> int: screen=self._ctrl.screenshot(), ) - def repair_longest(self, blacklist: set[str] | None = None) -> int: + def repair_longest( + self, + blacklist: set[str] | None = None, + *, + on_accepted: Callable[[str, int], None] | None = None, + ) -> int: """在选择修理 overlay 中修理修理时间最长的非黑名单舰船。 逐页扫描 (最多 10 页), 在第一个含非黑名单候选的页内选最长者点击。 @@ -365,11 +355,13 @@ def repair_longest(self, blacklist: set[str] | None = None) -> int: ---------- blacklist: 不修理的舰船名集合 (中文全名)。命中则跳过。 + on_accepted: + 确认入浴后通知调用方实际舰名和时长。 Returns ------- int - 修理秒数 (``>0`` 成功); ``-1`` 无可修候选 (空或全被排除); + 确认入浴的修理秒数;``-1`` 无可修候选或无法读出时长; ``-2`` 浴场已满 (点击后 overlay 未关闭)。 """ blocked = blacklist or set() @@ -378,7 +370,12 @@ def repair_longest(self, blacklist: set[str] | None = None) -> int: ships = self.recognize_repair_ships() candidates = [s for s in ships if s.name and s.name not in blocked] if candidates: - target = max(candidates, key=lambda s: s.repair_seconds) + quoted = [s for s in candidates if s.repair_time] + try: + target = max(quoted or candidates, key=lambda s: s.repair_seconds) + except ValueError as exc: + _log.warning('[UI] {}', exc) + return -1 break if len(ships) < _MAX_VISIBLE_CARDS: # 本页未填满一屏 (含被黑名单排除的), 说明已到修理列表末尾 @@ -399,9 +396,12 @@ def repair_longest(self, blacklist: set[str] | None = None) -> int: target.name, target.repair_time, ) + seconds = target.repair_seconds self._ctrl.click(*target.position) - if self._try_wait_overlay_close(): - return target.repair_seconds + if self.wait_repair_accepted(): + if on_accepted is not None: + on_accepted(target.name, seconds) + return seconds _log.warning('[UI] 浴场已满, 修理 {} 失败', target.name) return -2 @@ -451,15 +451,8 @@ def _wait_overlay_auto_close(self) -> None: target='浴室', ) - def _try_wait_overlay_close(self) -> bool: - """尝试等待 overlay 关闭, 超时返回 False (浴场已满)。 - - Returns - ------- - bool - ``True`` 表示 overlay 已关闭 (修理成功), - ``False`` 表示超时 overlay 仍打开 (浴场已满)。 - """ + def wait_repair_accepted(self) -> bool: + """确认选船弹窗已关闭且已返回浴室。超时表示尚未确认入浴。""" deadline = time.monotonic() + BATH_FULL_TIMEOUT while time.monotonic() < deadline: screen = self._ctrl.screenshot() diff --git a/autowsgr/ui/bath_page/recognition.py b/autowsgr/ui/bath_page/recognition.py index 3c20612c8..a1966636f 100644 --- a/autowsgr/ui/bath_page/recognition.py +++ b/autowsgr/ui/bath_page/recognition.py @@ -14,6 +14,7 @@ from __future__ import annotations import re +import unicodedata from typing import TYPE_CHECKING import cv2 @@ -33,6 +34,9 @@ # ── 卡片检测参数 ────────────────────────────────────────────────────── +_REFERENCE_SIZE = (1280, 720) +"""卡片尺寸和文字区域的标定分辨率。""" + _CARD_MIN_W = 150 """卡片最小宽度 (像素)。""" @@ -83,8 +87,9 @@ _TIME_SCALE = 2 """时间区域 OCR 前的放大倍数,提升数字识别精度。""" -_TIME_PATTERN = re.compile(r'\d{2}:\d{2}:\d{2}') -"""修理时间格式: HH:MM:SS。""" +_TIME_PATTERN = re.compile( + r'(?:耗时\s*:?\s*)?([0-9]{2})\s*[:;,.]?\s*([0-5][0-9])\s*[:;,.]?\s*([0-5][0-9])' +) def is_fully_visible( @@ -130,16 +135,23 @@ def _detect_card_rects(image: np.ndarray) -> list[tuple[int, int, int, int]]: """ gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) _, thresh = cv2.threshold(gray, _BORDER_THRESHOLD, 255, cv2.THRESH_BINARY) - contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) + contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) - cards: list[tuple[int, int, int, int]] = [] - for c in contours: + cards: dict[int, tuple[int, int, int, int]] = {} + for i, c in enumerate(contours): x, y, w, h = cv2.boundingRect(c) if _CARD_MIN_W < w < _CARD_MAX_W and _CARD_MIN_H < h < _CARD_MAX_H: - cards.append((x, y, w, h)) + cards[i] = (x, y, w, h) - cards.sort(key=lambda r: r[0]) - return cards + # 亮色卡框的内外沿都可能符合尺寸,只保留同一卡片的最外层轮廓。 + outer_cards = [] + for i, rect in cards.items(): + parent = hierarchy[0, i, 3] + while parent >= 0 and parent not in cards: + parent = hierarchy[0, parent, 3] + if parent < 0: + outer_cards.append(rect) + return sorted(outer_cards, key=lambda r: r[0]) def _normalize_time(raw: str) -> str: @@ -147,22 +159,8 @@ def _normalize_time(raw: str) -> str: EasyOCR 常将 ``:`` 识别为 ``;`` 、 ``,`` 或 ``.``,需统一替换。 """ - t = raw.replace('耗时', '').replace(' ', '') - t = t.replace(';', ':').replace(',', ':').replace('.', ':') - t = t.strip(':') - # 去除非数字和冒号字符 - t = ''.join(c for c in t if c.isdigit() or c == ':') - # 合并连续冒号 - while '::' in t: - t = t.replace('::', ':') - m = _TIME_PATTERN.search(t) - if m: - return m.group(0) - # 补救: OCR 可能丢失冒号,如 "005609" -> "00:56:09" - digits = ''.join(c for c in t if c.isdigit()) - if len(digits) == 6: - return f'{digits[0:2]}:{digits[2:4]}:{digits[4:6]}' - return t + match = _TIME_PATTERN.fullmatch(unicodedata.normalize('NFKC', raw).strip()) + return ':'.join(match.groups()) if match else '' def _ocr_card( @@ -228,12 +226,9 @@ def _ocr_card( for r in time_results: if r.bbox is None: continue - txt = r.text - if '耗时' in txt or ':' in txt or ';' in txt or '.' in txt: - normalized = _normalize_time(txt) - if _TIME_PATTERN.match(normalized): - time_text = normalized - break + time_text = _normalize_time(r.text) + if time_text: + break if name is None and time_text == '': return None @@ -267,10 +262,10 @@ def recognize_repair_cards( list[RepairShipInfo] 按从左到右顺序排列的舰船信息列表,仅包含完整可见的卡片。 """ - _h, w = screen.shape[:2] - # 检测时使用 BGR (cv2 默认),但输入是 RGB - bgr = cv2.cvtColor(screen, cv2.COLOR_RGB2BGR) - cards = _detect_card_rects(bgr) + if screen.shape[:2] != _REFERENCE_SIZE[::-1]: + screen = cv2.resize(screen, _REFERENCE_SIZE) + w = screen.shape[1] + cards = _detect_card_rects(screen) _log.debug('[修理识别] 检测到 {} 张卡片矩形', len(cards)) diff --git a/autowsgr/ui/battle/blood.py b/autowsgr/ui/battle/blood.py index b0df019ff..a7ef47c85 100644 --- a/autowsgr/ui/battle/blood.py +++ b/autowsgr/ui/battle/blood.py @@ -60,7 +60,7 @@ def classify_blood(pixel: Color) -> ShipDamageState: """根据像素颜色判断血量状态。 - 计算像素与五种参考颜色的欧氏距离,返回距离最近的对应状态。 + 计算像素与六种参考颜色的欧氏距离,返回距离最近的对应状态。 Parameters ---------- diff --git a/autowsgr/ui/battle/repair.py b/autowsgr/ui/battle/repair.py index 5fcbab2f6..c3a747cc3 100644 --- a/autowsgr/ui/battle/repair.py +++ b/autowsgr/ui/battle/repair.py @@ -5,8 +5,6 @@ from __future__ import annotations -import time - from autowsgr.infra import ActionFailedError from autowsgr.infra.logger import get_logger from autowsgr.types import ShipDamageState @@ -32,14 +30,20 @@ def repair_slots(self, positions: list[int]) -> None: if not positions: return + if self._ctx.stop_event.is_set(): + return self.select_panel(Panel.QUICK_REPAIR) - time.sleep(0.8) + if self._ctx.stop_event.wait(0.8): + return for pos in positions: if pos not in BLOOD_BAR_PROBE: _log.warning('[UI] 无效修理位置: {}', pos) continue + if self._ctx.stop_event.is_set(): + return self._ctrl.click(*BLOOD_BAR_PROBE[pos]) - time.sleep(1.5) + if self._ctx.stop_event.wait(1.5): + return _log.info('[UI] 出征准备 → 修理位置 {}', pos) def check_repair( diff --git a/examples/usersettings.full.yaml b/examples/usersettings.full.yaml index c51f66940..403e57c86 100644 --- a/examples/usersettings.full.yaml +++ b/examples/usersettings.full.yaml @@ -74,6 +74,7 @@ operation_delay_min: 0.0 # 单次操作最小延迟 operation_delay_max: 0.0 # 单次操作最大延迟 dock_full_destroy: true # 船坞满时自动清空 repair_manually: false # 是否手动修理 +quick_repair_threshold_seconds: null # 决战:null 沿用原策略;短于阈值立即入浴,达到阈值时优先换船,缺员才用桶 bathroom_count: 2 # 浴室修理槽位数 (auto_bath_repair 空位调度用) # ── 解装设置 ── @@ -143,7 +144,7 @@ decisive_battle: - U-96 - U-1206 repair_level: 1 # 维修策略 (1=中破修, 2=大破修) - use_quick_repair: true # 是否启用快修(桶修),关闭后不修理受损舰船。 + use_quick_repair: true # 允许使用快修桶;关闭后仍可按时长阈值安排入浴。 full_destroy: false # 船舱满了是否解装舰船 useful_skill: false # 充分利用技能 useful_skill_strict: false # 严格利用技能 (useful_skill 为 true 时才生效) diff --git a/testing/ops/test_repair_unit.py b/testing/ops/test_repair_unit.py index 38b8c0e16..5010fe41e 100644 --- a/testing/ops/test_repair_unit.py +++ b/testing/ops/test_repair_unit.py @@ -9,12 +9,18 @@ import types from typing import TYPE_CHECKING +from unittest.mock import Mock + +import pytest from autowsgr.context.bathroom import BathRoom +from autowsgr.context.game_context import GameContext +from autowsgr.types import ShipDamageState +from autowsgr.ui.bath_page import BathPage, RepairShipInfo if TYPE_CHECKING: - import pytest + from collections.abc import Callable # ── 替身 ── @@ -31,9 +37,16 @@ def __init__(self, results: list[int]) -> None: def go_to_choose_repair(self) -> None: self.go_to_choose_repair_calls += 1 - def repair_longest(self, blacklist: set[str] | None = None) -> int: # noqa: ARG002 # 签名匹配真实接口 (调用方按关键字传 blacklist=) + def repair_longest( + self, *, blacklist: set[str], on_accepted: Callable[[str, int], None] + ) -> int: self.repair_longest_calls += 1 - return self._results.pop(0) if self._results else -1 + seconds = self._results.pop(0) if self._results else -1 + if seconds >= 0: + name = f'舰船{self.repair_longest_calls}' + assert name not in blacklist + on_accepted(name, seconds) + return seconds class _FakeCtx: @@ -42,15 +55,20 @@ class _FakeCtx: def __init__(self, slot_count: int) -> None: self.bathroom = BathRoom(slot_count=slot_count) self.config = types.SimpleNamespace(bathroom_count=slot_count) + self.ship_registry = {} + self.ctrl = Mock() + + get_ship = GameContext.get_ship -def _patch_repair(monkeypatch: pytest.MonkeyPatch, fake_page: _FakeBathPage) -> None: +def _patch_repair(monkeypatch: pytest.MonkeyPatch, fake_page: _FakeBathPage | BathPage) -> None: """把 repair 模块的设备依赖 (goto_page / BathPage / sleep) 替换为 no-op。""" import autowsgr.ops.repair as mod monkeypatch.setattr(mod, 'goto_page', lambda *_a, **_kw: None) monkeypatch.setattr(mod, 'BathPage', lambda _ctx: fake_page) - monkeypatch.setattr(mod, 'time', types.SimpleNamespace(sleep=lambda *_a, **_kw: None)) + monkeypatch.setattr(mod.time, 'sleep', lambda *_a, **_kw: None) + monkeypatch.setattr(mod.time, 'time', lambda: 1000.0) # ── 循环填满 ── @@ -69,6 +87,9 @@ def test_fills_all_free_slots_then_stops(monkeypatch: pytest.MonkeyPatch): assert fake.repair_longest_calls == 2 # 恰好修 2 艘, 不是 1 也不是死循环 assert fake.go_to_choose_repair_calls == 2 # 每艘都重开 overlay assert ctx.bathroom.is_available() is False # 两槽全满 + assert ctx.bathroom.available_time == [1100.0, 1200.0] + assert ctx.get_ship('舰船1').repair_end_time == 1100.0 + assert ctx.get_ship('舰船2').damage_state is ShipDamageState.REPAIRING def test_partial_fill_then_no_candidates(monkeypatch: pytest.MonkeyPatch): @@ -125,3 +146,45 @@ def test_skip_when_no_free_slot(monkeypatch: pytest.MonkeyPatch): assert mod.repair_one_available(ctx) is False assert fake.go_to_choose_repair_calls == 0 # 没开 overlay + + +@pytest.mark.parametrize('mode', ['具名', '空闲']) +@pytest.mark.parametrize( + ('raw', 'accepted', 'registered'), + [('00:12:18', True, 738), ('00:00:00', True, 0), ('', True, None), ('00:12:18', False, None)], +) +def test_registry_only_after_confirmed_quote( + monkeypatch: pytest.MonkeyPatch, mode: str, raw: str, accepted: bool, registered: int | None +): + """使用真实选船和入浴逻辑,核对点击、舰船记录和槽位时间。""" + import autowsgr.ops.repair as mod + + ctx = _FakeCtx(slot_count=1) + page = BathPage(ctx) + monkeypatch.setattr(page, 'go_to_choose_repair', lambda: None) + monkeypatch.setattr(BathPage, 'has_choose_repair_overlay', staticmethod(lambda _screen: True)) + card = RepairShipInfo('U-351', (0.3, 0.5), raw) + monkeypatch.setattr(page, 'recognize_repair_ships', lambda: [card]) + monkeypatch.setattr(page, 'wait_repair_accepted', lambda: accepted) + _patch_repair(monkeypatch, page) + + if mode == '空闲': + assert mod.repair_one_available(ctx) is (registered is not None) + elif not raw: + with pytest.raises(ValueError, match=r'U-351.*时长'): + mod.repair_ship_by_name(ctx, 'U-351') + else: + seconds = mod.repair_ship_by_name(ctx, 'U-351') + assert seconds == (registered if registered is not None else -1) + + assert ctx.ctrl.click.call_count == bool(raw) + if registered is None: + assert not ctx.ship_registry + assert ctx.bathroom.available_time is None + else: + ship = ctx.get_ship('U-351') + assert ship.repair_end_time == 1000 + registered + assert ship.damage_state is ShipDamageState.REPAIRING + monkeypatch.setattr(mod.time, 'time', lambda: 2000.0) + assert not ship.available + assert ctx.bathroom.available_time == [1000 + registered if registered else 0.0] diff --git a/testing/ui/bath_page/test_recognition.py b/testing/ui/bath_page/test_recognition.py new file mode 100644 index 000000000..7d4b3756d --- /dev/null +++ b/testing/ui/bath_page/test_recognition.py @@ -0,0 +1,60 @@ +"""浴室卡片边框、点击坐标及修理时间识别的离线回归。""" + +from unittest.mock import MagicMock + +import cv2 +import numpy as np +import pytest + +from autowsgr.ui.bath_page.recognition import _ocr_card, recognize_repair_cards +from autowsgr.vision.ocr import OCRResult + + +@pytest.mark.parametrize('size', [(1280, 720), (960, 540), (1920, 1080)]) +def test_same_name_on_separate_bordered_cards(size: tuple[int, int]) -> None: + screen = np.zeros((720, 1280, 3), np.uint8) + # 整块面板也有边框;卡片应保留,两张卡片各自的内外沿只计一次。 + for start, end in [ + ((40, 30), (700, 650)), + ((98, 64), (271, 548)), + ((308, 64), (481, 548)), + ]: + cv2.rectangle(screen, start, end, (255, 255, 255), 3) + name = OCRResult('胡德', 1, (10, 125, 60, 140)) + duration = OCRResult('00:17:59', 1, (0, 0, 80, 12)) + ocr = MagicMock() + ocr.recognize.side_effect = [[name], [duration], [name], [duration]] + + cards = recognize_repair_cards(cv2.resize(screen, size), ocr) + + assert ocr.recognize.call_count == 4 + assert [(c.name, c.repair_time) for c in cards] == [('胡德', '00:17:59')] * 2 + for card, center in zip(cards, [185, 395], strict=True): + assert card.position == pytest.approx((center / 1280, 0.5), abs=1 / 1280) + + +@pytest.mark.parametrize( + ('raw', 'expected'), + [ + ('001759', '00:17:59'), + ('00,17,59', '00:17:59'), + ('耗时:00;17.59', '00:17:59'), + ('00:00:00', '00:00:00'), + ('00:60:00', ''), + ('001760', ''), + ('00,1,759', ''), + ('0017590', ''), + ('编号001759', ''), + ('00:17:59级', ''), + ('', ''), + ], +) +def test_card_accepts_only_complete_time(raw: str, expected: str) -> None: + ocr = MagicMock() + ocr.recognize.side_effect = [ + [OCRResult('胡德', 1, (10, 125, 60, 140))], + [OCRResult(raw, 1, (0, 0, 80, 12))], + ] + card = _ocr_card(np.zeros((480, 174, 3), np.uint8), ocr, 100, 174, 1280) + assert card is not None + assert (card.name, card.repair_time) == ('胡德', expected) From 736ddcd18ca78db776aa63baa2cf8fe24d8b7b02 Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:24 +0800 Subject: [PATCH 4/8] =?UTF-8?q?fix(decisive):=20=E6=A0=B8=E5=AE=9E?= =?UTF-8?q?=E9=A1=B5=E9=9D=A2=E5=90=8E=E7=BC=96=E9=98=9F=E9=80=89=E8=B7=AF?= =?UTF-8?q?=E4=B8=8E=E7=BB=93=E7=AE=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- autowsgr/ui/decisive/battle_page.py | 134 ++- autowsgr/ui/decisive/fleet_ocr.py | 56 +- autowsgr/ui/decisive/map_controller.py | 816 +++++++++++------- autowsgr/ui/decisive/overlay.py | 62 +- autowsgr/ui/decisive/preparation.py | 144 +++- testing/tools/test_decisive_collection.py | 11 +- .../decisive_battle_page/test_navigation.py | 292 +++++++ .../decisive_battle_page/test_stage_clear.py | 109 ++- 8 files changed, 1217 insertions(+), 407 deletions(-) create mode 100644 testing/ui/decisive_battle_page/test_navigation.py diff --git a/autowsgr/ui/decisive/battle_page.py b/autowsgr/ui/decisive/battle_page.py index c2eff9cfb..65877cdde 100644 --- a/autowsgr/ui/decisive/battle_page.py +++ b/autowsgr/ui/decisive/battle_page.py @@ -21,7 +21,9 @@ from autowsgr.image_resources import Templates from autowsgr.infra.logger import get_logger from autowsgr.types import DecisiveEntryStatus, PageName -from autowsgr.ui.utils import click_and_wait_for_page, confirm_operation +from autowsgr.ui.decisive.overlay import ENTRY_STATUS_ROI +from autowsgr.ui.utils import click_and_wait_for_page +from autowsgr.ui.utils.navigation import NavConfig, check_stop, wait_for_page from autowsgr.vision import ( Color, ImageChecker, @@ -38,10 +40,16 @@ import numpy as np from autowsgr.context import GameContext + from autowsgr.vision.image_template import ImageMatchDetail _log = get_logger('ui.decisive') + +class ResetConfirmationTimeoutError(TimeoutError): + """已提交重置,但还未看到第一小关。重试时只能核实存档。""" + + # ═══════════════════════════════════════════════════════════════════════════════ # 页面识别签名 # ═══════════════════════════════════════════════════════════════════════════════ @@ -175,7 +183,10 @@ def is_current_page(screen: np.ndarray) -> PageMatch: 深色活动主题页误命中) 保留备查, 不再参与判定。 """ result = ImageChecker.find_any( - screen, Templates.Decisive.entry_status_templates(), confidence=0.8 + screen, + Templates.Decisive.entry_status_templates(), + roi=ENTRY_STATUS_ROI, + confidence=0.8, ) name = PageName.DECISIVE_BATTLE.value if result is None: @@ -232,6 +243,7 @@ def go_back(self) -> None: def click_enter_map(self) -> None: """从决战总览页进入当前章节的决战地图页。""" _log.info('[决战] 决战总览 → 进入地图') + check_stop(self._ctx.stop_event) self._ctrl.click(*CLICK_ENTER_MAP) # ── 章节 OCR ────────────────────────────────────────────────────────── @@ -304,6 +316,7 @@ def navigate_to_chapter(self, target: int) -> None: raise RuntimeError('navigate_to_chapter 需要 OCR 引擎') for attempt in range(_CHAPTER_NAV_MAX_ATTEMPTS): + check_stop(self._ctx.stop_event) current = self._read_chapter() if current is None: _log.warning( @@ -317,6 +330,7 @@ def navigate_to_chapter(self, target: int) -> None: _log.info('[决战] 决战章节导航: 已到达 Ex-{}', target) return + check_stop(self._ctx.stop_event) if current > target: self.go_prev_chapter() else: @@ -400,32 +414,48 @@ def detect_entry_status( TimeoutError 超时仍未匹配到任何入口状态。 """ - from autowsgr.image_resources import Templates + status, _ = self.wait_for_entry_status( + timeout=timeout, interval=interval, confidence=confidence + ) + return status + def wait_for_entry_status( + self, *, timeout: float = 10.0, interval: float = 0.3, confidence: float = 0.8 + ) -> tuple[DecisiveEntryStatus, np.ndarray]: + """同时返回入口状态和对应画面,供恢复流程核实同一存档。""" templates = Templates.Decisive.entry_status_templates() - statuses = list(DecisiveEntryStatus) - - deadline = time.monotonic() + timeout - while True: - screen = self._ctrl.screenshot() + statuses = { + template.name: status + for template, status in zip(templates, DecisiveEntryStatus, strict=True) + } + status = None + + def has_status(image: np.ndarray) -> bool: + nonlocal status detail = ImageChecker.find_any( - screen, - templates, - confidence=confidence, + image, templates, roi=ENTRY_STATUS_ROI, confidence=confidence ) - if detail is not None: - idx = next(i for i, t in enumerate(templates) if t.name == detail.template_name) - status = statuses[idx] - _log.info('[决战] 决战入口状态: {}', status.value) - return status + if detail is None: + return False + status = statuses[detail.template_name] + return True - if time.monotonic() >= deadline: - raise TimeoutError(f'检测决战入口状态超时 ({timeout}s): 未匹配到任何状态模板') - time.sleep(interval) + screen = wait_for_page( + self._ctrl, + has_status, + target='决战总览', + timeout=timeout, + interval=interval, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) + if status is None: + raise TimeoutError('未识别到决战入口状态') + return status, screen # ── 章节重置 ───────────────────────────────────────────────────────── - def reset_chapter(self) -> bool: + def reset_chapter(self, chapter: int | None = None) -> bool: """使用磁盘重置当前章节。 在决战总览页点击"重置关卡"按钮并确认操作。 @@ -436,18 +466,58 @@ def reset_chapter(self) -> bool: 调用前需确保已在决战总览页且已导航到目标章节。 船坞已满处理由调用方负责。 """ - _log.info('[决战] 决战页面 → 重置关卡') - self._ctrl.click(*CLICK_RESET_CHAPTER) - time.sleep(1.0) - screen = self._ctrl.screenshot() - if ImageChecker.template_exists( - screen, - Templates.Build.SHIP_FULL_DEPOT, - confidence=0.8, - ): + + _log.info('[决战] 重置当前关卡') + if chapter is None: + chapter = self._read_chapter() + if chapter is None: + raise RuntimeError('重置前未能确认当前决战章节') + + def full(image: np.ndarray) -> bool: + return ImageChecker.template_exists( + image, Templates.Build.SHIP_FULL_DEPOT, confidence=0.8 + ) + + def confirmation(image: np.ndarray) -> ImageMatchDetail | None: + return ImageChecker.find_any(image, Templates.Confirm.all(), confidence=0.85) + + screen = click_and_wait_for_page( + self._ctrl, + CLICK_RESET_CHAPTER, + lambda image: full(image) or confirmation(image) is not None, + target='重置关卡确认', + config=NavConfig(timeout=5.0, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) + if full(screen): _log.warning('[决战] 重置关卡时检测到船坞已满') return False - confirm_operation(self._ctrl, must_confirm=True, timeout=5.0) - time.sleep(1.0) # 防止后续 stage 识别出问题 - _log.info('[决战] 决战关卡重置完成') + button = confirmation(screen) + if button is None: + raise RuntimeError('未找到重置关卡的确认按钮') + + def first_stage_visible(image: np.ndarray) -> bool: + # 进图按钮可能先于小关标记出现。只等同一章第一小关亮起,不再点击。 + entry = ImageChecker.find_any( + image, + Templates.Decisive.entry_status_templates()[:3], + roi=ENTRY_STATUS_ROI, + confidence=0.8, + ) + if entry is None: + return False + if entry.template_name == Templates.Decisive.ENTRY_CANT_FIGHT.name: + return True # 留给调用方报告无法出击。 + return self.detect_stage(image, chapter) == 1 and self._read_chapter(image) == chapter + + click_and_wait_for_page( + self._ctrl, + button.center, + first_stage_visible, + target=f'重置后第 {chapter} 章第一小关入口', + config=NavConfig(timeout=5.0, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=ResetConfirmationTimeoutError, + ) return True diff --git a/autowsgr/ui/decisive/fleet_ocr.py b/autowsgr/ui/decisive/fleet_ocr.py index b3d97543f..4f685dcaa 100644 --- a/autowsgr/ui/decisive/fleet_ocr.py +++ b/autowsgr/ui/decisive/fleet_ocr.py @@ -11,7 +11,6 @@ from __future__ import annotations -import time from typing import TYPE_CHECKING import cv2 @@ -26,13 +25,14 @@ SHIP_NAME_X_RANGES, SHIP_NAME_Y_RANGE, ) +from autowsgr.ui.utils.navigation import check_stop from autowsgr.vision import ROI, OCREngine if TYPE_CHECKING: import numpy as np - from autowsgr.emulator import AndroidController + from autowsgr.context import GameContext _log = get_logger('ui.decisive') @@ -124,28 +124,24 @@ def recognize_fleet_options( ) cost_img = cost_roi.crop(screen) cost_results = ocr.recognize(cost_img, allowlist='0123456789xX') - # cost_results 按bbox[0]从小到大排序 保证顺序正确 - cost_results.sort(key=lambda x: x.bbox[0]) - - costs: list[int] = [] - for r in cost_results: - cost = _parse_offer_cost_text(r.text) - if cost is None: - _log.debug("[舰队OCR] 费用解析跳过: '{}'", r.text) + # OCR 漏掉一张卡的费用时,其余费用仍按画面位置归属。 + costs: dict[int, list[int]] = {} + width = screen.shape[1] + for result in cost_results: + cost = _parse_offer_cost_text(result.text) + if result.bbox is None or cost is None or cost < 0: continue - costs.append(cost) - _log.debug('[舰队OCR] 识别到 {} 项费用: {}', len(costs), costs) - if any(c < 4 for c in costs[0:4]): - _log.warning('[舰队OCR] 识别到小于4的费用, 建议检查配队是否有误') + center = (int(cost_roi.x1 * width) + (result.bbox[0] + result.bbox[2]) / 2) / width + for slot, (left, right) in enumerate(SHIP_NAME_X_RANGES): + if left <= center <= right: + costs.setdefault(slot, []).append(cost) + break - # 3. 恢复原版行为:仅对可购买项识别舰名 selections: dict[str, FleetSelection] = {} - for i, cost in enumerate(costs): - if cost > score: + for i, values in sorted(costs.items()): + if len(values) != 1 or values[0] > score: continue - if i >= len(SHIP_NAME_X_RANGES): - break - + cost = values[0] x_range = SHIP_NAME_X_RANGES[i] y_range = SHIP_NAME_Y_RANGE name_roi = ROI(x1=x_range[0], y1=y_range[0], x2=x_range[1], y2=y_range[1]) @@ -153,13 +149,14 @@ def recognize_fleet_options( name = ocr.recognize_ship_name(name_img) if name is None: - raw = ocr.recognize_single(name_img) - name = raw.text.strip() or f'未识别_{i}' - _log.debug("[舰队OCR] 舰船名模糊匹配失败, 原文: '{}'", name) + _log.debug('[舰队OCR] 卡位 {} 未识别,不作为可购买项', i) + continue click_x = FLEET_CARD_X_POSITIONS[i] if i < len(FLEET_CARD_X_POSITIONS) else 0.5 click_y = FLEET_CARD_CLICK_Y + if name in selections and selections[name].cost <= cost: + continue selections[name] = FleetSelection( name=name, cost=cost, @@ -183,24 +180,27 @@ def detect_last_offer_name( def use_skill( - ctrl: AndroidController, + ctx: GameContext, ocr: OCREngine, ) -> list[str]: """在地图页使用一次副官技能并返回识别到的舰船。""" skill_pos = (0.2143, 0.894) ship_area = ROI(x1=0.26, y1=0.685, x2=0.74, y2=0.715) - ctrl.click(*skill_pos) - time.sleep(1.0) + check_stop(ctx.stop_event) + ctx.ctrl.click(*skill_pos) + ctx.stop_event.wait(1.0) + check_stop(ctx.stop_event) - screen = ctrl.screenshot() + screen = ctx.ctrl.screenshot() crop = ship_area.crop(screen) result = ocr.recognize_ship_names(crop) acquired: list[str] = [] if result is not None: acquired.extend(result) - ctrl.click(*skill_pos) # 快进一下 + check_stop(ctx.stop_event) + ctx.ctrl.click(*skill_pos) # 快进一下 return acquired diff --git a/autowsgr/ui/decisive/map_controller.py b/autowsgr/ui/decisive/map_controller.py index 2fc3bb207..c5a191ff1 100644 --- a/autowsgr/ui/decisive/map_controller.py +++ b/autowsgr/ui/decisive/map_controller.py @@ -21,11 +21,14 @@ import numpy as np import autowsgr.ui.decisive.fleet_ocr as _fleet_ocr +from autowsgr.infra import ActionFailedError from autowsgr.infra.logger import get_logger from autowsgr.types import DecisivePhase, FleetSelection, ShipDamageState +from autowsgr.ui.battle.constants import CLICK_BACK from autowsgr.ui.battle.preparation import BattlePreparationPage, RepairStrategy from autowsgr.ui.decisive.overlay import ( - ADVANCE_CARD_POSITIONS, + ADVANCE_CHOICE_ROI, + ADVANCE_CHOICE_THREE_ROI, CLICK_ADVANCE_CONFIRM, CLICK_FLEET_CLOSE, CLICK_FLEET_REFRESH, @@ -34,15 +37,22 @@ CLICK_RETREAT_BUTTON, CLICK_RETREAT_CONFIRM, CLICK_SORTIE, + ENTRY_STATUS_ROI, + SIG_MAP_PAGE, + USE_LAST_FLEET_ROI, DecisiveOverlay, + advance_choice_layout, detect_decisive_overlay, - get_overlay_template, is_decisive_map_page, is_fleet_acquisition, ) -from autowsgr.ui.decisive.preparation import DecisiveBattlePreparationPage -from autowsgr.ui.page import click_and_wait_for_page -from autowsgr.ui.utils import recognize_ships_in_list as _recognize_ships +from autowsgr.ui.decisive.preparation import DecisiveBattlePreparationPage, read_complete_fleet +from autowsgr.ui.utils.navigation import ( + NavConfig, + check_stop, + click_and_wait_for_page, + wait_for_page, +) from autowsgr.vision import ( ROI, ImageChecker, @@ -55,6 +65,7 @@ if TYPE_CHECKING: + from collections.abc import Callable from typing import NoReturn from autowsgr.context import GameContext @@ -128,11 +139,28 @@ def __init__( self, ctx: GameContext, config: DecisiveConfig, + *, + map_checker: Literal['template', 'pixel'] = 'template', + wait_timeout: float = 5.0, ) -> None: self._ctx = ctx self._ctrl = ctx.ctrl self._config = config self._ocr = ctx.ocr + if map_checker not in {'template', 'pixel'} or wait_timeout <= 0: + raise ValueError('地图检查器必须为 template 或 pixel,等待时限必须为正数') + self._map_checker = map_checker + self._wait_timeout = wait_timeout + self._branch_count: int | None = None + self._clear_drops: list[str] | None = None + self._clear_last_frame: CapturedFrame | None = None + self._clear_at_entry = False + + def configure_route(self, branch_count: int | None) -> None: + """由当前路线提供分支数量;不把它当作弹窗已出现的证据。""" + if branch_count is not None and branch_count not in {0, 1, 2, 3}: + raise ValueError('决战分支数必须为 0 到 3 或 None') + self._branch_count = branch_count # ══════════════════════════════════════════════════════════════════════ # 页面状态检测 @@ -142,47 +170,68 @@ def screenshot(self) -> np.ndarray: """获取当前截图。""" return self._ctrl.screenshot() - def detect_overlay(self, screen: np.ndarray | None = None) -> DecisiveOverlay | None: + def detect_overlay( + self, + screen: np.ndarray | None = None, + *, + advance_choice_roi: ROI | None = None, + ) -> DecisiveOverlay | None: """检测当前地图页上的 overlay 类型。""" if screen is None: - screen = self._ctrl.screenshot() - return detect_decisive_overlay(screen) + check_stop(self._ctx.stop_event) + screen = self._ctrl.capture_frame().image + return detect_decisive_overlay( + screen, + branch_count=self._branch_count, + advance_choice_roi=advance_choice_roi, + ) def is_map_page(self, screen: np.ndarray | None = None) -> bool: """判断截图是否为决战地图页 (无 overlay 遮挡)。""" if screen is None: - screen = self._ctrl.screenshot() + check_stop(self._ctx.stop_event) + screen = self._ctrl.capture_frame().image + return bool( + self._has_map_controls(screen) + and not self._has_stage_clear_choices(screen) + and not self._has_reward_drop(screen) + and self.detect_overlay(screen) is None + and self._find_use_last(screen) is None + ) + + def _has_map_controls(self, screen: np.ndarray) -> bool: + """仅识别地图按钮。调用方负责排除遮挡。""" + if getattr(self, '_map_checker', 'template') == 'pixel': + return PixelChecker.check_signature(screen, SIG_MAP_PAGE).matched return is_decisive_map_page(screen) + @staticmethod + def _find_use_last(screen: np.ndarray) -> ImageMatchDetail | None: + from autowsgr.image_resources import Templates + + return ImageChecker.find_template( + screen, + Templates.Decisive.USE_LAST_FLEET, + roi=USE_LAST_FLEET_ROI, + confidence=0.8, + ) + def is_skill_used(self) -> bool: screen = self._ctrl.screenshot() return PixelChecker.check_signature(screen, SKILL_USED).matched - def detect_decisive_phase( # noqa: PLR0911 + def _phase_on_screen( # noqa: PLR0911 self, - screen: np.ndarray | None = None, + screen: np.ndarray, + *, + allow_fleet_overlay: bool = True, + advance_choice_roi: ROI | None = None, ) -> DecisivePhase | None: - """单次截图检测当前决战页面状态。 - - 按以下优先级检测:: - - 1. dock_full — 弹窗存活时间极短 (~2s) - 2. use_last_fleet — 进入已有进度章节时弹出 - 3. overlay — 战备舰队 / 前进点(必须先于地图页判断) - 4. 地图页 — 无 overlay 的正常决战地图页 - - Returns - ------- - DecisivePhase | None - 检测到的阶段;过场动画中等未知状态返回 ``None``。 - """ + """纯分类:所有判断沿用调用者的同一帧,不等待或重新截图。""" from autowsgr.image_resources import Templates - if screen is None: - screen = self._ctrl.screenshot() - # 通关卡过场尚无按钮时也不能透过遮罩认成普通地图并点击编队。 - if self._has_stage_clear_choices(screen): + if self._has_stage_clear_choices(screen) or self._has_reward_drop(screen): return None if ImageChecker.template_exists( @@ -193,41 +242,81 @@ def detect_decisive_phase( # noqa: PLR0911 _log.warning('[地图控制器] 检测到船坞已满弹窗') return DecisivePhase.DOCK_FULL - if ImageChecker.template_exists( - screen, - Templates.Decisive.USE_LAST_FLEET, - confidence=0.8, - ): + if self._find_use_last(screen) is not None: _log.info('[地图控制器] 检测到「使用上次舰队」按钮') return DecisivePhase.USE_LAST_FLEET - overlay = detect_decisive_overlay(screen) + overlay = self.detect_overlay(screen, advance_choice_roi=advance_choice_roi) if overlay is not None: if overlay == DecisiveOverlay.ADVANCE_CHOICE: return DecisivePhase.ADVANCE_CHOICE if overlay == DecisiveOverlay.FLEET_ACQUISITION: - return DecisivePhase.CHOOSE_FLEET - - if is_decisive_map_page(screen): - # 进图后的首个稳定帧有时会短暂满足“地图页”特征,但战备舰队 - # overlay 会在随后 1-2 帧内出现。这里补一次短延迟复检,只把 - # 连续两次都稳定为地图页的结果视为 PREPARE_COMBAT。 - time.sleep(0.2) - confirm_screen = self._ctrl.screenshot() - - overlay = detect_decisive_overlay(confirm_screen) - if overlay is not None: - if overlay == DecisiveOverlay.ADVANCE_CHOICE: - _log.debug('[地图控制器] 地图页复检修正为 overlay: advance_choice') - return DecisivePhase.ADVANCE_CHOICE - if overlay == DecisiveOverlay.FLEET_ACQUISITION: - _log.debug('[地图控制器] 地图页复检修正为 overlay: fleet_acquisition') - return DecisivePhase.CHOOSE_FLEET - - if is_decisive_map_page(confirm_screen): - return DecisivePhase.PREPARE_COMBAT + return DecisivePhase.CHOOSE_FLEET if allow_fleet_overlay else None + return None - return None + return DecisivePhase.PREPARE_COMBAT if self._has_map_controls(screen) else None + + def detect_decisive_phase( + self, + screen: np.ndarray | None = None, + *, + allow_fleet_overlay: bool = True, + advance_choice_roi: ROI | None = None, + ) -> DecisivePhase | None: + """有截图时直接判断;未提供截图时等待可识别的入口页面。""" + check_stop(self._ctx.stop_event) + if screen is not None: + return self._phase_on_screen( + screen, + allow_fleet_overlay=allow_fleet_overlay, + advance_choice_roi=advance_choice_roi, + ) + try: + return self.wait_for_entry_phase( + wait_for_fleet=allow_fleet_overlay, + advance_choice_roi=advance_choice_roi, + timeout=self._wait_timeout, + ) + except TimeoutError: + return None + + def wait_for_entry_phase( + self, + *, + wait_for_use_last: bool = True, + wait_for_advance: bool = True, + wait_for_fleet: bool = True, + advance_choice_roi: ROI | None = None, + timeout: float = 5.0, + interval: float = 0.2, + ) -> DecisivePhase: + """已消费的浮窗只阻挡地图操作,不能再次作为允许的入口阶段。""" + allowed = {DecisivePhase.DOCK_FULL, DecisivePhase.PREPARE_COMBAT} + if wait_for_use_last: + allowed.add(DecisivePhase.USE_LAST_FLEET) + if wait_for_advance: + allowed.add(DecisivePhase.ADVANCE_CHOICE) + if wait_for_fleet: + allowed.add(DecisivePhase.CHOOSE_FLEET) + phase = None + + def ready(image: np.ndarray) -> bool: + nonlocal phase + phase = self._phase_on_screen(image, advance_choice_roi=advance_choice_roi) + return phase in allowed + + wait_for_page( + self._ctrl, + ready, + target='决战入口', + timeout=timeout, + interval=interval, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) + if phase is None: + raise TimeoutError('未识别到决战入口') + return phase # ── 舰船图标颜色检测参数 (HSV, BGR 输入) ────────────────────── # 决战地图上的舰船指示器呈橙黄色高亮,是该色段面积最大的连通区域 @@ -335,39 +424,33 @@ def recognize_node( return node return None + def map_icon_is_stable(self, earlier: CapturedFrame, later: CapturedFrame) -> bool: + """两个已核实地图帧中,舰标位移不超过两像素或均不可见。""" + first, second = ( + self._locate_ship_icon(cv2.cvtColor(frame.image, cv2.COLOR_RGB2BGR)) + for frame in (earlier, later) + ) + if first is None or second is None: + return first is second + return abs(second - first) * later.image.shape[1] <= 2 + def wait_for_stable_map_frame(self, timeout: float = 5.0) -> CapturedFrame: """复用地图等待:两个不同帧确认地图,有舰标时另外验证位移稳定。""" deadline = time.monotonic() + timeout previous = None - previous_center = None while time.monotonic() < deadline: - if self._ctx.stop_event.is_set(): - raise InterruptedError('等待决战地图时收到停止请求') + check_stop(self._ctx.stop_event) frame = self._ctrl.capture_frame() - if ( - is_decisive_map_page(frame.image) - and detect_decisive_overlay(frame.image) is None - and not self._has_stage_clear_choices(frame.image) - ): - center = self._locate_ship_icon(cv2.cvtColor(frame.image, cv2.COLOR_RGB2BGR)) - distinct = previous is not None and ( - frame.sequence != previous.sequence - if frame.sequence is not None and previous.sequence is not None - else frame.captured_at > previous.captured_at - ) - if distinct and ( - (center is None and previous_center is None) - or ( - center is not None - and previous_center is not None - and abs(center - previous_center) * frame.image.shape[1] <= 2 - ) - ): + if not frame.is_newer_than(previous, allow_static=True): + time.sleep(0.05) + continue + if self.is_map_page(frame.image): + if previous is not None and self.map_icon_is_stable(previous, frame): + check_stop(self._ctx.stop_event) return frame - if previous is None or distinct: - previous, previous_center = frame, center + previous = frame.snapshot() else: - previous, previous_center = None, None + previous = None time.sleep(0.05) raise TimeoutError('决战地图未取得两个稳定的独立帧') @@ -394,21 +477,19 @@ def wait_for_fleet_overlay_stable( screen: np.ndarray | None = None, timeout: float = 8.0, ) -> np.ndarray: - """等待战备舰队弹窗稳定后返回截图。 - - 当上层已通过阶段纠偏进入 ``CHOOSE_FLEET`` 时,当前截图本身就可能是 - 首进购买界面,此时不要再次强依赖旧的 overlay 像素签名;直接以当前截图 - 为起点做短暂稳定等待即可。 - """ - if screen is None: - screen = self.wait_for_overlay(DecisiveOverlay.FLEET_ACQUISITION, timeout=timeout) - - stable_deadline = time.monotonic() + 1.0 - last_screen = screen - while time.monotonic() < stable_deadline: - time.sleep(0.25) - last_screen = self._ctrl.screenshot() - return last_screen + """等待购买浮窗,给卡片文字留出展开时间。""" + if screen is not None and ( + self._has_stage_clear_choices(screen) or self._has_reward_drop(screen) + ): + raise TimeoutError('通关或奖励页面不能作为战备舰队读取') + if screen is None or not is_fleet_acquisition(screen): + self.wait_for_overlay(DecisiveOverlay.FLEET_ACQUISITION, timeout=timeout) + self._ctx.stop_event.wait(0.3) + check_stop(self._ctx.stop_event) + screen = self._ctrl.screenshot() + if not is_fleet_acquisition(screen): + raise TimeoutError('读取战备舰队时购买浮窗已关闭') + return screen def detect_last_offer_name( self, @@ -421,30 +502,41 @@ def detect_last_offer_name( def buy_fleet_option(self, click_position: tuple[float, float]) -> None: """点击购买一个舰船/技能卡。""" + check_stop(self._ctx.stop_event) self._ctrl.click(*click_position) time.sleep(0.3) def refresh_fleet(self) -> None: """点击「刷新」按钮,刷新备选舰船。""" + check_stop(self._ctx.stop_event) self._ctrl.click(*CLICK_FLEET_REFRESH) time.sleep(1.5) def close_fleet_overlay(self) -> bool: """关闭战备舰队获取 overlay,并确认已离开该弹窗。""" - self._ctrl.click(*CLICK_FLEET_CLOSE) - deadline = time.monotonic() + 5.0 - while time.monotonic() < deadline: - screen = self._ctrl.screenshot() - if not is_fleet_acquisition(screen): - time.sleep(0.2) # 等待动画完成 - return True - time.sleep(0.2) - _log.warning('[地图控制器] 关闭战备舰队弹窗后仍停留在原界面') - return False + try: + self.wait_for_overlay(DecisiveOverlay.FLEET_ACQUISITION, timeout=self._wait_timeout) + click_and_wait_for_page( + self._ctrl, + CLICK_FLEET_CLOSE, + lambda image: ( + self._phase_on_screen(image) + in {DecisivePhase.PREPARE_COMBAT, DecisivePhase.ADVANCE_CHOICE} + ), + config=NavConfig(timeout=self._wait_timeout, interval=0.3), + target='决战地图或前进点', + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) + except TimeoutError: + _log.warning('[地图控制器] 关闭战备舰队弹窗后未确认返回地图或前进点') + return False + return True def is_fleet_overlay_open(self) -> bool: """当前是否仍停留在战备舰队获取界面。""" - return is_fleet_acquisition(self._ctrl.screenshot()) + check_stop(self._ctx.stop_event) + return is_fleet_acquisition(self._ctrl.capture_frame().image) def check_dock_full(self) -> bool: """检查当前界面是否出现船坞已满提示。""" @@ -463,151 +555,123 @@ def click_use_last_fleet(self) -> None: 对应 Legacy ``decisive_battle_image[7]`` + ``click(873, 500)``。 由状态机多次调度实现重试。 """ - from autowsgr.image_resources import Templates - - click_confirm_pos: tuple[float, float] = (873 / 960, 500 / 540) - - screen = self._ctrl.screenshot() - match = ImageChecker.find_template( - screen, - Templates.Decisive.USE_LAST_FLEET, - confidence=0.8, + screen = wait_for_page( + self._ctrl, + lambda image: self._find_use_last(image) is not None, + target='使用上次舰队', + timeout=self._wait_timeout, + interval=0.3, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, ) - if match is not None: - self._ctrl.click(*match.center) - time.sleep(0.5) - - self._ctrl.click(*click_confirm_pos) - time.sleep(1.0) + match = self._find_use_last(screen) + if match is None: + raise TimeoutError('未识别到使用上次舰队按钮,拒绝点击') + check_stop(self._ctx.stop_event) + self._ctrl.click(*match.center) + # 等按钮的点击动画结束,再辨别下方的舰队确认按钮。 + self._ctx.stop_event.wait(0.3) + following = wait_for_page( + self._ctrl, + lambda image: ( + self._find_use_last(image) is not None + or self._phase_on_screen(image) + in { + DecisivePhase.PREPARE_COMBAT, + DecisivePhase.ADVANCE_CHOICE, + DecisivePhase.CHOOSE_FLEET, + } + ), + timeout=self._wait_timeout, + target='上次舰队确认或决战地图', + interval=0.3, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) + if self._find_use_last(following) is not None: + check_stop(self._ctx.stop_event) + self._ctrl.click(873 / 960, 500 / 540) def use_skill(self) -> list[str]: """在地图页使用一次副官技能并返回识别到的舰船。""" - return _fleet_ocr.use_skill(self._ctrl, self._ocr) + return _fleet_ocr.use_skill(self._ctx, self._ocr) def check_fleet( self, + observe_repairing: Callable[[str], None] | None = None, ) -> tuple[list[str | None], dict[int, ShipDamageState], set[str]]: - """恢复进度时在编队页面扫描当前编队及所有可用舰船。 - - 完整 UI 流程: - - 1. 进入编队页 (preparation page) - 2. OCR 识别当前编队成员 + 像素检测血量 - 3. 进入选船列表扫描所有可用舰船 - 4. 返回地图页 - - 对齐 legacy ``_check_fleet``: 同时收集编队成员与列表中的舰船。 - - Returns - ------- - tuple[list[str | None], dict[int, ShipDamageState], set[str]] - ``(fleet, damage, all_ships)``: - - - *fleet*: 当前 6 槽位舰船名 (``None`` 为空) - - *damage*: 各槽位血量状态 - - *all_ships*: 所有可用舰船名 (含编队成员) - """ - # TODO(2de0cf4f 回退): legacy 只识别选船列表首屏, 会漏掉首屏以下的舰船。 - # 完整遍历 (DecisiveShipListWalker, 2de0cf4f) 因入场动画竞态 - # (页面签名先于下拉文字就绪, 筛选检查误杀, 2026-11-14 实机日志) 已回退。 - # 待有真实 issue 证明首屏漏船影响决策时, 修复竞态后再恢复完整遍历。 - _log.info('[地图控制器] 扫描当前编队与可用舰船') - + """在准备页核对当前编队和伤情,查看选船列表第一页有哪些候补舰,然后返回地图。""" self.enter_formation() - time.sleep(0.5) # 等待编队页加载完成 page = DecisiveBattlePreparationPage(self._ctx, self._config, self._ocr) - - screen = self._ctrl.screenshot() - fleet = page.detect_fleet(screen) - damage = page.detect_ship_damage(screen) - - # 进入选船列表:先确认已离开出征准备页,再进行一次识别 - page.click_ship_slot(0) - deadline = time.monotonic() + 5.0 - ship_list_screen = None - while time.monotonic() < deadline: - time.sleep(0.2) - screen = self._ctrl.screenshot() - if not BattlePreparationPage.is_current_page(screen): - ship_list_screen = screen - break - - if ship_list_screen is None: - _log.warning('[地图控制器] 点击舰船位后未确认进入选船列表,按当前截图继续识别') - ship_list_screen = self._ctrl.screenshot() - else: - time.sleep(0.3) # 等待选船列表内容稳定 - ship_list_screen = self._ctrl.screenshot() - - available = _recognize_ships(self._ocr, ship_list_screen) - _log.debug('[地图控制器] 选船列表识别结果: {}', sorted(available)) - - # 编队中的舰船也计入可用集合 - all_ships = set(available) - for name in fleet: - if name is not None: - all_ships.add(name) - - # 返回准备页 - self._ctrl.click(0.05, 0.05) - time.sleep(1.0) - - # 返回地图页 + fleet, damage = read_complete_fleet(page, self._ctx.stop_event) + if observe_repairing is not None: + for slot, name in enumerate(fleet): + if name and damage[slot] is ShipDamageState.REPAIRING: + observe_repairing(name) + available = page.read_first_screen_candidates() + check_stop(self._ctx.stop_event) page.go_back() - time.sleep(1.0) - - _log.info( - '[地图控制器] 编队={}, 可用舰船={}', - fleet, - sorted(all_ships), - ) - return fleet, damage, all_ships - - # ══════════════════════════════════════════════════════════════════════ - # 选择前进点 overlay - # ══════════════════════════════════════════════════════════════════════ + check_stop(self._ctx.stop_event) + _log.info('[决战] 当前编队={},选船首屏候选={}', fleet, sorted(available)) + return fleet, damage, available | {name for name in fleet if name} def select_advance_card(self, index: int) -> None: - """选择前进点卡片并确认。""" - if index < len(ADVANCE_CARD_POSITIONS): - self._ctrl.click(*ADVANCE_CARD_POSITIONS[index]) - time.sleep(0.5) - self._ctrl.click(*CLICK_ADVANCE_CONFIRM) - time.sleep(1.5) - - # ══════════════════════════════════════════════════════════════════════ - # 地图操作 - # ══════════════════════════════════════════════════════════════════════ + """按页面显示的两卡或三卡布局选择前进点并确认。""" - def enter_formation(self) -> None: - """点击右下角「编队」按钮。""" - # TODO: 改进鲁棒性 - time.sleep(1) - # 调试:检测当前页面状态 - from autowsgr.image_resources import Templates - from autowsgr.ui.utils.navigation import NavConfig + def layout(image: np.ndarray) -> int | None: + return advance_choice_layout(image, branch_count=self._branch_count) - screen = self._ctrl.screenshot() - map_check = ImageChecker.template_exists( - screen, Templates.Decisive.MAP_PAGE, confidence=0.85 - ) - prep_check = ImageChecker.template_exists( - screen, Templates.Page.BATTLE_PREP, confidence=0.85 + screen = wait_for_page( + self._ctrl, + lambda image: layout(image) is not None, + target='选择前进点', + timeout=self._wait_timeout, + interval=0.3, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, ) - _log.debug( - '[地图控制器] 点击编队前 - 地图页: {}, 出征准备页: {}', - map_check, - prep_check, + count = layout(screen) + if count not in (2, 3) or not 0 <= index < count: + raise ValueError('前进点索引超出实际布局') + left = (ADVANCE_CHOICE_THREE_ROI if count == 3 else ADVANCE_CHOICE_ROI).center[0] + positions = (left, 0.5, 1.0 - left) if count == 3 else (left, 1.0 - left) + check_stop(self._ctx.stop_event) + self._ctrl.click(positions[index], 0.5) + self._ctx.stop_event.wait(0.5) + click_and_wait_for_page( + self._ctrl, + CLICK_ADVANCE_CONFIRM, + lambda image: layout(image) is None, + target='离开前进点选择', + config=NavConfig(timeout=self._wait_timeout, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, ) - config = NavConfig(timeout=10.0, interval=0.5, max_retries=3) + @staticmethod + def is_fleet_preparation(screen: np.ndarray) -> bool: + """沿用出征准备页的识别特征。""" + return bool(BattlePreparationPage.is_current_page(screen)) + + def enter_formation(self) -> None: + """确认地图上的浮窗已经关闭,再进入出征准备页。""" + wait_for_page( + self._ctrl, + self.is_map_page, + target='决战地图', + timeout=self._wait_timeout, + interval=0.3, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) click_and_wait_for_page( self._ctrl, CLICK_FORMATION, - BattlePreparationPage.is_current_page, - config=config, - source='决战地图', + self.is_fleet_preparation, target='出征准备', + config=NavConfig(timeout=self._wait_timeout, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, ) def click_sortie(self) -> None: @@ -616,31 +680,125 @@ def click_sortie(self) -> None: time.sleep(2.0) def go_to_map_page(self) -> None: - """确保当前在决战地图页(若在准备页则点击左上角返回)。""" - screen = self._ctrl.screenshot() - if is_decisive_map_page(screen): + """核实决战地图,或从已识别的准备页返回。""" + check_stop(self._ctx.stop_event) + frame = self._ctrl.capture_frame() + if self.is_map_page(frame.image): return - self._ctrl.click(0.03, 0.06) - time.sleep(1.0) - if not is_decisive_map_page(self._ctrl.screenshot()): - _log.warning('[地图控制器] 无法确认已回到地图页') + if not self.is_fleet_preparation(frame.image): + raise RuntimeError('未确认决战地图或编队页,无法打开撤退菜单') + click_and_wait_for_page( + self._ctrl, + (0.03, 0.06), + self.is_map_page, + target='决战地图', + config=NavConfig(timeout=self._wait_timeout, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) def open_retreat_dialog(self) -> None: - """点击左上角撤退按钮,打开确认退出 overlay。""" self.go_to_map_page() + self._open_exit_from_map() + + def _open_exit_from_map(self) -> None: + check_stop(self._ctx.stop_event) self._ctrl.click(*CLICK_RETREAT_BUTTON) - time.sleep(1.0) - self.wait_for_overlay(DecisiveOverlay.CONFIRM_EXIT, timeout=5.0) + self.wait_for_overlay(DecisiveOverlay.CONFIRM_EXIT) + + def try_leave_interrupted_sortie(self) -> bool: + """冷启动遇到已打开的决战时,从已核实的准备页或地图暂离到总览。""" + check_stop(self._ctx.stop_event) + screen = self._ctrl.capture_frame().image + if not self.is_map_page(screen): + if not self.is_fleet_preparation(screen): + return False + # 普通准备页有选中的编号舰队标签,决战的同一区域则显示固定标题。 + if BattlePreparationPage.get_selected_fleet(screen) is not None: + return False + title = PixelChecker.crop(screen, 113 / 1280, 87 / 720, 307 / 1280, 144 / 720) + result = self._ocr.recognize_single(title) + if result.text.strip() != '主力决战舰队' or result.confidence < 0.8: + raise ActionFailedError('恢复决战', '未能在准备页核实主力决战舰队标题') + click_and_wait_for_page( + self._ctrl, + CLICK_BACK, + self.is_map_page, + target='决战地图', + config=NavConfig(timeout=self._wait_timeout, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) + self._open_exit_from_map() + self.confirm_leave() + return True + + def _confirm_exit(self, coord: tuple[float, float]) -> None: + from autowsgr.ui.decisive.battle_page import DecisiveBattlePage + + self.wait_for_overlay(DecisiveOverlay.CONFIRM_EXIT, timeout=self._wait_timeout) + click_and_wait_for_page( + self._ctrl, + coord, + DecisiveBattlePage.is_current_page, + target='决战总览', + config=NavConfig(timeout=self._wait_timeout, interval=0.3), + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) def confirm_retreat(self) -> None: - """在确认退出 overlay 中点击「撤退」。""" - self._ctrl.click(*CLICK_RETREAT_CONFIRM) - time.sleep(2.0) + self._confirm_exit(CLICK_RETREAT_CONFIRM) def confirm_leave(self) -> None: - """在确认退出 overlay 中点击「暂离」。""" - self._ctrl.click(*CLICK_LEAVE) - time.sleep(2.0) + self._confirm_exit(CLICK_LEAVE) + + def leave_to_overview(self) -> None: + """在地图或已打开的退出菜单暂离。每个按钮只点一次,直到新画面确认总览。""" + from autowsgr.ui.decisive.battle_page import DecisiveBattlePage + + stop = self._ctx.stop_event + deadline = time.monotonic() + self._wait_timeout + menu_requested = leave_requested = False + previous = None + while True: + check_stop(stop) + frame = self._ctrl.capture_frame() + check_stop(stop) + if frame.is_newer_than(previous, allow_static=False): + screen = frame.image + if DecisiveBattlePage.is_current_page(screen): + return + if ( + not leave_requested + and self.detect_overlay(screen) is DecisiveOverlay.CONFIRM_EXIT + ): + check_stop(stop) + self._ctrl.click(*CLICK_LEAVE) + leave_requested = True + # 暂离已经提交。即使加载超过常规导航时限,也只等总览的新帧。 + deadline = time.monotonic() + 2 * self._wait_timeout + elif not (menu_requested or leave_requested) and self.is_map_page(screen): + check_stop(stop) + self._ctrl.click(*CLICK_RETREAT_BUTTON) + menu_requested = True + deadline = time.monotonic() + self._wait_timeout + previous = frame.snapshot() + if time.monotonic() >= deadline: + raise ActionFailedError('暂离决战', '未能确认已返回决战总览,保留当前页面') + stop.wait(0.3) + + def continue_combat_result(self, screen: np.ndarray) -> None: + """只在仍可识别的战果或经验页推进,避免点击决战地图。""" + from autowsgr.combat.actions import Coords + from autowsgr.combat.recognizer import CombatRecognizer + from autowsgr.combat.state import CombatPhase + + if CombatRecognizer.identify_current( + screen, [CombatPhase.RESULT, CombatPhase.EXP_SETTLEMENT] + ): + check_stop(self._ctx.stop_event) + self._ctrl.click(*Coords.CLICK_RESULT) @staticmethod def _has_stage_clear_choices(screen: np.ndarray) -> bool: @@ -704,87 +862,89 @@ def _raise_clear_error(self, screen: np.ndarray, reason: str) -> NoReturn: _STAGE_CLEAR_TIMEOUT = 45.0 - def confirm_stage_clear(self, *, resume_rewards: bool = False) -> list[str]: # noqa: PLR0912 - """按实际控件结算奖励,两个独立帧确认返回入口后才结束小关。 + def reset_settlement(self) -> None: + """新一轮或成功结算后,清理本次通关的凭据与掉落记录。""" + self._clear_drops = None + self._clear_last_frame = None + self._clear_at_entry = False - 左侧「确认通关」必须处于选中状态才能确认,避免误选「放弃」。 - 掉落展示只在菜单和完整对话框同时可见时推进;过场动画不点击。 - 只有调用者明确恢复已确认的结算时,才允许从完整掉落页继续。 - """ + def _advance_reward(self, screen: np.ndarray, collected: list[str]) -> bool: + """处理已确认结算中的一个页面,返回是否观察到了入口。""" from autowsgr.combat import recognize_ship_drop from autowsgr.combat.actions import Coords from autowsgr.image_resources import Templates - if self._ctx.stop_event.is_set(): - raise InterruptedError('决战通关结算时收到停止请求') + if self._has_reward_drop(screen): + try: + drop = recognize_ship_drop(screen, ocr=self._ocr) + if drop.ship_name and drop.ship_name not in collected: + collected.append(drop.ship_name) + except Exception as exc: + _log.warning('[地图控制器] 掉落舰名读取失败: {}', exc) + check_stop(self._ctx.stop_event) + self._ctrl.click(*Coords.CLICK_RESULT) + return False + + confirm = ImageChecker.find_any( + screen, + Templates.Confirm.all(), + roi=ROI(0.25, 0.15, 0.8, 0.93), + confidence=0.88, + ) + if confirm is not None: + check_stop(self._ctx.stop_event) + self._ctrl.click(*confirm.center) + return False + return ( + ImageChecker.find_any( + screen, + Templates.Decisive.entry_status_templates(), + roi=ENTRY_STATUS_ROI, + confidence=0.85, + ) + is not None + ) + + def confirm_stage_clear(self, *, resume_rewards: bool = False) -> list[str]: + """按通关控件推进结算,连续两次观察到裸露的入口页才结束。""" + check_stop(self._ctx.stop_event) frame = self._ctrl.capture_frame() - if resume_rewards and not self._has_reward_drop(frame.image): - self._raise_clear_error(frame.image, '未确认完整掉落页面,拒绝恢复决战通关奖励结算') - if not resume_rewards and not self.is_stage_clear(frame.image): - self._raise_clear_error(frame.image, '未确认真实决战通关页面,拒绝结算操作') + if self._clear_drops is None: + if resume_rewards: + if not self._has_reward_drop(frame.image): + self._raise_clear_error( + frame.image, '未确认完整掉落页面,拒绝恢复决战通关奖励结算' + ) + self._clear_drops = [] + elif not self.is_stage_clear(frame.image): + self._raise_clear_error(frame.image, '未确认真实决战通关页面,拒绝结算操作') + deadline = time.monotonic() + self._STAGE_CLEAR_TIMEOUT - collected: list[str] = [] - last_frame = None - last_drop = None - entry_frames = 0 - confirmed_clear = resume_rewards while time.monotonic() < deadline: - if self._ctx.stop_event.is_set(): - raise InterruptedError('决战通关结算时收到停止请求') - token = frame.sequence if frame.sequence is not None else frame.captured_at - if token == last_frame: - time.sleep(0.05) - frame = self._ctrl.capture_frame() - continue - last_frame = token - screen = frame.image - clear_button = self._stage_clear_button(screen) - if clear_button is not None: - selected = PixelChecker.check_signature(screen, STAGE_CLEAR_SELECTED).matched - # 先点击实际左卡,再等待新帧确认选中;绝不确认右侧放弃选项。 - self._ctrl.click(*(clear_button.center if selected else (0.31, 0.48))) - confirmed_clear = confirmed_clear or selected - entry_frames = 0 - elif confirmed_clear: - confirm = ImageChecker.find_any( - screen, - Templates.Confirm.all(), - roi=ROI(0.25, 0.15, 0.8, 0.93), - confidence=0.88, - ) - if confirm is not None: - self._ctrl.click(*confirm.center) - entry_frames = 0 - last_drop = None - elif self._has_reward_drop(screen): - try: - drop = recognize_ship_drop(screen, ocr=self._ocr) - if drop.ship_name and drop.ship_name != last_drop: - collected.append(drop.ship_name) - last_drop = drop.ship_name - except Exception as exc: - # 舰名只用于反馈,不让一次 OCR 失败改变已确认的控件操作。 - _log.warning('[地图控制器] 掉落舰名读取失败: {}', exc) - # 斜纹角只证明对话框已展开,不是继续按钮;复用掉落页已验证的继续区域。 - self._ctrl.click(*Coords.CLICK_RESULT) - entry_frames = 0 - elif ( - ImageChecker.find_any( - screen, - Templates.Decisive.entry_status_templates(), - roi=ROI(0.3, 0.8, 0.78, 1.0), - confidence=0.85, - ) - is not None - ): - entry_frames += 1 - if entry_frames >= 2: + check_stop(self._ctx.stop_event) + if frame.is_newer_than(self._clear_last_frame, allow_static=self._clear_at_entry): + self._clear_last_frame = frame.snapshot() + clear_button = self._stage_clear_button(frame.image) + if clear_button is not None: + selected = PixelChecker.check_signature( + frame.image, STAGE_CLEAR_SELECTED + ).matched + check_stop(self._ctx.stop_event) + self._ctrl.click(*(clear_button.center if selected else (0.31, 0.48))) + if selected and self._clear_drops is None: + self._clear_drops = [] + self._clear_at_entry = False + elif self._clear_drops is not None: + at_entry = self._advance_reward(frame.image, self._clear_drops) + if at_entry and self._clear_at_entry: + check_stop(self._ctx.stop_event) + collected = self._clear_drops + self.reset_settlement() _log.info('[地图控制器] 通关结算完成并确认返回入口,掉落={}', collected) return collected - else: - entry_frames = 0 - last_drop = None + self._clear_at_entry = at_entry time.sleep(0.3) + check_stop(self._ctx.stop_event) frame = self._ctrl.capture_frame() self._raise_clear_error(frame.image, '决战通关结算超时,未确认返回入口页,保留现场并停止') @@ -804,7 +964,7 @@ def repair_at_node(self, repair_level: int) -> list[int]: repaired = page.apply_repair(strategy) if repaired: - _log.info('[地图控制器] 修理完成, 修理槽位: {}', repaired) + _log.info('[地图控制器] 快修完成,编队位置(从 1 开始):{}', [i + 1 for i in repaired]) else: _log.debug('[地图控制器] 无需修理') @@ -826,9 +986,9 @@ def change_fleet( ---------- fleet_id: 舰队编号 (1-4);``None`` 代表不指定舰队。 - 更换 1 队时槽位 0 必须保留目标舰船。 + 更换第 1 舰队时,旗舰位置必须指定舰船。 ship_names: - 目标舰船名列表 (按槽位 0-5);``None``/``""`` 表示该位留空。 + 按编队顺序列出舰名,第一项为旗舰。``None``/``""`` 表示该位置留空。 """ _log.info('[地图控制器] 进入准备页换船: {} 队 → {}', fleet_id, ship_names) page = DecisiveBattlePreparationPage(self._ctx, self._config, self._ocr) @@ -845,12 +1005,12 @@ def wait_for_overlay( interval: float = 0.3, ) -> np.ndarray: """反复截图直到指定 overlay 出现。""" - tmpl = get_overlay_template(target) - deadline = time.monotonic() + timeout - while True: - screen = self._ctrl.screenshot() - if ImageChecker.template_exists(screen, tmpl, confidence=0.85): - return screen - if time.monotonic() >= deadline: - raise TimeoutError(f'等待 overlay {target.value} 超时 ({timeout}s)') - time.sleep(interval) + return wait_for_page( + self._ctrl, + lambda screen: self.detect_overlay(screen) == target, + target=target.value, + timeout=timeout, + interval=interval, + stop_event=self._ctx.stop_event, + timeout_error=TimeoutError, + ) diff --git a/autowsgr/ui/decisive/overlay.py b/autowsgr/ui/decisive/overlay.py index d96a9a1b0..97cf0836e 100644 --- a/autowsgr/ui/decisive/overlay.py +++ b/autowsgr/ui/decisive/overlay.py @@ -18,6 +18,7 @@ from autowsgr.image_resources import Templates from autowsgr.infra.logger import get_logger from autowsgr.vision import ( + ROI, ImageChecker, ImageTemplate, MatchStrategy, @@ -32,6 +33,23 @@ _log = get_logger('ui.decisive') + +def _padded_roi(x1: float, y1: float, x2: float, y2: float) -> ROI: + """Fork 的 720p 截图边界留一像素,避免模板大小取整后比 ROI 大。""" + return ROI( + max(0.0, x1 - 1 / 1280), + max(0.0, y1 - 1 / 720), + min(1.0, x2 + 1 / 1280), + min(1.0, y2 + 1 / 720), + ) + + +ENTRY_STATUS_ROI = _padded_roi(547 / 1280, 635 / 720, 814 / 1280, 705 / 720) +USE_LAST_FLEET_ROI = _padded_roi(0.82, 0.30, 1.0, 0.50) +CONFIRM_EXIT_ROI = _padded_roi(363 / 1280, 161 / 720, 917 / 1280, 465 / 720) +ADVANCE_CHOICE_ROI = _padded_roi(324 / 1280, 237 / 720, 607 / 1280, 429 / 720) +ADVANCE_CHOICE_THREE_ROI = _padded_roi(142 / 1280, 235 / 720, 429 / 1280, 431 / 720) + # ═══════════════════════════════════════════════════════════════════════════════ # 枚举 # ═══════════════════════════════════════════════════════════════════════════════ @@ -215,7 +233,12 @@ class DecisiveOverlay(enum.Enum): # ═══════════════════════════════════════════════════════════════════════════════ -def detect_decisive_overlay(screen: np.ndarray) -> DecisiveOverlay | None: +def detect_decisive_overlay( + screen: np.ndarray, + *, + branch_count: int | None = None, + advance_choice_roi: ROI | None = None, +) -> DecisiveOverlay | None: """按优先级检测决战地图页上的弹窗。 Parameters @@ -228,10 +251,12 @@ def detect_decisive_overlay(screen: np.ndarray) -> DecisiveOverlay | None: DecisiveOverlay | None 首个命中的弹窗类型;无弹窗则返回 ``None``。 """ - for overlay_type, tmpl in _OVERLAY_TEMPLATE_MAP.items(): - if ImageChecker.template_exists(screen, tmpl, confidence=0.85): - _log.debug('[决战] 检测到 overlay: {}', overlay_type.value) - return overlay_type + if is_fleet_acquisition(screen): + return DecisiveOverlay.FLEET_ACQUISITION + if is_confirm_exit(screen): + return DecisiveOverlay.CONFIRM_EXIT + if advance_choice_layout(screen, branch_count=branch_count, roi=advance_choice_roi): + return DecisiveOverlay.ADVANCE_CHOICE return None @@ -249,12 +274,35 @@ def is_fleet_acquisition(screen: np.ndarray) -> bool: def is_advance_choice(screen: np.ndarray) -> bool: """截图是否为选择前进点 overlay。""" - return ImageChecker.template_exists(screen, Templates.Decisive.ADVANCE_CHOICE, confidence=0.85) + return advance_choice_layout(screen) is not None + + +def advance_choice_layout( + screen: np.ndarray, + *, + branch_count: int | None = None, + roi: ROI | None = None, +) -> int | None: + """路线只决定优先搜索区域,实际匹配仍决定两卡或三卡布局。""" + preferred = ADVANCE_CHOICE_THREE_ROI if branch_count == 3 else ADVANCE_CHOICE_ROI + areas = (preferred, ADVANCE_CHOICE_ROI, ADVANCE_CHOICE_THREE_ROI) + if roi is not None: + areas = (roi, *areas) + for area in dict.fromkeys(areas): + if ImageChecker.template_exists( + screen, Templates.Decisive.ADVANCE_CHOICE, roi=area, confidence=0.8 + ): + if area == ADVANCE_CHOICE_THREE_ROI: + return 3 + return 3 if area == roi and branch_count == 3 else 2 + return None def is_confirm_exit(screen: np.ndarray) -> bool: """截图是否为确认退出 overlay。""" - return ImageChecker.template_exists(screen, Templates.Decisive.CONFIRM_EXIT, confidence=0.85) + return ImageChecker.template_exists( + screen, Templates.Decisive.CONFIRM_EXIT, roi=CONFIRM_EXIT_ROI, confidence=0.85 + ) def get_overlay_template(overlay: DecisiveOverlay) -> ImageTemplate: diff --git a/autowsgr/ui/decisive/preparation.py b/autowsgr/ui/decisive/preparation.py index 333bae6e3..2eebe9c29 100644 --- a/autowsgr/ui/decisive/preparation.py +++ b/autowsgr/ui/decisive/preparation.py @@ -17,35 +17,103 @@ from __future__ import annotations +import time from typing import TYPE_CHECKING +import numpy as np + from autowsgr.combat.fleet import exact_fleet_rules +from autowsgr.constants import DECISIVE_SKILL_NAMES, ship_name_identity +from autowsgr.infra import ActionFailedError from autowsgr.infra.logger import get_logger -from autowsgr.ui.battle.constants import CLICK_BACK +from autowsgr.types import ShipDamageState +from autowsgr.ui.battle.blood import classify_blood +from autowsgr.ui.battle.constants import BLOOD_BAR_PROBE, CLICK_BACK from autowsgr.ui.battle.preparation import BattlePreparationPage from autowsgr.ui.decisive.legacy_fleet_change import change_fleet_legacy from autowsgr.ui.decisive.overlay import is_decisive_map_page -from autowsgr.ui.utils import click_and_wait_for_page -from autowsgr.ui.utils.navigation import NavConfig +from autowsgr.ui.utils import click_and_wait_for_page, recognize_ships_in_list +from autowsgr.ui.utils.navigation import NavConfig, NavigationError, check_stop +from autowsgr.vision import Color, PixelChecker _log = get_logger('ui.decisive') if TYPE_CHECKING: - from collections.abc import Sequence + from collections.abc import Mapping, Sequence + from threading import Event from autowsgr.context import GameContext from autowsgr.infra import DecisiveConfig from autowsgr.vision import OCREngine +# classic 准备页在 960x540 下的十处维修标记采样点,颜色已从 BGR 转为 RGB。 +_REPAIR_SLOT_OFFSETS = (0, 111, 223, 335, 447, 559) +_REPAIR_MARKER = ( + (49, 220, Color.of(153, 55, 35)), + (58, 220, Color.of(174, 72, 51)), + (56, 231, Color.of(182, 63, 43)), + (72, 220, Color.of(218, 93, 66)), + (69, 231, Color.of(218, 93, 65)), + (126, 222, Color.of(220, 87, 73)), + (125, 230, Color.of(220, 92, 64)), + (138, 221, Color.of(174, 68, 44)), + (137, 230, Color.of(178, 68, 41)), + (146, 232, Color.of(150, 56, 47)), +) + + +type RepairSnapshot = tuple[list[str | None], dict[int, ShipDamageState]] + + +def is_complete_fleet(fleet: Sequence[str | None], damage: Mapping[int, ShipDamageState]) -> bool: + """逐个核对编队位置:有船时须认出舰名和伤情,舰名不能重复;空位不能有舰名或血条。""" + names = [ship_name_identity(name) for name in fleet if name] + return ( + len(fleet) == 6 + and set(damage) == set(range(6)) + and None not in names + and len(set(names)) == len(names) + and not any(name in DECISIVE_SKILL_NAMES for name in fleet) + and all( + isinstance(damage[i], ShipDamageState) + and (damage[i] is ShipDamageState.NO_SHIP) == (not name) + for i, name in enumerate(fleet) + ) + ) + + +def read_complete_fleet( + page: DecisiveBattlePreparationPage, stop_event: Event, *, fresh: bool = False +) -> RepairSnapshot: + """从同一张准备页截图核对整队舰名和伤情,画面没显示完整时再取新截图。""" + check_stop(stop_event) + snapshot = page.read_repair_snapshot(fresh=True) if fresh else page.read_repair_snapshot() + deadline = time.monotonic() + 2.0 + for _ in range(5): + if is_complete_fleet(*snapshot): + break + remaining = deadline - time.monotonic() + if remaining <= 0: + break + check_stop(stop_event) + try: + snapshot = page.read_repair_snapshot(fresh=True, timeout=remaining) + except ActionFailedError: + break + check_stop(stop_event) + if not is_complete_fleet(*snapshot): + raise RuntimeError('决战准备页未能确认全部舰船的名称和伤情') + return snapshot + + class DecisiveBattlePreparationPage(BattlePreparationPage): """决战出征准备页面控制器(无搜索框换船版)。 - 与 :class:`BattlePreparationPage` 唯一的区别是 - ``_use_search = False``,使选船页面跳过搜索框,直接 - 通过 DLL 行定位 + OCR 识别舰船列表并点击目标。 + 决战选船页没有搜索框,按舰船卡片的位置和名称选择目标。 + 准备页在同一张画面中识别舰名和维修标记,供编队与派修复核。 Parameters ---------- @@ -69,6 +137,65 @@ def __init__( self._ocr: OCREngine = ocr or ctx.ocr # type: ignore[assignment] self._config = config + @staticmethod + def detect_repair_damage(screen: np.ndarray) -> dict[int, ShipDamageState]: + """逐舰位先检查维修标记,未命中时按血条最接近的参考色判断伤情。""" + result = {} + for slot, offset in enumerate(_REPAIR_SLOT_OFFSETS): + if all( + PixelChecker.get_pixel(screen, (x + offset + 0.5) / 960, (y + 0.5) / 540).distance( + color + ) + < 30 + for x, y, color in _REPAIR_MARKER + ): + result[slot] = ShipDamageState.REPAIRING + else: + result[slot] = classify_blood( + PixelChecker.get_pixel(screen, *BLOOD_BAR_PROBE[slot]) + ) + return result + + def read_repair_snapshot( + self, *, fresh: bool = False, timeout: float = 3.0 + ) -> tuple[list[str | None], dict[int, ShipDamageState]]: + """在同一画面读取舰名和伤情;到期复查和用桶前后须取得新画面。""" + if fresh: + started = time.monotonic() + baseline: np.ndarray | None = None + while True: + check_stop(self._ctx.stop_event) + frame = self._ctrl.capture_frame() + if frame.sequence is None: + # 缺少解码序号时,截图时间可能来自缓存;像素变化才能确认刷新。 + if baseline is None: + baseline = frame.image.copy() + elif not np.array_equal(baseline, frame.image): + screen = frame.image + break + elif frame.captured_at >= started: + screen = frame.image + break + if time.monotonic() - started >= timeout: + raise ActionFailedError('决战维修复核未取得新的准备页画面') + self._ctx.stop_event.wait(0.05) + else: + screen = self._ctrl.screenshot() + return self.detect_fleet(screen), self.detect_repair_damage(screen) + + def read_first_screen_candidates(self) -> set[str]: + """从首舰位打开选船页,识别首屏舰名后回到准备页。""" + try: + self._open_choose_page(0, stop_event=self._ctx.stop_event) + except NavigationError as exc: + raise TimeoutError(str(exc)) from exc + # 离开准备页时卡片文字还在展开,稍候再读取首屏舰名。 + self._ctx.stop_event.wait(0.3) + check_stop(self._ctx.stop_event) + candidates = recognize_ships_in_list(self._ocr, self._ctrl.screenshot()) + self._cancel_choose_page(stop_event=self._ctx.stop_event) + return candidates + def change_fleet( self, fleet_id: int | None, @@ -94,7 +221,8 @@ def go_back(self) -> None: self._ctrl, click_coord=CLICK_BACK, checker=is_decisive_map_page, - config=NavConfig(timeout=10.0, interval=0.5, max_retries=3), + config=NavConfig(timeout=10.0, interval=0.5), + stop_event=self._ctx.stop_event, source='出征准备', target='决战地图', ) diff --git a/testing/tools/test_decisive_collection.py b/testing/tools/test_decisive_collection.py index b4cb388c3..9a5575768 100644 --- a/testing/tools/test_decisive_collection.py +++ b/testing/tools/test_decisive_collection.py @@ -763,7 +763,16 @@ def test_collection_does_not_recognize_non_map_or_overlay_frames( if overlay: patch = getattr(Templates.Decisive, overlay).image height, width = patch.shape[:2] - pixels[50 : 50 + height, 700 : 700 + width] = patch + x, y = { + 'FLEET_ACQUISITION': (500, 42), + 'CONFIRM_EXIT': (370, 165), + 'ADVANCE_CHOICE': (330, 241), + }[overlay] + template = getattr(Templates.Decisive, overlay) + scale = 1280 / template.source_resolution[0] + patch = cv2.resize(patch, (round(width * scale), round(height * scale))) + height, width = patch.shape[:2] + pixels[y : y + height, x : x + width] = patch native = MagicMock() monkeypatch.setattr('autowsgr.ui.decisive.map_controller.get_api_dll', lambda: native) assert ( diff --git a/testing/ui/decisive_battle_page/test_navigation.py b/testing/ui/decisive_battle_page/test_navigation.py new file mode 100644 index 000000000..528ef3522 --- /dev/null +++ b/testing/ui/decisive_battle_page/test_navigation.py @@ -0,0 +1,292 @@ +"""决战编队和前进点页面导航。""" + +import threading +from types import SimpleNamespace +from unittest.mock import MagicMock, call + +import numpy as np +import pytest + +from autowsgr.emulator.frame import CapturedFrame +from autowsgr.image_resources import Templates +from autowsgr.infra import ActionFailedError, DecisiveConfig +from autowsgr.types import DecisivePhase, ShipDamageState +from autowsgr.ui.battle.constants import CLICK_BACK as PREPARATION_BACK +from autowsgr.ui.choose_ship_page import ChooseShipPage +from autowsgr.ui.decisive import preparation +from autowsgr.ui.decisive.battle_page import DecisiveBattlePage +from autowsgr.ui.decisive.map_controller import DecisiveMapController +from autowsgr.ui.decisive.overlay import ( + ADVANCE_CHOICE_ROI, + ADVANCE_CHOICE_THREE_ROI, + CLICK_ADVANCE_CONFIRM, + CLICK_LEAVE, + CLICK_RETREAT_BUTTON, + DecisiveOverlay, +) +from autowsgr.ui.decisive.preparation import DecisiveBattlePreparationPage +from autowsgr.ui.utils.navigation import NavigationError, click_and_wait_for_page, wait_for_page + + +@pytest.mark.parametrize('count', [2, 3]) +def test_leftmost_route_uses_visible_layout_when_hint_is_wrong(count: int) -> None: + image = np.full((720, 1280, 3), 40, dtype=np.uint8) + blank = image.copy() + patch = Templates.Decisive.ADVANCE_CHOICE.image + x, y = (143, 236) if count == 3 else (325, 238) + h, w = patch.shape[:2] + image[y : y + h, x : x + w] = patch + ctx = SimpleNamespace(stop_event=threading.Event(), ctrl=MagicMock(), ocr=MagicMock()) + page = DecisiveMapController(ctx, DecisiveConfig()) + page.configure_route(2 if count == 3 else 3) + ctx.ctrl.screenshot.side_effect = [image, blank] + page.select_advance_card(0) + area = ADVANCE_CHOICE_THREE_ROI if count == 3 else ADVANCE_CHOICE_ROI + assert ctx.ctrl.click.call_args_list == [ + call(area.center[0], 0.5), + call(*CLICK_ADVANCE_CONFIRM), + ] + + +def test_fleet_candidates_read_only_the_first_visible_screen( + monkeypatch: pytest.MonkeyPatch, +) -> None: + ctx = SimpleNamespace(stop_event=MagicMock(), ctrl=MagicMock(), ocr=MagicMock()) + ctx.stop_event.is_set.return_value = False + page = DecisiveBattlePreparationPage(ctx, DecisiveConfig()) + preparing = np.zeros((2, 2, 3), np.uint8) + opening = np.ones_like(preparing) + expanded = np.full_like(preparing, 2) + ctx.ctrl.screenshot.side_effect = [opening, expanded, preparing] + monkeypatch.setattr(ChooseShipPage, 'is_current_page', lambda image: image is opening) + monkeypatch.setattr(page, 'is_current_page', lambda image: image is preparing) + + def recognize_names(_ocr, image: np.ndarray) -> set[str]: + ctx.stop_event.wait.assert_called_once_with(0.3) + assert image is expanded + return {'U-96', 'U-47'} + + recognize = MagicMock(side_effect=recognize_names) + monkeypatch.setattr(preparation, 'recognize_ships_in_list', recognize) + + assert page.read_first_screen_candidates() == {'U-96', 'U-47'} + recognize.assert_called_once_with(ctx.ocr, expanded) + assert ctx.ctrl.click.call_count == 2 + ctx.ctrl.swipe.assert_not_called() + + +@pytest.mark.parametrize('duplicate', [False, True]) +def test_inventory_registers_repair_marker_only_after_complete_formation( + monkeypatch: pytest.MonkeyPatch, duplicate: bool +) -> None: + ctx = SimpleNamespace(stop_event=threading.Event(), ctrl=MagicMock(), ocr=MagicMock()) + controller = DecisiveMapController(ctx, DecisiveConfig()) + controller.enter_formation = MagicMock() + page = MagicMock() + monkeypatch.setattr( + 'autowsgr.ui.decisive.map_controller.DecisiveBattlePreparationPage', lambda *_: page + ) + damage = dict.fromkeys(range(6), ShipDamageState.NO_SHIP) + damage.update({0: ShipDamageState.REPAIRING, 1: ShipDamageState.NORMAL}) + complete = ['351', 'U-96', None, None, None, None] + incomplete = ['U-47', 'U-47' if duplicate else None, None, None, None, None] + page.read_repair_snapshot.side_effect = [(incomplete, damage), (complete, damage)] + page.read_first_screen_candidates.return_value = {'U-1206'} + report = MagicMock() + + fleet, _, inventory = controller.check_fleet(report) + assert fleet == complete + assert inventory == {'351', 'U-96', 'U-1206'} + assert page.read_repair_snapshot.call_args.kwargs['fresh'] + report.assert_called_once_with('351') + + +def test_map_classification_checks_each_obstruction_once(monkeypatch: pytest.MonkeyPatch) -> None: + ctx = SimpleNamespace(stop_event=threading.Event(), ctrl=MagicMock(), ocr=MagicMock()) + page = DecisiveMapController(ctx, DecisiveConfig()) + image = np.zeros((2, 2, 3), np.uint8) + page._has_stage_clear_choices = MagicMock(return_value=False) + page._has_reward_drop = MagicMock(return_value=False) + page._find_use_last = MagicMock(return_value=None) + page.detect_overlay = MagicMock(return_value=None) + page._has_map_controls = MagicMock(return_value=True) + monkeypatch.setattr( + 'autowsgr.ui.decisive.map_controller.ImageChecker.template_exists', lambda *_a, **_kw: False + ) + assert page.detect_decisive_phase(image) is DecisivePhase.PREPARE_COMBAT + for checker in ( + page._has_stage_clear_choices, + page._has_reward_drop, + page._find_use_last, + page._has_map_controls, + ): + checker.assert_called_once_with(image) + page.detect_overlay.assert_called_once_with(image, advance_choice_roi=None) + page.detect_overlay.return_value = DecisiveOverlay.CONFIRM_EXIT + assert not page.is_map_page(image) + + +@pytest.mark.parametrize( + ('start', 'text', 'confidence', 'after_clicks', 'error', 'clicks'), + [ + ( + 'prep', + '主力决战舰队', + 0.99, + ['map', 'exit', 'exit', 'overview'], + None, + [PREPARATION_BACK, CLICK_RETREAT_BUTTON, CLICK_LEAVE], + ), + ('map', '', 0.0, ['exit', 'exit', 'overview'], None, [CLICK_RETREAT_BUTTON, CLICK_LEAVE]), + ('ordinary', '主力决战舰队', 1.0, [], None, []), + ('other', '', 0.0, [], None, []), + ('prep', '决战舰队', 0.99, [], ActionFailedError, []), + ('prep', '主力决战舰队', 0.5, [], ActionFailedError, []), + ('prep', '主力决战舰队', 1.0, ['other'], TimeoutError, [PREPARATION_BACK]), + ('map', '', 0.0, ['exit', 'other'], TimeoutError, [CLICK_RETREAT_BUTTON]), + ], +) +def test_cold_start_confirms_each_screen_before_leaving( + monkeypatch: pytest.MonkeyPatch, + start: str, + text: str, + confidence: float, + after_clicks: list[str], + error: type[Exception] | None, + clicks: list[tuple[float, float]], +) -> None: + screens = { + name: np.zeros((720, 1280, 3), np.uint8) + for name in ('prep', 'ordinary', 'other', 'map', 'exit', 'overview') + } + screens['prep'][87:144, 113:307] = 170 + screens['ordinary'][122:127, 94:99] = (16, 133, 228) # 普通第一舰队的选中标签 + ctx = SimpleNamespace(ctrl=MagicMock(), ocr=MagicMock(), stop_event=threading.Event()) + page = DecisiveMapController(ctx, DecisiveConfig()) + page._wait_timeout = 0 + ctx.ctrl.capture_frame.return_value.image = screens[start] + ctx.ctrl.screenshot.side_effect = [screens[name] for name in after_clicks] + ctx.ocr.recognize_single.return_value = SimpleNamespace(text=text, confidence=confidence) + monkeypatch.setattr(page, 'is_map_page', lambda s: s is screens['map']) + monkeypatch.setattr( + page, 'is_fleet_preparation', lambda s: s is screens['prep'] or s is screens['ordinary'] + ) + monkeypatch.setattr( + page, + 'detect_overlay', + lambda s: DecisiveOverlay.CONFIRM_EXIT if s is screens['exit'] else None, + ) + monkeypatch.setattr(DecisiveBattlePage, 'is_current_page', lambda s: s is screens['overview']) + + monkeypatch.setattr('autowsgr.ui.page.get_current_page', lambda *_args, **_kwargs: None) + monkeypatch.setattr('autowsgr.infra.logger.save_image', MagicMock()) + if error is None: + assert page.try_leave_interrupted_sortie() is bool(clicks) + else: + with pytest.raises(error): + page.try_leave_interrupted_sortie() + assert ctx.ctrl.click.call_args_list == [call(*point) for point in clicks] + if start == 'prep': + ctx.ocr.recognize_single.assert_called_once() + title = ctx.ocr.recognize_single.call_args.args[0] + assert title.shape[:2] == (57, 194) + assert np.all(title == 170) + else: + ctx.ocr.recognize_single.assert_not_called() + + +@pytest.mark.parametrize( + ('states', 'expected', 'success'), + [ + (['overview'], [], True), + ( + ['map', 'map', 'exit', 'other', 'exit', 'other', 'overview'], + [CLICK_RETREAT_BUTTON, CLICK_LEAVE], + True, + ), + (['exit', 'exit', 'other', 'overview'], [CLICK_LEAVE], True), + (['exit'], [CLICK_LEAVE], False), + (['map'], [CLICK_RETREAT_BUTTON], False), + (['other'], [], False), + ], +) +def test_scheduled_leave_clicks_only_confirmed_controls_and_waits_for_overview( + monkeypatch: pytest.MonkeyPatch, states: list[str], expected: list, success: bool +) -> None: + screens = {k: np.full((2, 2, 3), i, np.uint8) for i, k in enumerate(set(states))} + ctx = SimpleNamespace(ctrl=MagicMock(), ocr=MagicMock(), stop_event=threading.Event()) + page = DecisiveMapController(ctx, DecisiveConfig(), wait_timeout=0.8) + tick = 0 + + def capture() -> CapturedFrame: + screen = screens[states[min(tick, len(states) - 1)]] + return CapturedFrame(screen, tick, tick * 0.3) + + def advance(_seconds: float) -> None: + nonlocal tick + tick += 1 + + ctx.ctrl.capture_frame.side_effect = capture + monkeypatch.setattr(ctx.stop_event, 'wait', advance) + monkeypatch.setattr('autowsgr.ui.decisive.map_controller.time.monotonic', lambda: tick * 0.3) + monkeypatch.setattr(page, 'is_map_page', lambda s: s is screens.get('map')) + monkeypatch.setattr( + DecisiveBattlePage, 'is_current_page', lambda s: s is screens.get('overview') + ) + monkeypatch.setattr( + page, + 'detect_overlay', + lambda s: DecisiveOverlay.CONFIRM_EXIT if s is screens.get('exit') else None, + ) + if success: + page.leave_to_overview() + else: + with pytest.raises(ActionFailedError, match='未能确认已返回决战总览'): + page.leave_to_overview() + assert ctx.ctrl.click.call_args_list == [call(*point) for point in expected] + + +@pytest.mark.parametrize('stop_at', ['before_click', 'capture', 'interval']) +def test_page_wait_honors_stop_before_next_ui_action( + monkeypatch: pytest.MonkeyPatch, stop_at: str +) -> None: + ctrl = MagicMock() + event = threading.Event() + screen = np.zeros((2, 2, 3), np.uint8) + checker = MagicMock(return_value=False) + if stop_at == 'before_click': + event.set() + + def capture() -> np.ndarray: + if stop_at == 'capture': + event.set() + return screen + + ctrl.screenshot.side_effect = capture + monkeypatch.setattr('autowsgr.ui.page.get_current_page', lambda *_args, **_kwargs: None) + monkeypatch.setattr(event, 'wait', lambda _interval: event.set()) + with pytest.raises(InterruptedError): + click_and_wait_for_page(ctrl, (0.5, 0.5), checker, stop_event=event) + + assert ctrl.click.call_count == int(stop_at != 'before_click') + assert ctrl.screenshot.call_count == int(stop_at != 'before_click') + assert checker.call_count == int(stop_at == 'interval') + + +def test_wait_timeout_preserves_navigation_evidence_and_default_error( + monkeypatch: pytest.MonkeyPatch, +) -> None: + ctrl = MagicMock() + screen = np.zeros((2, 2, 3), np.uint8) + ctrl.screenshot.return_value = screen + monkeypatch.setattr('autowsgr.ui.page.get_current_page', lambda *_args, **_kwargs: None) + save = MagicMock() + monkeypatch.setattr('autowsgr.infra.logger.save_image', save) + with pytest.raises(NavigationError): + wait_for_page(ctrl, lambda _: False, timeout=0) + save.assert_called_once_with(screen, tag='NavError') + save.reset_mock() + with pytest.raises(TimeoutError) as timeout: + wait_for_page(ctrl, lambda _: False, timeout=0, timeout_error=TimeoutError) + assert isinstance(timeout.value.__cause__, NavigationError) + save.assert_called_once_with(screen, tag='NavError') diff --git a/testing/ui/decisive_battle_page/test_stage_clear.py b/testing/ui/decisive_battle_page/test_stage_clear.py index 616b36a44..601c9e215 100644 --- a/testing/ui/decisive_battle_page/test_stage_clear.py +++ b/testing/ui/decisive_battle_page/test_stage_clear.py @@ -14,6 +14,7 @@ from autowsgr.emulator.frame import CapturedFrame from autowsgr.image_resources import Templates +from autowsgr.types import DecisivePhase from autowsgr.ui.decisive import map_controller as module from autowsgr.ui.decisive.map_controller import DecisiveMapController @@ -49,6 +50,8 @@ def _reward_screen(menu: ImageTemplate | None, *, dialogue: bool) -> np.ndarray: def controller(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> DecisiveMapController: ctrl = DecisiveMapController.__new__(DecisiveMapController) ctrl._ctrl = MagicMock() + ctrl._branch_count = None + ctrl.reset_settlement() ctrl._ocr = MagicMock(side_effect=AssertionError('Unexpected OCR model dependency')) ctrl._ctx = SimpleNamespace( stop_event=threading.Event(), @@ -153,7 +156,7 @@ def test_item_reward_can_resume_settlement_with_real_templates( (round(template.width * 1280 / 960), round(template.height * 720 / 540)), ) height, width = patch.shape[:2] - entry[600 : 600 + height, 500 : 500 + width] = patch + entry[645 : 645 + height, 580 : 580 + width] = patch controller._ctrl.capture_frame.side_effect = [ CapturedFrame(image, 1, 1.0), CapturedFrame(entry, 2, 2.0), @@ -197,7 +200,7 @@ def test_clear_transition_cannot_become_a_stable_normal_map( final, ] monkeypatch.setattr(module, 'is_decisive_map_page', lambda _: True) - monkeypatch.setattr(module, 'detect_decisive_overlay', lambda _: None) + monkeypatch.setattr(module, 'detect_decisive_overlay', lambda _, **_kwargs: None) monkeypatch.setattr(controller, '_locate_ship_icon', lambda _: None) assert controller.wait_for_stable_map_frame() is final @@ -215,7 +218,7 @@ def test_settlement_checks_each_control_and_waits_for_two_fresh_entry_frames( clear, clear, # 缓存帧不能重复确认。 CapturedFrame(screen(), 2, 2.0), # 过场不能盲点。 - CapturedFrame(screen('reward_confirm'), 3, 3.0), + CapturedFrame(screen('entry', 'reward_confirm'), 3, 3.0), CapturedFrame(screen(*_DROP), 4, 4.0), entry, entry, @@ -358,6 +361,55 @@ def test_entry_confirmation_requires_consecutive_frames( assert controller._ctrl.capture_frame.call_count == 5 +def test_unsequenced_cached_rewards_are_consumed_once_and_static_entry_finishes( + controller: DecisiveMapController, + screen: Callable[..., np.ndarray], + monkeypatch: pytest.MonkeyPatch, +) -> None: + drop = MagicMock(return_value=SimpleNamespace(ship_name='测试舰甲')) + monkeypatch.setattr('autowsgr.combat.recognize_ship_drop', drop) + clear, confirm, reward, entry = ( + screen(*_CLEAR), + screen('reward_confirm'), + screen(*_DROP), + screen('entry'), + ) + pages = [clear, clear, confirm, confirm, reward, reward, entry, entry] + shared_buffer = clear.copy() + + def capture() -> CapturedFrame: + index = controller._ctrl.capture_frame.call_count - 1 + np.copyto(shared_buffer, pages[index]) + return CapturedFrame(shared_buffer, None, float(index)) + + controller._ctrl.capture_frame.side_effect = capture + assert controller.confirm_stage_clear() == ['测试舰甲'] + assert [call.args for call in controller._ctrl.click.call_args_list] == [ + (0.502, 0.847), + (0.502, 0.566), + (0.953, 0.954), + ] + assert controller._ctrl.capture_frame.call_count == 8 + drop.assert_called_once() + + +def test_unsequenced_entry_can_finish_after_capture_interruption( + controller: DecisiveMapController, screen: Callable[..., np.ndarray] +) -> None: + entry = screen('entry') + controller._ctrl.capture_frame.side_effect = [ + CapturedFrame(screen(*_CLEAR), None, 1.0), + CapturedFrame(entry, None, 2.0), + OSError('采集中断'), + ] + with pytest.raises(OSError, match='采集中断'): + controller.confirm_stage_clear() + + controller._ctrl.capture_frame.side_effect = [CapturedFrame(entry.copy(), None, 3.0)] + assert controller.confirm_stage_clear() == [] + controller._ctrl.click.assert_called_once_with(0.502, 0.847) + + def test_unselected_clear_card_is_selected_before_confirmation( controller: DecisiveMapController, screen: Callable[..., np.ndarray], @@ -373,6 +425,57 @@ def test_unselected_clear_card_is_selected_before_confirmation( assert controller._ctrl.click.call_args_list[1].args == (0.502, 0.847) +def test_interrupted_settlement_resumes_with_distinct_drops( + controller: DecisiveMapController, + screen: Callable[..., np.ndarray], + monkeypatch: pytest.MonkeyPatch, +) -> None: + drop = MagicMock( + side_effect=[ + SimpleNamespace(ship_name=name) for name in ('测试舰甲', '测试舰甲', '测试舰乙') + ] + ) + monkeypatch.setattr('autowsgr.combat.recognize_ship_drop', drop) + first_drop = CapturedFrame(screen(*_DROP), 2, 2.0) + controller._ctrl.capture_frame.side_effect = [ + CapturedFrame(screen(*_CLEAR), 1, 1.0), + first_drop, + OSError('采集中断'), + ] + with pytest.raises(OSError, match='采集中断'): + controller.confirm_stage_clear() + + # 恢复时缓存的旧帧不能再点击,淡入后的同名奖励也不能重复记录。 + controller._ctrl.capture_frame.side_effect = [ + first_drop, + CapturedFrame(screen(), 3, 3.0), + CapturedFrame(screen(*_DROP), 4, 4.0), + CapturedFrame(screen(*_DROP), 5, 5.0), + CapturedFrame(screen('entry'), 6, 6.0), + CapturedFrame(screen('entry'), 7, 7.0), + ] + assert controller.confirm_stage_clear() == ['测试舰甲', '测试舰乙'] + assert drop.call_count == 3 + assert controller._ctrl.click.call_count == 4 + + +def test_consumed_overlay_waits_until_first_allowed_page( + controller: DecisiveMapController, monkeypatch: pytest.MonkeyPatch +) -> None: + stages = [DecisivePhase.USE_LAST_FLEET, DecisivePhase.PREPARE_COMBAT] + monkeypatch.setattr( + controller, '_phase_on_screen', lambda image, **_: stages[int(image[0, 0, 0])] + ) + monkeypatch.setattr('autowsgr.ui.page.get_current_page', lambda *_, **__: None) + controller._ctx.ctrl = controller._ctrl + controller._ctrl.screenshot.side_effect = [ + np.full((2, 2, 3), page, np.uint8) for page in (0, 1) + ] + assert controller.wait_for_entry_phase(wait_for_use_last=False) == DecisivePhase.PREPARE_COMBAT + assert controller._ctrl.screenshot.call_count == 2 + controller._ctrl.click.assert_not_called() + + def test_stop_before_settlement_has_no_device_actions(controller: DecisiveMapController) -> None: controller._ctx.stop_event.set() with pytest.raises(InterruptedError): From 7698eb7ae205672b2842825be432aba5b2d21edc Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:30 +0800 Subject: [PATCH 5/8] =?UTF-8?q?fix(combat):=20=E6=88=98=E6=9E=9C=E9=A1=B5?= =?UTF-8?q?=E6=B6=88=E5=A4=B1=E5=90=8E=E4=BA=A4=E5=9B=9E=E5=86=B3=E6=88=98?= =?UTF-8?q?=E7=BB=93=E7=AE=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- autowsgr/combat/handlers.py | 6 ++++-- testing/combat/test_result_dismiss_unit.py | 17 ++++++++++++++++- 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/autowsgr/combat/handlers.py b/autowsgr/combat/handlers.py index 95d9ef720..bf1634cf5 100644 --- a/autowsgr/combat/handlers.py +++ b/autowsgr/combat/handlers.py @@ -529,7 +529,7 @@ def _click_result_until_closed( - 命中 *phase* → 点击被动画吞掉, 立即重试点击 (重试即动画等待); - 识别不到 (过渡帧/页面渐变中) → **只等待不点击**: 对切换中的 页面盲目连点会穿透中间页, 落点若是 PROCEED 对话框还可能误触 - 按钮。轮询窗口耗尽仍认不出才继续点击推进 (真正的未知页)。 + 按钮。窗口耗尽时,决战战果交回决战流程识别地图或浮窗,其他情况继续点击。 参数 ---------- @@ -570,7 +570,9 @@ def _click_result_until_closed( _log.debug('[Combat] {} 已推进到 {}', phase.name, current.name) return else: - # 整个轮询窗口都无法识别 → 未知页, 继续点击推进 + if phase == CombatPhase.RESULT and self._plan.mode == CombatMode.DECISIVE: + _log.debug('[Combat] 决战战果点击后持续无法识别,交回决战流程') + return _log.debug( '[Combat] {} 点击后持续无法识别 (第 {} 次), 继续点击', phase.name, attempt ) diff --git a/testing/combat/test_result_dismiss_unit.py b/testing/combat/test_result_dismiss_unit.py index c2d6f2caa..684ca0dc1 100644 --- a/testing/combat/test_result_dismiss_unit.py +++ b/testing/combat/test_result_dismiss_unit.py @@ -7,7 +7,7 @@ 返回, 引擎等待 PROCEED/GET_SHIP 等状态 7.5s 全落空 → 恢复失败 → 强制重启游戏。 现行判据是**到达验证**: 在 ``[phase] + 后继状态`` 集合上识别, -命中后继才算成功, 识别不到任何状态 (未知中间页) 则继续点击推进。 +命中后继才算成功。遇到持续未知的中间页时,决战战果交回决战流程,其他情况继续点击。 经验结算子页后正式注册为 ``CombatPhase.EXP_SETTLEMENT``, 不再是盲点。 """ @@ -20,6 +20,7 @@ from autowsgr.combat import handlers as handlers_mod from autowsgr.combat.handlers import PhaseHandlersMixin +from autowsgr.combat.plan import CombatMode from autowsgr.combat.state import CombatPhase from autowsgr.types import ConditionFlag @@ -79,6 +80,7 @@ def test_intermediate_page_keeps_clicking(self): 窗口内只等待不点击 (防穿透); 4 次 None 耗尽 polls 后才第二次点击。 """ host, device, _ = _make_host([None, None, None, None, CombatPhase.GET_SHIP]) + host._plan.mode = CombatMode.NORMAL host._click_result_until_closed(CombatPhase.RESULT) assert device.click.call_count == 2 @@ -220,6 +222,19 @@ def test_fast_passes_through_exp(self): assert device.click.call_count == 2 host._history.add.assert_not_called() + def test_decisive_result_hands_off_after_unknown_polls(self) -> None: + host, device, recognizer = _make_host( + [None, CombatPhase.RESULT, CombatPhase.EXP_SETTLEMENT, None, None, None, None], + end_phase=CombatPhase.RESULT, + collect_result_info=False, + ) + host._plan.mode = CombatMode.DECISIVE + host._tracking_phase = MagicMock() + + assert host._make_decision(CombatPhase.RESULT) == ConditionFlag.FIGHT_END + assert device.click.call_count == 3 + assert recognizer.identify_current.call_count == 7 + def test_slow_collects_grade_mvp_and_records(self): """慢速: 采集评级/MVP 记入战斗历史, 经验页是到达点 (只点一次)。""" host, device, _ = _make_host([CombatPhase.EXP_SETTLEMENT], collect_result_info=True) From 9c4d2444209e5c248f53c9d909da5468f689dad4 Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:35 +0800 Subject: [PATCH 6/8] =?UTF-8?q?feat(decisive):=20=E8=B0=83=E5=BA=A6?= =?UTF-8?q?=E8=8A=82=E7=82=B9=E7=BB=AD=E6=88=98=E4=B8=8E=E5=85=B7=E5=90=8D?= =?UTF-8?q?=E7=BB=B4=E4=BF=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 在安全节点交回设备,统一调度日常任务、具名派修和原轮次续战。 短修入浴,长修先换健康舰;确认缺员、舰名和伤情后才快修。 --- autowsgr/ops/decisive/base.py | 31 +- autowsgr/ops/decisive/chapter.py | 8 +- autowsgr/ops/decisive/controller.py | 342 +++++++++-- autowsgr/ops/decisive/handlers.py | 466 ++++++++++----- autowsgr/ops/decisive/logic.py | 211 +++---- autowsgr/ops/decisive/repair.py | 659 +++++++++++++++++++++ autowsgr/ops/decisive/state.py | 7 + autowsgr/scheduler/daily_plan.py | 28 +- autowsgr/scheduler/decisive.py | 107 ++++ autowsgr/scheduler/scheduler.py | 140 +++-- autowsgr/scheduler/triggers.py | 24 +- autowsgr/server/routes/task.py | 2 + testing/ops/test_decisive_lifecycle.py | 333 ++++++++++- testing/ops/test_decisive_node_handoff.py | 178 ++++++ testing/ops/test_decisive_purchases.py | 308 +++++++++- testing/ops/test_decisive_quote_retries.py | 97 +++ testing/ops/test_decisive_repair.py | 646 ++++++++++++++++++++ testing/ops/test_decisive_tracking.py | 32 + testing/ops/test_scheduler_unit.py | 246 ++++++++ testing/server/test_task_routes.py | 39 +- testing/tools/test_decisive_collection.py | 19 +- 21 files changed, 3509 insertions(+), 414 deletions(-) create mode 100644 autowsgr/ops/decisive/repair.py create mode 100644 autowsgr/scheduler/decisive.py create mode 100644 testing/ops/test_decisive_node_handoff.py create mode 100644 testing/ops/test_decisive_quote_retries.py create mode 100644 testing/ops/test_decisive_repair.py diff --git a/autowsgr/ops/decisive/base.py b/autowsgr/ops/decisive/base.py index b544de329..6f766acc1 100644 --- a/autowsgr/ops/decisive/base.py +++ b/autowsgr/ops/decisive/base.py @@ -12,6 +12,7 @@ from autowsgr.constants import DECISIVE_SKILL_NAMES, update_shipnames from autowsgr.infra import DecisiveConfig, get_logger from autowsgr.ops.decisive.logic import DecisiveLogic +from autowsgr.ops.decisive.repair import DecisiveRepairCoordinator from autowsgr.ops.decisive.state import DecisiveState from autowsgr.ops.decisive.tracking import DecisiveTrackingSession from autowsgr.ui.decisive import DecisiveBattlePage, DecisiveMapController @@ -19,6 +20,10 @@ if TYPE_CHECKING: from autowsgr.context import GameContext + from autowsgr.infra import UserConfig + from autowsgr.ops.decisive.repair import RepairOutcome + from autowsgr.scheduler import TaskScheduler + from autowsgr.types import DecisivePhase _log = get_logger('ops.decisive') @@ -35,7 +40,7 @@ class DecisiveBase: _logic 纯决策模块 (DecisiveLogic) _battle_page 决战总览页 UI _map 决战地图页 UI - _inventory_refresh_required 编队和完整库存是否需要重新核实 + _inventory_refresh_required 是否需要重新确认编队及首屏可选舰船 _has_chosen_fleet 是否已经历过战备舰队获取 _wait_deadline 等待超时截止时间 _use_last_fleet_attempts 使用上次舰队尝试次数 @@ -48,20 +53,24 @@ class DecisiveBase: └── DecisiveController(DecisivePhaseHandlers, DecisiveChapterOps) """ + _scheduler: TaskScheduler | None = None + _resume_outcome: RepairOutcome | None = None + _failures: int = 0 + def __init__( self, ctx: GameContext, config: DecisiveConfig, + *, + user_config: UserConfig | None = None, ) -> None: self._ctx = ctx self._ctrl = ctx.ctrl self._ocr = ctx.ocr # 合并配置:传入的 config 覆盖 ctx.config,未指定的字段使用 ctx.config 的值 - base = ( - ctx.config.decisive_battle.model_dump() - if ctx.config.decisive_battle is not None - else {} - ) + settings = user_config if user_config is not None else ctx.config + self._settings = settings + base = settings.decisive_battle.model_dump() if settings.decisive_battle is not None else {} merged_config_dict = { **base, **config.model_dump(exclude_unset=True), @@ -77,7 +86,15 @@ def __init__( update_shipnames(merged_config.level1 + merged_config.level2 + DECISIVE_SKILL_NAMES) self._state = DecisiveState(chapter=merged_config.chapter) - self._logic = DecisiveLogic(merged_config, self._state, ctx=ctx) + self._repairs = DecisiveRepairCoordinator(ctx, merged_config, user_config=settings) + self._scheduled_repair: RepairOutcome | None = None + self._after_settlement: DecisivePhase | None = None + self._logic = DecisiveLogic( + merged_config, + self._state, + ctx=ctx, + prefer_healthy=settings.quick_repair_threshold_seconds is not None, + ) self._battle_page = DecisiveBattlePage(self._ctx, ocr=self._ocr) self._map = DecisiveMapController( ctx, diff --git a/autowsgr/ops/decisive/chapter.py b/autowsgr/ops/decisive/chapter.py index 469b0be07..52343ab7b 100644 --- a/autowsgr/ops/decisive/chapter.py +++ b/autowsgr/ops/decisive/chapter.py @@ -10,6 +10,7 @@ from autowsgr.infra.logger import get_logger from autowsgr.ops.decisive.base import DecisiveBase from autowsgr.types import PageName +from autowsgr.ui.utils.navigation import check_stop _log = get_logger('ops.decisive') @@ -27,7 +28,10 @@ def _prepare_entry_state(self) -> None: """进入决战总览并推断入口状态。""" from autowsgr.ops.navigate import goto_page + check_stop(self._ctx.stop_event) goto_page(self._ctx, PageName.DECISIVE_BATTLE) + if self._state.expected_stage is not None: + return self._battle_page.navigate_to_chapter(self._config.chapter) def _do_dock_full_destroy(self) -> None: @@ -36,8 +40,8 @@ def _do_dock_full_destroy(self) -> None: from autowsgr.ops.destroy import destroy_ships_auto _log.warning('[决战] 船坞已满,执行自动解装') - self._ctrl.click(0.38, 0.565) - if not destroy_ships_auto(self._ctx): + check_stop(self._ctx.stop_event) + if not destroy_ships_auto(self._ctx, from_dialog=True): # 保留舰种覆盖全部舰种, 无可解装对象, 船坞仍满 raise DockFullError('决战中船坞已满,且无可解装舰种') return diff --git a/autowsgr/ops/decisive/controller.py b/autowsgr/ops/decisive/controller.py index a4ac74b19..472154aca 100644 --- a/autowsgr/ops/decisive/controller.py +++ b/autowsgr/ops/decisive/controller.py @@ -24,11 +24,20 @@ from __future__ import annotations import enum +from dataclasses import replace +from typing import TYPE_CHECKING +from autowsgr.infra import ActionFailedError, DockFullError from autowsgr.infra.logger import get_logger from autowsgr.ops.decisive.chapter import DecisiveChapterOps from autowsgr.ops.decisive.handlers import DecisivePhaseHandlers -from autowsgr.types import DecisivePhase +from autowsgr.ops.decisive.repair import RepairOutcome, RepairStatus +from autowsgr.types import DecisiveEntryStatus, DecisivePhase, ShipDamageState +from autowsgr.ui.decisive import DecisiveBattlePreparationPage + + +if TYPE_CHECKING: + from autowsgr.ui.decisive.preparation import RepairSnapshot _log = get_logger('ops.decisive') @@ -39,7 +48,10 @@ class DecisiveResult(enum.Enum): - """决战单轮的最终结局。""" + """单轮结果。NODE_COMPLETE 和 RETRY 只在调度器内部流转。""" + + NODE_COMPLETE = 'node_complete' + RETRY = 'retry' CHAPTER_CLEAR = 'chapter_clear' """大关通关 (3 个小关全部完成)。""" @@ -86,19 +98,183 @@ def run(self) -> DecisiveResult: # 进入已有进度和重新开局都需要核实库存,确定 A 不能代替库存观察。 self._inventory_refresh_required = True self._has_chosen_fleet = False - self._prepare_entry_state() - self._state.phase = DecisivePhase.ENTER_MAP + self._repairs.reset_stage() + self._scheduled_repair = None + self._after_settlement = None + self._map.reset_settlement() + self._resume_outcome = None + self._failures = 0 try: return self._main_loop() except Exception: if self._ctx.stop_event.is_set(): return DecisiveResult.STOPPED - _log.exception('[决战] 执行异常') - self._state.phase = DecisivePhase.FINISHED + _log.exception('[决战] 调度中断,保留当前进度') + self._log_failure_screen(1) return DecisiveResult.ERROR finally: self._close_tracking() + def _resume_interrupted_sortie(self) -> bool: + """冷启动时先检查进度现场。暂离后只允许进入同一章节的存档。""" + try: + if not self._map.try_leave_interrupted_sortie(): + return False + status, screen = self._battle_page.wait_for_entry_status() + chapter = self._config.chapter + if ( + status not in (DecisiveEntryStatus.CHALLENGING, DecisiveEntryStatus.REFRESHED) + or self._battle_page._read_chapter(screen) != chapter + ): + raise ActionFailedError('恢复决战', '暂离后未确认目标章节的存档入口') + stage = self._battle_page.detect_stage(screen, chapter) + self._enter_verified_stage(stage) + _log.info('[决战] 已从中断现场暂离,继续第 {} 章第 {} 小关', chapter, stage) + except (ActionFailedError, InterruptedError): + raise + except Exception as exc: + # 返回或暂离可能已经生效,不能从新画面按普通入口重试或重置章节。 + raise ActionFailedError('恢复决战', str(exc)) from exc + return True + + def _log_failure_screen(self, attempt: int) -> None: + """只在识别或操作失败时保存现场,方便按日志还原问题。""" + from autowsgr.infra.logger import save_image + + log_dir = self._ctx.config.log.dir + if log_dir: + try: + save_image(self._ctrl.screenshot(), f'decisive-error-{attempt}', log_dir / 'images') + except Exception as exc: + _log.warning('[决战] 保存异常现场失败:{}', exc) + + def _recover_phase(self) -> None: + """重试时按当前页面继续;已进入战果、通关结算或等待维修的,接着处理原步骤。""" + phase = self._state.phase + self._inventory_refresh_required = True + if phase in {DecisivePhase.NODE_RESULT, DecisivePhase.STAGE_CLEAR}: + return + if phase in (DecisivePhase.INIT, DecisivePhase.WAITING_FOR_REPAIR): + return + if self._state.navigate_to_entry: + return + if phase in {DecisivePhase.IN_COMBAT, DecisivePhase.RETREAT, DecisivePhase.LEAVE}: + raise ActionFailedError('无法确认战斗或退出操作是否生效,保留现场') + screen = self._ctrl.capture_frame().image + if self._battle_page.is_current_page(screen): + self._state.phase = DecisivePhase.ENTER_MAP + return + if self._map.is_fleet_preparation(screen): + page = DecisiveBattlePreparationPage(self._ctx, self._config, self._ocr) + page.go_back() + observed = self._map.detect_decisive_phase() + if observed is None: + raise RuntimeError('异常恢复未能确认当前决战页面') + self._state.phase = observed + + def _repair_snapshot( + self, page: DecisiveBattlePreparationPage, *, fresh: bool = False + ) -> RepairSnapshot: + target = self._state.fleet.copy() + return self._repairs.read_complete_snapshot( + page, + expected=target[1:], + fresh=fresh, + recheck_fleet=lambda: self._verify_prepared_fleet(page, target, force_change=True), + ) + + def _observe_repairs( + self, page: DecisiveBattlePreparationPage, snapshot: RepairSnapshot | None = None + ) -> RepairSnapshot: + if snapshot is None: + snapshot = self._repairs.read_complete_snapshot( + page, fresh=bool(self._repairs.due_identities) + ) + names, damage = snapshot + self._repairs.observe_inventory( + self._state.ships, + chapter=self._state.chapter, + stage=self._state.stage, + damage={name: damage[i] for i, name in enumerate(names) if name}, + ) + self._state.fleet = [''] + [name or '' for name in names] + self._state.ship_stats = [damage[i] for i in range(6)] + return names, damage + + def _leave_for_repairs(self, page: DecisiveBattlePreparationPage | None) -> None: + self._repairs.save_progress(page, self._map) + self._state.expected_stage = self._state.stage + self._state.at_node_boundary = False + self._state.node_completed = False + self._route_repair(RepairOutcome(RepairStatus.NEEDS_BATH)) + + def _prepare_repairs( + self, page: DecisiveBattlePreparationPage, snapshot: RepairSnapshot | None = None + ) -> bool: + names, damage = snapshot if snapshot is not None else self._repair_snapshot(page) + target = self._state.fleet.copy() + result = self._repairs.prepare( + page, + fleet=names, + damage=damage, + acquired=self._state.ships, + chapter=self._state.chapter, + stage=self._state.stage, + recheck_fleet=lambda: self._verify_prepared_fleet(page, target, force_change=True), + ) + if result.status is RepairStatus.READY: + if result.snapshot is not None: + names, damage = result.snapshot + if any( + i not in damage + or (damage[i] is ShipDamageState.NO_SHIP) != (not name) + or damage[i] >= self._config.repair_level + for i, name in enumerate(names) + ): + raise RuntimeError('决战出征前未确认全部舰位可用') + self._state.ship_stats = [ + damage[i] if name else ShipDamageState.NO_SHIP for i, name in enumerate(names) + ] + self._sync_ship_states() + return True + if result.status is RepairStatus.NEEDS_BATH: + self._leave_for_repairs(page) + else: + self._route_repair(result) + return False + + def _route_repair(self, result: RepairOutcome) -> None: + if result.status is RepairStatus.STOPPED or self._ctx.stop_event.is_set(): + self._state.phase = DecisivePhase.FINISHED + elif result.status is RepairStatus.REENTER: + if self._after_settlement is not None: + phase = self._after_settlement + self._repairs.reset_stage() + self._after_settlement = None + self._state.phase = phase + else: + self._state.phase = DecisivePhase.ENTER_MAP + self._state.expected_stage = self._state.stage + self._state.navigate_to_entry = self._state.phase is DecisivePhase.ENTER_MAP + self._inventory_refresh_required = True + elif result.status in (RepairStatus.WAITING, RepairStatus.NEEDS_BATH): + self._scheduled_repair = replace( + result, resume_immediately=self._repairs.can_continue_without_pending + ) + self._state.phase = DecisivePhase.WAITING_FOR_REPAIR + else: + ships = '、'.join(result.targets) + action = f'复核待修舰船({ships})' if ships else '复核决战编队' + raise ActionFailedError(action, result.detail) + + def _next_repair(self) -> RepairOutcome: + """先执行本次暂离请求;后续复查按各舰船的到期时间安排。""" + if self._scheduled_repair is not None: + result = self._scheduled_repair + self._scheduled_repair = None + return result + return self._repairs.poll() + def run_for_times(self, times: int = 1) -> list[DecisiveResult]: """执行多轮决战;未完成一轮时停止,不重新开始或清空进度。""" results: list[DecisiveResult] = [] @@ -114,7 +290,101 @@ def run_for_times(self, times: int = 1) -> list[DecisiveResult]: # ── 主循环 ──────────────────────────────────────────────────────────── def _main_loop(self) -> DecisiveResult: - """决战主状态机循环。""" + """同一控制器的多轮决战共用日常触发器和就绪队列。""" + from autowsgr.scheduler import TaskScheduler + + if self._scheduler is None: + self._scheduler = TaskScheduler.for_decisive(self._ctx, user_config=self._settings) + return self._scheduler.run_decisive( + self._advance_node, + self._next_repair, + self._repairs.dispatch_pending, + self._resume_from_queue, + park=self._park_for_daily, + ) + + def _resume_from_queue(self, outcome: RepairOutcome) -> None: + self._resume_outcome = outcome + + def _park_for_daily(self) -> bool: + """只有总览或已核实的节点地图能把页面交给其他任务。""" + phase = self._state.phase + if self._failures: + return False + if phase is DecisivePhase.INIT: + from autowsgr.ui.main_page import MainPage + + screen = self._ctrl.screenshot() + return bool( + self._battle_page.is_current_page(screen) or MainPage.is_current_page(screen) + ) + if phase is DecisivePhase.WAITING_FOR_REPAIR: + return self._repairs.saved + if phase is DecisivePhase.ENTER_MAP: + self._state.navigate_to_entry = True + return True + if not self._state.at_node_boundary: + return False + self._map.leave_to_overview() + self._state.expected_stage = self._state.stage + self._state.at_node_boundary = False + self._state.navigate_to_entry = True + self._state.phase = DecisivePhase.ENTER_MAP + self._inventory_refresh_required = True + _log.info( + '[决战] 已在 {}-{}-{} 暂离,先处理排在前面的任务', + self._state.chapter, + self._state.stage, + self._state.node, + ) + return True + + def _advance_node(self) -> DecisiveResult | None: + """从实际页面续行,连续三次未能恢复就保留现场。""" + try: + if self._failures: + self._recover_phase() + if self._state.phase is DecisivePhase.INIT and not self._resume_interrupted_sortie(): + self._prepare_entry_state() + self._state.phase = DecisivePhase.ENTER_MAP + if self._resume_outcome is not None: + outcome, self._resume_outcome = self._resume_outcome, None + self._route_repair(outcome) + if self._state.navigate_to_entry: + self._prepare_entry_state() + self._state.navigate_to_entry = False + if self._tracking is not None: + self._tracking.request_node_sample('暂离后重新核实当前节点') + result = self._advance_until_repair() + except Exception as exc: + if self._ctx.stop_event.is_set(): + return DecisiveResult.STOPPED + self._failures += 1 + self._state.at_node_boundary = False + _log.exception('[决战] 第 {}/3 次尝试失败,保留当前节点', self._failures) + self._log_failure_screen(self._failures) + if self._failures == 3 or isinstance(exc, (ActionFailedError, DockFullError)): + return DecisiveResult.ERROR + return DecisiveResult.RETRY + self._failures = 0 + return result + + def _finish_node(self) -> bool: + """已结算的战斗,等到下一节点地图或小关总览再交回队列。""" + if self._state.phase is DecisivePhase.PREPARE_COMBAT: + if not self._prepare_map_tracking(): + return False + if self._repairs.needs_dispatch: + self._leave_for_repairs(None) + return False + self._state.at_node_boundary = True + elif self._state.phase is not DecisivePhase.ENTER_MAP: + return False + self._state.node_completed = False + return True + + def _advance_until_repair(self) -> DecisiveResult | None: + """最多打一个节点,处理完战备、选路和奖励后交回调度器。""" _handlers = { DecisivePhase.ENTER_MAP: self._handle_enter_map, DecisivePhase.WAITING_FOR_MAP: self._handle_waiting_for_map, @@ -128,11 +398,15 @@ def _main_loop(self) -> DecisiveResult: DecisivePhase.STAGE_CLEAR: self._handle_stage_clear, } - while self._state.phase != DecisivePhase.FINISHED: - if self._ctx.stop_event.is_set(): - self._close_tracking() - return DecisiveResult.STOPPED + while not self._ctx.stop_event.is_set(): phase = self._state.phase + if phase is DecisivePhase.WAITING_FOR_REPAIR: + return None + if self._state.node_completed: + if self._finish_node(): + return DecisiveResult.NODE_COMPLETE + if self._state.phase is not phase: + continue # WAITING_FOR_MAP 太频繁,只在非等待阶段打日志 if phase != DecisivePhase.WAITING_FOR_MAP: @@ -143,32 +417,28 @@ def _main_loop(self) -> DecisiveResult: self._state.node, ) - if phase == DecisivePhase.CHAPTER_CLEAR: - _log.info('[决战] 大关通关!') - self._state.phase = DecisivePhase.FINISHED - return DecisiveResult.CHAPTER_CLEAR - - if phase == DecisivePhase.RETREAT: - self._execute_retreat() - self._state.reset() - self._state.phase = DecisivePhase.ENTER_MAP - continue - - if phase == DecisivePhase.LEAVE: - self._execute_leave() - self._state.phase = DecisivePhase.FINISHED - return DecisiveResult.LEAVE - handler = _handlers.get(phase) if handler is None: - _log.error('[决战] 未知阶段: {}', phase) - self._state.phase = DecisivePhase.FINISHED - return DecisiveResult.ERROR - + return self._finish_attempt(phase) handler() - if self._ctx.stop_event.is_set(): - self._close_tracking() - return DecisiveResult.STOPPED - self._close_tracking() - return DecisiveResult.ERROR + return DecisiveResult.STOPPED + + def _finish_attempt(self, phase: DecisivePhase) -> DecisiveResult: + if phase is DecisivePhase.RETREAT: + self._execute_retreat() + self._repairs.reset_stage() + self._state.reset() + self._state.phase = DecisivePhase.ENTER_MAP + return DecisiveResult.NODE_COMPLETE + if phase is DecisivePhase.LEAVE: + self._execute_leave() + result = DecisiveResult.LEAVE + elif phase is DecisivePhase.CHAPTER_CLEAR: + _log.info('[决战] 大关通关!') + result = DecisiveResult.CHAPTER_CLEAR + else: + _log.error('[决战] 无法继续,当前阶段为 {}', phase) + result = DecisiveResult.ERROR + self._state.phase = DecisivePhase.FINISHED + return result diff --git a/autowsgr/ops/decisive/handlers.py b/autowsgr/ops/decisive/handlers.py index 4e0865073..8172f524b 100644 --- a/autowsgr/ops/decisive/handlers.py +++ b/autowsgr/ops/decisive/handlers.py @@ -17,13 +17,13 @@ import time from typing import TYPE_CHECKING -import cv2 - from autowsgr.combat.engine import run_combat from autowsgr.combat.plan import CombatMode, CombatPlan, NodeDecision -from autowsgr.constants import ship_name_identity +from autowsgr.constants import DECISIVE_SKILL_NAMES, ship_name_identity from autowsgr.infra.logger import get_logger from autowsgr.ops.decisive.base import DecisiveBase +from autowsgr.ops.decisive.config import MapData +from autowsgr.ops.decisive.repair import RepairOutcome, RepairStatus from autowsgr.types import ( ConditionFlag, DecisiveEntryStatus, @@ -32,8 +32,9 @@ Formation, ShipDamageState, ) -from autowsgr.ui import RepairStrategy from autowsgr.ui.decisive import DecisiveBattlePreparationPage +from autowsgr.ui.decisive.battle_page import ResetConfirmationTimeoutError +from autowsgr.ui.utils.navigation import check_stop if TYPE_CHECKING: @@ -41,6 +42,8 @@ from autowsgr.combat.history import CombatResult from autowsgr.emulator.frame import CapturedFrame + from autowsgr.ops.decisive.tracking import DecisiveTrackingSession + from autowsgr.ui.decisive.preparation import RepairSnapshot _log = get_logger('ops.decisive') @@ -89,62 +92,82 @@ def _sync_ship_states(self) -> None: self._ctx.update_ship_damage(name, stat) def _refresh_inventory(self) -> None: - """只发布完整、已返回地图的库存;扫描异常或停止时保留原业务快照。""" + """返回地图后更新当前编队及选船列表首屏读到的舰船。""" self._inventory_refresh_required = True if self._ctx.stop_event.is_set(): raise InterruptedError('核实决战库存前收到停止请求') - fleet, damage, all_ships = self._map.check_fleet() + + def observe_repairing(name: str) -> None: + # 扫描库存可能耗时,从首次读到在修标记起计时;到期复核使用准备页新帧。 + if ship_name_identity(name) not in self._repairs.due_identities: + self._repairs.observe_inventory( + [name], + chapter=self._state.chapter, + stage=self._state.stage, + damage={name: ShipDamageState.REPAIRING}, + ) + + fleet, damage, all_ships = self._map.check_fleet(observe_repairing) if len(fleet) != 6 or any( name is not None and (not isinstance(name, str) or not name) for name in fleet ): - raise ValueError('决战库存扫描未提供完整六槽编队') + raise ValueError('未能识别当前编队的全部舰船名称') ships = set(all_ships) if any(not isinstance(name, str) or not name for name in ships) or not { name for name in fleet if name }.issubset(ships): - raise ValueError('决战完整库存与当前编队不一致') + raise ValueError('可选舰船记录与当前编队不一致') + if any( + name and damage.get(slot) in (None, ShipDamageState.NO_SHIP) + for slot, name in enumerate(fleet) + ): + raise ValueError('未能确认当前编队中全部舰船的损伤状态') + # 首屏可能看不到上次确认的候补;本小关已实见的舰船仍可参与编队。 + ships.update(self._repairs.acquired) new_fleet = [''] + [name or '' for name in fleet] stats = [ - damage.get(slot, ShipDamageState.NORMAL) if name else ShipDamageState.NO_SHIP - for slot, name in enumerate(fleet) + damage[slot] if name else ShipDamageState.NO_SHIP for slot, name in enumerate(fleet) ] if self._ctx.stop_event.is_set(): - raise InterruptedError('核实决战库存时收到停止请求,保留原快照') + raise InterruptedError('核对已获得的决战舰船时收到停止请求,保留上次的编队和舰船记录') previous = self._state.ships, self._state.fleet, self._state.ship_stats self._state.ships, self._state.fleet, self._state.ship_stats = ships, new_fleet, stats try: self._sync_ship_states() + self._repairs.observe_inventory( + ships, + chapter=self._state.chapter, + stage=self._state.stage, + damage={ + name: stats[i] + for i, name in enumerate(fleet) + if name and ship_name_identity(name) not in self._repairs.due_identities + }, + ) except Exception: self._state.ships, self._state.fleet, self._state.ship_stats = previous raise self._inventory_refresh_required = False def _verify_prepared_fleet( - self, page: DecisiveBattlePreparationPage, target: list[str] - ) -> None: - """换船返回成功还须独立核对六槽身份和占用状态,确认后才发布编队。""" + self, page: DecisiveBattlePreparationPage, target: list[str], *, force_change: bool = False + ) -> RepairSnapshot: + """换船后从新画面核对整队舰名、顺序和血量。""" self._inventory_refresh_required = True if self._ctx.stop_event.is_set(): raise InterruptedError('更换决战编队前收到停止请求') - if self._state.fleet != target and not page.change_fleet(None, target[1:]): + changed = force_change or self._state.fleet != target + if changed and not page.change_fleet(None, target[1:]): raise RuntimeError('决战编队更换未成功,停止并保留现场') - snapshot = page.detect_fleet_snapshot() - if ( - len(snapshot.names) != 6 - or len(snapshot.occupied) != 6 - or any( - occupied != bool(expected) - or ship_name_identity(actual) != ship_name_identity(expected) - for actual, occupied, expected in zip( - snapshot.names, snapshot.occupied, target[1:], strict=True - ) - ) - ): - raise RuntimeError('决战实际编队与目标六槽不一致,停止并保留现场') + snapshot = self._repairs.read_complete_snapshot(page, fresh=True) + names, _ = snapshot + if list(map(ship_name_identity, names)) != list(map(ship_name_identity, target[1:])): + raise RuntimeError('换船后未能确认实际编队中的舰船名称和顺序') if self._ctx.stop_event.is_set(): raise InterruptedError('核实决战编队时收到停止请求') - self._state.fleet = [''] + [name or '' for name in snapshot.names] + self._state.fleet = [''] + [name or '' for name in names] self._inventory_refresh_required = False + return snapshot """决战阶段处理器子类。 @@ -184,13 +207,33 @@ def _handle_enter_map(self) -> None: - ``CHALLENGING``: 挑战中,直接进入地图 - ``CANT_FIGHT``: 无法出击,抛出异常 """ + check_stop(self._ctx.stop_event) + expected = self._state.expected_stage + if expected is not None: + self._repairs.validate_stage(self._battle_page, self._state.chapter, expected) + _log.info( + '[决战] 已在总览确认第 {} 章第 {} 小关的进度,准备进入地图', + self._state.chapter, + expected, + ) + self._enter_verified_stage(expected) + return entry_status = self._battle_page.detect_entry_status() did_reset = False if entry_status == DecisiveEntryStatus.REFRESH: _log.info('[决战] 检测到「重置关卡」状态,执行章节重置') self._inventory_refresh_required = True - reset_success = self._battle_page.reset_chapter() + try: + reset_success = self._battle_page.reset_chapter(self._config.chapter) + except ResetConfirmationTimeoutError: + # 磁盘可能已消耗,下一次调度只能核实同一章第一小关。 + self._state.expected_stage = 1 + self._close_tracking() + self._repairs.reset_stage() + self._has_chosen_fleet = False + self._known_start_stage = 1 + raise if not reset_success: # 重置不成功是因为需要解装 self._state.phase = DecisivePhase.DOCK_FULL @@ -205,73 +248,64 @@ def _handle_enter_map(self) -> None: f'决战 Ex-{self._config.chapter}: 入口状态为「无法出击」,其他关卡正在进行中' ) - _log.info('[决战] 入口状态: {}', entry_status.value) - - self._state.stage = self._detect_entry_stage() + stage = self._detect_entry_stage() + _log.info( + '[决战] 第 {} 章第 {} 小关,{}', + self._config.chapter, + stage, + '已重置,从头开始' if did_reset else '从当前进度进入', + ) if did_reset: - if entry_status == DecisiveEntryStatus.REFRESH or self._state.stage != 1: + if entry_status == DecisiveEntryStatus.REFRESH or stage != 1: raise RuntimeError('重置后未确认第一小关入口,拒绝假定 A 起点') + self._repairs.reset_stage() + self._has_chosen_fleet = False self._known_start_stage = 1 - self._battle_page.click_enter_map() + self._enter_verified_stage(stage) + + def _enter_verified_stage(self, stage: int) -> None: + if stage not in (1, 2, 3): + raise RuntimeError(f'决战 Ex-{self._config.chapter} 未识别有效小节') + if self._state.stage != stage: + # 下一张图的战备窗口可能先于库存检查出现,不能拿上一张图的舰船做购买决策。 + self._state.ships.clear() + self._state.fleet = [''] * 7 + self._state.ship_stats = [ShipDamageState.NO_SHIP] * 6 + self._state.stage = stage + branches = None + if self._known_start_stage == stage: + branches = len(MapData.get_leftmost_choices(self._config.chapter, stage, '0')) + if self._tracking is None or self._tracking.stage != stage: + self._map.configure_route(branches) + check_stop(self._ctx.stop_event) self._use_last_fleet_attempts = 0 self._wait_deadline = time.monotonic() + 15.0 self._state.phase = DecisivePhase.WAITING_FOR_MAP + self._battle_page.click_enter_map() def _handle_waiting_for_map(self) -> None: - """等待地图页加载: 单次截图检测 → 转到对应阶段或继续等待。""" - screen = self._ctrl.screenshot() - phase = self._map.detect_decisive_phase(screen) - - # Ex-1 首次进入第 1 小节时,理论上应先经历一次战备舰队获取。 - # 若此时尚未进入过 CHOOSE_FLEET,却稳定识别成 PREPARE_COMBAT, - # 则将其视为购买界面漏判并自动修正到 CHOOSE_FLEET。 - # 注意:暂离后重进时 node='U',此时舰标已在地图上,不应修正到 CHOOSE_FLEET - if ( - phase == DecisivePhase.PREPARE_COMBAT - and self._state.stage == 1 - and not self._has_chosen_fleet - ): - if self._state.node != 'U': - _log.warning('[决战] 首进第 1 小节将 PREPARE_COMBAT 修正为 CHOOSE_FLEET') - self._state.phase = DecisivePhase.CHOOSE_FLEET - return - # node == 'U' 时,通过舰标检测区分暂离重进与 overlay 延迟加载 - bgr = cv2.cvtColor(screen, cv2.COLOR_RGB2BGR) - icon_x = self._map._locate_ship_icon(bgr) - if icon_x is None: - _log.warning( - '[决战] 首进第 1 小节未检测到舰标,将 PREPARE_COMBAT 修正为 CHOOSE_FLEET' - ) - self._state.phase = DecisivePhase.CHOOSE_FLEET - return - - if phase is not None: - self._state.phase = phase - - # 未检测到已知状态 — 重试或超时 - if time.monotonic() >= self._wait_deadline: - raise TimeoutError('等待地图页或 overlay 超时') - time.sleep(0.05) + """按新帧确认入口浮窗或稳定的地图,消费过的上次舰队弹窗只能遮挡地图。""" + remaining = self._wait_deadline - time.monotonic() + if remaining <= 0: + raise TimeoutError('等待地图页或浮窗 超时') + self._state.phase = self._map.wait_for_entry_phase( + timeout=remaining, + wait_for_use_last=self._use_last_fleet_attempts == 0, + ) def _handle_use_last_fleet(self) -> None: """点击「使用上次舰队」按钮 → 转到 WAITING_FOR_MAP。""" - self._use_last_fleet_attempts += 1 - if self._use_last_fleet_attempts > 5: - raise TimeoutError('选择决战舰船失败 (超过 5 次尝试)') - - _log.info( - '[决战] 「使用上次舰队」第 {} 次尝试', - self._use_last_fleet_attempts, - ) + check_stop(self._ctx.stop_event) self._map.click_use_last_fleet() + self._use_last_fleet_attempts = 1 self._wait_deadline = time.monotonic() + 10.0 self._state.phase = DecisivePhase.WAITING_FOR_MAP def _handle_dock_full(self) -> None: """船坞已满: 自动解装 → ENTER_MAP。""" _log.warning('[决战] 处理船坞已满') - self._do_dock_full_destroy() # type: ignore[attr-defined] # from DecisiveChapterOps - self._prepare_entry_state() # type: ignore[attr-defined] # from DecisiveChapterOps + self._do_dock_full_destroy() # type: ignore[attr-defined] + self._prepare_entry_state() # type: ignore[attr-defined] self._state.phase = DecisivePhase.ENTER_MAP # ── 舰队与地图 ──────────────────────────────────────────────────────── @@ -286,17 +320,20 @@ def _handle_choose_fleet(self) -> None: ) self._state.score = score + self._inventory_refresh_required = True + attempted: set[str] = set() if selections: first_node = self._state.is_begin() if first_node: last_name = self._map.detect_last_offer_name(screen) - if last_name in {'长跑训练', '肌肉记忆', '黑科技'}: + if last_name in DECISIVE_SKILL_NAMES: _log.info('[决战] 首节点判定修正: 最后一项为技能') first_node = False to_buy = self._logic.choose_ships(selections, first_node=first_node) if not to_buy: + check_stop(self._ctx.stop_event) self._map.refresh_fleet() screen, score, selections = self._recognize_fleet_options_with_retry( fallback_score=self._state.score, @@ -310,28 +347,46 @@ def _handle_choose_fleet(self) -> None: _log.info('[决战] 选择购买: {}', to_buy) for name in to_buy: sel = selections[name] - self._inventory_refresh_required = True + check_stop(self._ctx.stop_event) + attempted.add(name) self._map.buy_fleet_option(sel.click_position) # 点击不代表购买成功(费用 OCR 错误、余额不足或点击被动画吞掉)。 # 包括免费卡和技能卡在内,都复用准备阶段的真实库存扫描确认结果。 # 不把未经确认的卡片名称加入库存,否则后续编队会寻找不存在的舰船。 - self._state.phase = DecisivePhase.PREPARE_COMBAT + check_stop(self._ctx.stop_event) + if self._map.close_fleet_overlay(): + self._state.phase = DecisivePhase.PREPARE_COMBAT + return + + # 重新读取卡面和余额,避免按旧截图购买已经消费的卡或超支。 + _, score, remaining = self._recognize_fleet_options_with_retry(fallback_score=0) + self._state.score = score + affordable = [ + offer + for name, offer in remaining.items() + if name + and not name.startswith('未识别_') + and name not in attempted + and name not in DECISIVE_SKILL_NAMES + and 0 <= offer.cost <= score + ] + if not affordable: + raise RuntimeError('决战选船界面无法关闭,也没有可支付的非技能舰卡') + fallback = min(affordable, key=lambda offer: offer.cost) + check_stop(self._ctx.stop_event) + self._map.buy_fleet_option(fallback.click_position) + check_stop(self._ctx.stop_event) if not self._map.close_fleet_overlay(): - _log.info('[决战] 关闭决战选船界面失败, 选择第一艘后撤退') - self._state.phase = DecisivePhase.RETREAT - _, first_value = next(iter(selections.items())) - self._inventory_refresh_required = True - self._map.buy_fleet_option(first_value.click_position) - if not self._map.close_fleet_overlay(): - raise RuntimeError('关闭决战选船界面失败') + raise RuntimeError('决战选船界面在购买最低费舰卡后仍未关闭') + self._state.phase = DecisivePhase.RETREAT def _handle_advance_choice(self) -> None: """选择前进点。""" _log.info('[决战] 选择前进点') - choice_idx = self._logic.get_advance_choice([]) - self._map.select_advance_card(choice_idx) - self._state.phase = DecisivePhase.CHOOSE_FLEET + self._map.select_advance_card(0) + self._wait_deadline = time.monotonic() + 10.0 + self._state.phase = DecisivePhase.WAITING_FOR_MAP # ── 战斗 ────────────────────────────────────────────────────────────── @@ -339,12 +394,11 @@ def _prepare_map_tracking(self) -> bool: """准备前确认稳定地图;延迟出现的弹窗交回状态机处理。""" screen = self._ctrl.screenshot() - # 某些情况下地图页识别会先于 overlay 稳定,导致实际上仍停留在 + # 某些情况下地图页识别会先于浮窗稳定,导致实际上仍停留在 # 「战备舰队获取 / 前进点选择」时就误入 PREPARE_COMBAT。 # 这里补一次即时探测,优先回到正确阶段,避免后续直接点“编队”超时。 overlay_phase = self._map.detect_decisive_phase(screen) if overlay_phase in (DecisivePhase.CHOOSE_FLEET, DecisivePhase.ADVANCE_CHOICE): - _log.info('[决战] 出征准备前检测到 overlay,切回阶段: {}', overlay_phase.name) self._state.phase = overlay_phase return False @@ -366,17 +420,43 @@ def _prepare_map_tracking(self) -> bool: def _handle_prepare_combat(self) -> None: """出征准备:编队 → 修理 → 出征。""" - if self._ctx.stop_event.is_set(): - self._state.phase = DecisivePhase.FINISHED - return - if not self._prepare_map_tracking(): + check_stop(self._ctx.stop_event) + if not self._state.at_node_boundary and not self._prepare_map_tracking(): return + self._state.at_node_boundary = False _log.info( '[决战] 出征准备 (小关 {} 节点 {})', self._state.stage, self._state.node, ) + if not self._prepare_node_supplies(): + return + # 缺船撤退依据实际拥有的主备舰数;在修造成的暂时缺员交给维修协调器。 + if self._logic.should_retreat(self._logic.get_best_fleet()): + _log.info('[决战] 舰船不足, 准备撤退') + self._state.phase = DecisivePhase.RETREAT + return + self._map.enter_formation() + page = DecisiveBattlePreparationPage(self._ctx, self._config, self._ocr) + if not self._prepare_available_fleet(page): + return + + if self._ctx.stop_event.is_set(): + self._state.phase = DecisivePhase.FINISHED + return + self._battle_encounter_id = self._ensure_tracking().encounter_id + self._state.phase = DecisivePhase.IN_COMBAT + page.start_battle() + time.sleep(1.0) + + def _prepare_node_supplies(self) -> bool: + """使用本节点技能,处理首次战备浮窗并核实已获得的舰船。""" + # 战果页已核实的受伤舰,在确认地图可暂离后优先派修。 + if self._repairs.needs_dispatch: + self._leave_for_repairs(None) + return False + # 先使用技能,再注册舰船,如果是未知节点,也判定一下技能是否使用 current_node = self._state.node time.sleep(0.5) # 等待动画稳定后截图判定 @@ -390,6 +470,9 @@ def _handle_prepare_combat(self) -> None: and self._inventory_refresh_required ): self._refresh_inventory() + if self._repairs.needs_dispatch: + self._leave_for_repairs(None) + return False # 点击后可能实际获得舰船,即使结果 OCR 失败也必须重新核实。 self._inventory_refresh_required = True gained = self._map.use_skill() @@ -398,49 +481,69 @@ def _handle_prepare_combat(self) -> None: if gained and self._config.useful_skill and not self._logic.check_useful_skill(gained): _log.info('[决战] 技能获得: {}, 效果不佳,撤退重试', gained) self._state.phase = DecisivePhase.RETREAT - return + return False else: _log.debug('[决战] 跳过技能使用: 节点={}, 技能已使用={}', current_node, skill_used) - # 首次进入且尚未选择过舰队时,使用技能后可能出现战备舰队获取 overlay, - # 先切回 WAITING_FOR_MAP 等待 overlay 稳定,避免直接点击编队超时。 + # 首次进入且尚未选择过舰队时,使用技能后可能出现战备舰队获取浮窗, + # 先切回 WAITING_FOR_MAP 等待浮窗稳定,避免直接点击编队超时。 if not skill_used and not self._has_chosen_fleet: - _log.info('[决战] 首次进入,使用技能后等待 overlay 稳定') + _log.info('[决战] 首次进入,使用技能后等待浮窗稳定') self._wait_deadline = time.monotonic() + 10.0 self._state.phase = DecisivePhase.WAITING_FOR_MAP - return + return False if self._inventory_refresh_required: self._refresh_inventory() + if self._repairs.needs_dispatch: + self._leave_for_repairs(None) + return False + return True - best_fleet = self._logic.get_best_fleet() - if self._logic.should_retreat(best_fleet): - _log.info('[决战] 舰船不足, 准备撤退') - self._state.phase = DecisivePhase.RETREAT - return - - self._map.enter_formation() - time.sleep(0.5) # 等待编队页加载完成(对齐 check_fleet 的做法) - page = DecisiveBattlePreparationPage(self._ctx, self._config, self._ocr) - - self._verify_prepared_fleet(page, best_fleet) - - strategy = ( - RepairStrategy.MODERATE if self._config.repair_level <= 1 else RepairStrategy.SEVERE - ) - page.apply_repair(strategy, repair_manually=not self._config.use_quick_repair) - - screen = self._ctrl.screenshot() - damage = page.detect_ship_damage(screen) - self._state.ship_stats = [damage.get(i, ShipDamageState.NORMAL) for i in range(6)] - self._sync_ship_states() + def _prepare_available_fleet(self, page: DecisiveBattlePreparationPage) -> bool: + """检查主力和候补舰的伤情,选出本小关出征所需的舰船。""" + snapshot = self._observe_repairs(page) + snapshot = self._review_due_reserves(page, snapshot) - if self._ctx.stop_event.is_set(): - self._state.phase = DecisivePhase.FINISHED - return - page.start_battle() - time.sleep(1.0) - self._state.phase = DecisivePhase.IN_COMBAT + # 替补也可能正在维修。换入后重读健康状态,必要时再选下一艘。 + tried = set() + while True: + if self._repairs.needs_dispatch: + self._leave_for_repairs(page) + return False + best_fleet = self._logic.get_best_fleet( + self._repairs.blocked_identities, self._repairs.damaged_identities + ) + if sum(bool(name) for name in best_fleet) < self._repairs.target_size: + if self._prepare_repairs(page, snapshot): + raise RuntimeError(f'可选舰船不足 {self._repairs.target_size} 艘,无法出征') + return False + key = tuple(map(ship_name_identity, best_fleet[1:])) + if key == tuple(map(ship_name_identity, snapshot[0])): + return self._prepare_repairs(page, snapshot) + if key in tried: + raise RuntimeError('决战编队反复变化,保留现场') + tried.add(key) + snapshot = self._verify_prepared_fleet(page, best_fleet) + self._observe_repairs(page, snapshot) + + def _review_due_reserves( + self, page: DecisiveBattlePreparationPage, snapshot: RepairSnapshot + ) -> RepairSnapshot: + """到了复查时间,把候补舰临时换入编队,核对它的舰名和伤情。""" + due = self._repairs.due_identities + for name in sorted(self._state.ships): + identity = ship_name_identity(name) + if identity not in due or identity in { + ship_name_identity(n) for n in self._state.fleet + }: + continue + target = self._state.fleet.copy() + slot = next((i for i in range(1, 7) if not target[i]), 6) + target[slot] = name + snapshot = self._verify_prepared_fleet(page, target) + self._observe_repairs(page, snapshot) + return snapshot def _observe_map_ready(self, frame: CapturedFrame) -> None: """采集器可复用这个入口,保证字母识别与定位裁剪使用同一帧。""" @@ -473,30 +576,46 @@ def _handle_combat(self) -> None: for name in self._ensure_tracking().tracker.map_data.nodes }, ) - self._battle_encounter_id = self._tracking.encounter_id result = self._run_combat(plan) self._state.node = ( self._tracking.current_node if self._tracking.current_node != '0' else 'U' ) self._state.ship_stats = result.ship_stats[:] self._sync_ship_states() - _log.info( - '[决战] 战斗结束: {} (节点 {} 血量 {})', - result.flag.value, - self._state.node, - self._state.ship_stats, + health = { + ShipDamageState.NORMAL: '绿血', + ShipDamageState.MODERATE: '中破', + ShipDamageState.SEVERE: '大破', + ShipDamageState.REPAIRING: '维修中', + ShipDamageState.NO_SHIP: '未读到血条', + } + report = '、'.join( + f'{name}({health[damage]})' + for name, damage in zip(self._state.fleet[1:], result.ship_stats, strict=True) + if name ) + _log.info('[决战] 节点 {} 的战斗结束,{}', self._state.node, report or '未识别到舰船') # 处理战斗结果标志 if self._ctx.stop_event.is_set(): self._state.phase = DecisivePhase.FINISHED elif result.flag == ConditionFlag.DOCK_FULL: - _log.warning('[决战] 战斗中检测到船坞已满,转到 DOCK_FULL 阶段处理') + _log.warning('[决战] 船坞已满,准备解装') self._state.phase = DecisivePhase.DOCK_FULL elif result.flag == ConditionFlag.OPERATION_SUCCESS: + self._repairs.observe_inventory( + self._state.ships, + chapter=self._state.chapter, + stage=self._state.stage, + damage={ + name: status + for name, status in zip(self._state.fleet[1:], result.ship_stats, strict=True) + if name and status is not ShipDamageState.NO_SHIP + }, + ) self._state.phase = DecisivePhase.NODE_RESULT else: - _log.error('[决战] 战斗未完成,不推进节点: {}', result.flag.value) + _log.error('[决战] 战斗未完成,保留当前节点') self._state.phase = DecisivePhase.FINISHED def _run_combat(self, plan: CombatPlan) -> CombatResult: @@ -516,9 +635,9 @@ def _handle_node_result(self) -> None: 战斗引擎在 RESULT 点击后退出,游戏随后回到决战地图。 地图上可能出现以下几种情况: - - **ADVANCE_CHOICE**: 分支路径选择 overlay - - **CHOOSE_FLEET**: 战备舰队获取 overlay - - **PREPARE_COMBAT**: 地图页无 overlay,准备下一节点 + - **ADVANCE_CHOICE**: 分支路径选择浮窗 + - **CHOOSE_FLEET**: 战备舰队获取浮窗 + - **PREPARE_COMBAT**: 地图页无浮窗,准备下一节点 - **STAGE_CLEAR**: 独立通关页面确认,模型预测只决定是否复核 """ _log.info('[决战] 节点 {} 战斗结束, 等待地图加载', self._state.node) @@ -528,9 +647,23 @@ def _handle_node_result(self) -> None: return session = self._ensure_tracking() + self._complete_battle_encounter(session) + self._state.node_completed = True + self._wait_for_post_combat_page(session) + + def _complete_battle_encounter(self, session: DecisiveTrackingSession) -> None: + """按遭遇标识只推进一次,并记录真实分支的来源节点。""" if self._battle_encounter_id is None: raise RuntimeError('缺少成功战斗的遭遇标识,拒绝推进') - session.complete_encounter(self._battle_encounter_id) + if session.complete_encounter(self._battle_encounter_id): + completion = session.completed_encounter(self._battle_encounter_id) + source = completion.decision_node + branches = ( + len(MapData.get_leftmost_choices(self._state.chapter, self._state.stage, source)) + if source and source not in {'0', 'U'} + else None + ) + self._map.configure_route(branches) self._state.node = session.current_node if session.current_node != '0' else 'U' terminal_weight = sum( row['weight'] @@ -541,47 +674,73 @@ def _handle_node_result(self) -> None: if predicted_terminal: session.request_node_sample('战斗完成后存在终点候选,等待真实页面复核') + def _wait_for_post_combat_page(self, session: DecisiveTrackingSession) -> None: + """战果可能经过短暂地图后才显示选路或战备,等待控件稳定。""" + previous = None + stable_map = None + map_since = 0.0 deadline = time.monotonic() + self._POST_COMBAT_TIMEOUT while time.monotonic() < deadline: + check_stop(self._ctx.stop_event) + time.sleep(self._POST_COMBAT_INTERVAL) + check_stop(self._ctx.stop_event) + frame = self._ctrl.capture_frame() if self._ctx.stop_event.is_set(): self._state.phase = DecisivePhase.FINISHED return - time.sleep(self._POST_COMBAT_INTERVAL) - frame = self._ctrl.capture_frame() + if not frame.is_newer_than(previous, allow_static=stable_map is not None): + continue + previous = frame.snapshot() if self._map.is_stage_clear(frame.image): if session.stage_clear(frame): self._state.phase = DecisivePhase.STAGE_CLEAR return continue phase = self._map.detect_decisive_phase(frame.image) + if phase != DecisivePhase.PREPARE_COMBAT: + stable_map = None + if phase is None: + self._map.continue_combat_result(frame.image) + continue if phase == DecisivePhase.PREPARE_COMBAT: - frame = self._map.wait_for_stable_map_frame() + if stable_map is None or not self._map.map_icon_is_stable(stable_map, frame): + map_since = time.monotonic() + stable_map = previous + continue + stable_map = previous + if time.monotonic() - map_since < 1.0: + continue self._observe_map_ready(frame) elif phase in (DecisivePhase.CHOOSE_FLEET, DecisivePhase.ADVANCE_CHOICE): session.map_ready(frame) - if phase is not None: - _log.info('[决战] 战后检测到: {}', phase.name) - self._state.phase = phase - return + self._state.phase = phase + return session.request_node_sample('战后页面超时') - raise TimeoutError('战后未确认下一节点或真实通关页面;保留现场,停止决战') + raise TimeoutError('战斗已结束,等待下一节点地图或小关通关画面超时') def _handle_stage_clear(self, *, resume_rewards: bool = False) -> None: """小关通关:确认弹窗 → 收集掉落 → 下一小关或大关。""" _log.info('[决战] 小关 {} 通关!', self._state.stage) collected = self._map.confirm_stage_clear(resume_rewards=resume_rewards) self._close_tracking() + self._has_chosen_fleet = False self._known_start_stage = self._state.stage + 1 + self._state.expected_stage = self._known_start_stage if self._state.stage < 3 else None self._state.node = 'A' self._inventory_refresh_required = True if collected: _log.info('[决战] 获得 {} 个掉落: {}', len(collected), collected) - if self._state.stage >= 3: - self._state.phase = DecisivePhase.CHAPTER_CLEAR + next_phase = ( + DecisivePhase.CHAPTER_CLEAR if self._state.stage >= 3 else DecisivePhase.ENTER_MAP + ) + if self._repairs.park_after_settlement(): + self._after_settlement = next_phase + self._route_repair(RepairOutcome(RepairStatus.NEEDS_BATH)) else: - self._state.phase = DecisivePhase.ENTER_MAP + self._repairs.reset_stage() + self._state.phase = next_phase # ── 撤退与暂离 ────────────────────────────────────────────────────── @@ -592,6 +751,7 @@ def _execute_retreat(self) -> None: self._map.confirm_retreat() self._close_tracking() self._known_start_stage = None + self._has_chosen_fleet = False self._inventory_refresh_required = True def _execute_leave(self) -> None: diff --git a/autowsgr/ops/decisive/logic.py b/autowsgr/ops/decisive/logic.py index a0e9e444b..a3275f329 100644 --- a/autowsgr/ops/decisive/logic.py +++ b/autowsgr/ops/decisive/logic.py @@ -6,11 +6,13 @@ from __future__ import annotations +from itertools import combinations from typing import TYPE_CHECKING +from autowsgr.constants import DECISIVE_SKILL_NAMES, ship_name_identity from autowsgr.infra.logger import get_logger from autowsgr.ops.decisive.config import MapData -from autowsgr.types import FleetSelection, Formation +from autowsgr.types import FleetSelection, Formation, ShipDamageState if TYPE_CHECKING: @@ -28,7 +30,7 @@ def _is_ship(name: str) -> bool: """判断名称是否为舰船(而非增益技能)。""" - return name not in {'长跑训练', '肌肉记忆', '黑科技'} + return bool(name) and name not in DECISIVE_SKILL_NAMES def _count_anti_sub(enemy: list[str | None]) -> int: @@ -61,13 +63,16 @@ def __init__( config: DecisiveConfig, state: DecisiveState, ctx: GameContext | None = None, + *, + prefer_healthy: bool = False, ) -> None: self.config = config self.state = state self._ctx = ctx + self._prefer_healthy = prefer_healthy self._level1_set = set(config.level1) # level2_full = level1 + level2 + 增益技能 - self._level2_full = list({'长跑训练', '肌肉记忆', *config.level1, *config.level2, '黑科技'}) + self._level2_full = [*config.level1, *config.level2, *DECISIVE_SKILL_NAMES] # ── 战备舰队选择 ─────────────────────────────────────────────────── @@ -77,58 +82,59 @@ def choose_ships( *, first_node: bool = False, ) -> list[str]: - """从可购买列表中选择要购买的舰船/技能。 - - 策略优先级:: - - 舰队为空/仅1艘 → 只购买 level1 舰船 - 舰队未满编 → 购买 level2 中的舰船 (不买技能) - 满编但有非一级 → 优先凑齐 level1 - 满编且全一级 → 可购买增益技能 - 第一节点额外 → 同时尝试购买二级舰船 - - Parameters - ---------- - selections: - 当前可购买项 ``{name: FleetSelection}``。 - first_node: - 是否为第一小关第一节点。 - - Returns - ------- - list[str] - 选中购买的名称列表(按决策顺序)。 - """ - fleet_count = sum(1 for s in self.state.fleet[1:] if s) + """在预算内先增加主备池舰数,同数优先一级舰、低费用。""" + primary = list(dict.fromkeys(ship_name_identity(name) for name in self.config.level1)) + pool = list(dict.fromkeys([*primary, *(ship_name_identity(n) for n in self.config.level2)])) + owned = {ship_name_identity(name) for name in self.state.ships}.intersection(pool) score = self.state.score - - if fleet_count <= 1: - candidates = self.config.level1 - elif fleet_count < 6: - candidates = [e for e in self._level2_full if _is_ship(e)] - elif not {s for s in self.state.fleet[1:] if s}.issubset(self._level1_set): - candidates = self.config.level1 - else: - candidates = self.config.level1 + [e for e in self._level2_full if not _is_ship(e)] - - lim = 6 if fleet_count < 6 else score - lim = score if fleet_count == 0 else lim - result: list[str] = [] - for target in candidates: - if target in selections: - sel = selections[target] - if score >= sel.cost and sel.cost <= lim: - score -= sel.cost - result.append(target) - - # 第一节点没选上Lv1,也购买Lv2舰船 - if first_node: - for target in set(self._level2_full) - self._level1_set: - if target in selections: - sel = selections[target] - if score >= sel.cost and sel.cost <= lim: - score -= sel.cost - result.append(target) + offers: dict[str, FleetSelection] = {} + for name, offer in selections.items(): + identity = ship_name_identity(name) + if ( + identity is not None + and identity in pool + and _is_ship(name) + and 0 <= offer.cost <= score + and (identity not in offers or offer.cost < offers[identity].cost) + ): + offers[identity] = offer + + target = 2 if first_node and len(owned) < 2 else 6 + candidates = [identity for identity in pool if identity in offers and identity not in owned] + + def best_bundle(candidates: list[str], capacity: int) -> tuple[str, ...]: + best = () + best_rank = (0, 0, 0) + for count in range(1, min(capacity, len(candidates)) + 1): + for bundle in combinations(candidates, count): + cost = sum(offers[identity].cost for identity in bundle) + rank = (count, sum(identity in primary for identity in bundle), -cost) + if cost <= score and rank > best_rank: + best, best_rank = bundle, rank + return best + + selected = list(best_bundle(candidates, target - len(owned))) + score -= sum(offers[identity].cost for identity in selected) + owned.update(selected) + if not first_node and len(owned) >= 6: + for upgrade in (False, True): + candidates = [ + identity + for identity in primary + if identity in offers + and identity not in selected + and (identity in owned) == upgrade + ] + batch = best_bundle(candidates, len(candidates)) + score -= sum(offers[identity].cost for identity in batch) + selected.extend(batch) + owned.update(batch) + result = [offers[identity].name for identity in selected] + if len(owned.intersection(primary)) >= 6: + for name in DECISIVE_SKILL_NAMES: + if name in selections and 0 <= selections[name].cost <= score: + result.append(name) + score -= selections[name].cost return result # ── 状态判断 ─────────────────────────────────────────────────────── @@ -215,54 +221,57 @@ def check_useful_skill(self, gained: list[str]) -> bool: # ── 编队计算 ─────────────────────────────────────────────────────── - def get_best_fleet(self) -> list[str]: - """根据当前拥有的舰船计算最优编队。 - - Returns - ------- - list[str] - 长度 7 的列表:索引 0 留空,1-6 为各位置舰船名。 - """ - ships = self.state.ships - best: list[str] = [''] - _log.debug('[决战] 当前舰船: {}', ships) - for ship in self.config.level1: - if ship in ships and self._is_available(ship) and len(best) < 7: - best.append(ship) - - for ship in self.config.level2: - if ship in ships and ship not in best and self._is_available(ship) and len(best) < 7: - best.append(ship) - - for flag_ship in self.config.flagship_priority: - if flag_ship in best[1:]: - idx = best.index(flag_ship) - best[idx], best[1] = best[1], best[idx] + def get_best_fleet( + self, blocked: frozenset[str] = frozenset(), damaged: frozenset[str] = frozenset() + ) -> list[str]: + """按配置顺序挑选主备舰,启用按时长维修时优先使用健康候补。""" + by_identity = {ship_name_identity(name): name for name in sorted(self.state.ships)} + candidates = list( + dict.fromkeys( + ship_name_identity(name) + for name in (*self.config.level1, *self.config.level2) + if _is_ship(name) + ) + ) + damage = { + ship_name_identity(name): state + for name, state in zip(self.state.fleet[1:], self.state.ship_stats, strict=True) + if name + } + + def needs_repair(identity: str) -> bool: + health = damage.get(identity) + if health is not None: + return health >= self.config.repair_level + return identity in damaged or not self._is_available(by_identity[identity]) + + identities = [ + identity + for identity in candidates + if identity in by_identity and identity not in blocked + ] + if self._prefer_healthy: + identities.sort(key=needs_repair) + else: + # 原编队优先级允许中破主力;有可用替补时,大破舰不占它的舰位。 + identities.sort( + key=lambda identity: ( + damage.get(identity) is ShipDamageState.SEVERE + or not self._is_available(by_identity[identity]) + ) + ) + selected = identities[:6] + for name in self.config.flagship_priority: + identity = ship_name_identity(name) + if identity in selected: + idx = selected.index(identity) + selected[0], selected[idx] = selected[idx], selected[0] break - - while len(best) < 7: - best.append('') - - _log.debug('[决战] 最优编队: {}', best) - return best - - # ── 路径选择 ─────────────────────────────────────────────────────── - - def get_advance_choice(self, options: list[str]) -> int: # noqa: ARG002 - """选择前进点索引。 - - Parameters - ---------- - options: - 可选前进点列表 (如 ``["A1", "A2"]``)。 - - Returns - ------- - int - 选中选项的索引 (0-based)。 - """ - # TODO: 根据地图数据和关键节点信息做出更智能的选择 - return 0 + return [ + '', + *(by_identity[identity] for identity in selected), + *([''] * (6 - len(selected))), + ] def get_formation(self, node: str | None = None) -> Formation: """根据指定候选节点敌方编成选择阵型;省略节点时使用当前状态。 diff --git a/autowsgr/ops/decisive/repair.py b/autowsgr/ops/decisive/repair.py new file mode 100644 index 000000000..92bbdca82 --- /dev/null +++ b/autowsgr/ops/decisive/repair.py @@ -0,0 +1,659 @@ +"""记录决战舰船的伤情和维修进度,确认编队能否出征。""" + +from __future__ import annotations + +import time +from dataclasses import dataclass +from enum import StrEnum +from typing import TYPE_CHECKING + +from autowsgr.constants import DECISIVE_SKILL_NAMES, normalize_ship_name, ship_name_identity +from autowsgr.infra import ActionFailedError +from autowsgr.infra.logger import get_logger +from autowsgr.ops.navigate import goto_page +from autowsgr.ops.repair_policy import ( + BLIND_RECHECK_SECONDS, + RepairAction, + decide_repair, + parse_repair_duration, +) +from autowsgr.types import DecisiveEntryStatus, PageName, ShipDamageState +from autowsgr.ui.bath_page import BathPage +from autowsgr.ui.bath_page.signatures import SWIPE_DELAY, SWIPE_DURATION, SWIPE_END, SWIPE_START +from autowsgr.ui.decisive.preparation import is_complete_fleet, read_complete_fleet +from autowsgr.ui.utils.navigation import NavigationError + + +if TYPE_CHECKING: + from collections.abc import Callable, Iterable, Mapping, Sequence + + from autowsgr.context import GameContext + from autowsgr.context.ship import Ship + from autowsgr.infra import DecisiveConfig, UserConfig + from autowsgr.ui.bath_page.page import RepairShipInfo + from autowsgr.ui.decisive.battle_page import DecisiveBattlePage + from autowsgr.ui.decisive.map_controller import DecisiveMapController + from autowsgr.ui.decisive.preparation import DecisiveBattlePreparationPage, RepairSnapshot + + +_log = get_logger('ops.decisive') + + +class RepairStatus(StrEnum): + READY = 'ready' + NEEDS_BATH = 'needs_bath' + WAITING = 'waiting' + REENTER = 'reenter' + RECHECK = 'recheck' + STOPPED = 'stopped' + + +@dataclass(frozen=True, slots=True) +class RepairOutcome: + status: RepairStatus + target_size: int = 0 + wait_seconds: float | None = None + targets: tuple[str, ...] = () + detail: str = '' + snapshot: RepairSnapshot | None = None + resume_immediately: bool = False + + +def _named_ships(names: Iterable[str | None]) -> dict[str, str]: + result: dict[str, str] = {} + for raw in names: + name = normalize_ship_name(raw) + identity = ship_name_identity(name) + if name and identity and name not in DECISIVE_SKILL_NAMES: + result.setdefault(identity, name) + return result + + +class DecisiveRepairCoordinator: + """记录本小关已获得的舰船及其维修状态。 + + 出征前,从同一张准备页截图核对每艘在队舰船的名称和伤情,并确认哪些位置是空的。 + """ + + def __init__( + self, + ctx: GameContext, + config: DecisiveConfig, + *, + user_config: UserConfig | None = None, + clock: Callable[[], float] = time.time, + ) -> None: + self._clock = clock + self._settings = user_config if user_config is not None else ctx.config + self._ctx = ctx + self._config = config + self._configured = _named_ships([*config.level1, *config.level2]) + self.reset_stage() + + def reset_stage(self) -> None: + """开始新一轮或确认切换小关时,清理本小关的登记。""" + self._chapter_stage: tuple[int, int] | None = None + self._acquired: dict[str, Ship] = {} # 只引用本小关实见舰船在 ctx 中的记录 + self._damage: dict[str, ShipDamageState] = {} + self._pending: dict[str, str] = {} + self._long_repairs: set[str] = set() + self._unconfirmed_bucket: tuple[str, int] | None = None + self._target_size = 0 + self._saved = False + self._settled = False + self._retry_at: dict[str, float] = {} + self._failed_quotes: set[str] = set() + + @property + def saved(self) -> bool: + return self._saved + + @property + def _deadlines(self) -> dict[str, float]: + return { + identity: at + for identity, ship in self._acquired.items() + if (at := ship.repair_recheck_at or ship.repair_end_time) + } + + @property + def due_identities(self) -> frozenset[str]: + now = self._clock() + return frozenset(identity for identity, end in self._deadlines.items() if end <= now) + + @property + def target_size(self) -> int: + return self._target_size + + @property + def acquired(self) -> tuple[str, ...]: + return tuple(ship.name for ship in self._acquired.values()) + + @property + def can_continue_without_pending(self) -> bool: + """已获得的其他配置舰足以组队时,将节点与派修一同排队。""" + pool = self._acquired.keys() & self._configured.keys() + return len(pool - self.blocked_identities) >= self.target_size > 0 + + @property + def damaged_identities(self) -> frozenset[str]: + """按本轮维修标准标出应优先换下的舰船。""" + return frozenset( + identity + for identity, state in self._damage.items() + if self._config.repair_level <= state < ShipDamageState.REPAIRING + ) + + @property + def protected_identities(self) -> frozenset[str]: + """保护配置舰、已获得舰及其别名。""" + return frozenset(self._configured.keys() | self._acquired.keys()) + + @property + def blocked_identities(self) -> frozenset[str]: + """等待派修或等待复查的舰船不能出征。""" + return frozenset( + identity + for identity in self._acquired + if self._is_repairing(identity) + or (identity in self._pending and identity not in self._long_repairs) + ) + + def observe_inventory( + self, + acquired: Iterable[str], + *, + chapter: int, + stage: int, + damage: Mapping[str, ShipDamageState] | None = None, + ) -> None: + """按名登记已获得舰船和已确认的伤情。""" + pair = (chapter, stage) + if self._chapter_stage is not None and pair != self._chapter_stage: + raise ValueError('决战小关已改变,无法沿用之前的维修记录') + self._chapter_stage = pair + for identity, name in _named_ships(acquired).items(): + ship = self._ctx.get_ship(name) + self._acquired[identity] = ship + if ship.repair_end_time or ship.repair_recheck_at: + self._pending[identity] = name + self._failed_quotes.discard(identity) + self._long_repairs.discard(identity) + self._retry_at.pop(identity, None) + elif ship.damage_state is ShipDamageState.REPAIRING or ship.repairing: + self._record_repair_marker(identity, self._clock(), 0.0) + elif ship.damage_state >= self._config.repair_level: + self._damage[identity] = ship.damage_state + if self._settings.quick_repair_threshold_seconds is not None: + self._pending[identity] = name + count = len(self._acquired.keys() & self._configured.keys()) + self._target_size = max(self._target_size, min(6, count)) + for name, state in (damage or {}).items(): + identity = ship_name_identity(name) + if identity in self._acquired: + self._record_health(identity, state) + + def _is_repairing(self, identity: str) -> bool: + ship = self._acquired[identity] + return ship.repairing or bool(ship.repair_end_time or ship.repair_recheck_at) + + def _record_health(self, identity: str, state: ShipDamageState) -> None: + if not isinstance(state, ShipDamageState) or state is ShipDamageState.NO_SHIP: + raise ValueError('准备页未能确认这艘船的伤情') + now = self._clock() + ship = self._acquired[identity] + known_end = ship.repair_end_time + due = ship.repair_recheck_at or known_end or None + if state is ShipDamageState.REPAIRING or ship.repairing: + state = ShipDamageState.REPAIRING + self._record_repair_marker(identity, now, known_end) + elif due is not None and now < due: + # 同一段维修时间内的重复观察不改变复查时刻。 + return + else: + ship.repair_end_time = ship.repair_recheck_at = 0.0 + if state != self._damage.get(identity): + self._long_repairs.discard(identity) + if state < self._config.repair_level: + self._pending.pop(identity, None) + self._failed_quotes.discard(identity) + self._retry_at.pop(identity, None) + elif due is not None or self._settings.quick_repair_threshold_seconds is not None: + self._pending[identity] = ship.name + self._damage[identity] = state + ship.damage_state = state + + def _record_repair_marker(self, identity: str, now: float, known_end: float) -> None: + ship = self._acquired[identity] + name = ship.name + if self._damage.get(identity) is not ShipDamageState.REPAIRING: + if known_end > now: + _log.info( + '[决战] {} 显示维修中,按已登记的入浴时间 {:.1f} 秒后复查', + name, + known_end - now, + ) + else: + _log.info( + '[决战] {} 显示维修中,时长未知,{} 秒后复查', name, BLIND_RECHECK_SECONDS + ) + if max(ship.repair_recheck_at, known_end) <= now: + ship.repair_recheck_at = now + BLIND_RECHECK_SECONDS + self._pending[identity] = name + self._long_repairs.discard(identity) + self._failed_quotes.discard(identity) + self._retry_at.pop(identity, None) + + @property + def needs_dispatch(self) -> bool: + """是否有需在浴室读取时长或安排入浴的舰船。""" + return bool(self._dispatchable()) + + def _dispatchable(self) -> set[str]: + now = self._clock() + return { + key + for key in self._pending + if key not in self._long_repairs + and not self._is_repairing(key) + and key not in self._failed_quotes + and self._retry_at.get(key, 0) <= now + } + + def _healthy_count(self, identities: Iterable[str]) -> int: + blocked = self.blocked_identities + return sum( + self._damage.get(key) in (ShipDamageState.NORMAL, ShipDamageState.MODERATE) + and self._damage[key] < self._config.repair_level + and key not in blocked + for key in identities + ) + + def _outcome( + self, + status: RepairStatus, + *, + wait_seconds: float | None = None, + detail: str = '', + snapshot: RepairSnapshot | None = None, + ) -> RepairOutcome: + return RepairOutcome( + status, + self.target_size, + wait_seconds, + tuple(self._pending.values()), + detail, + snapshot, + ) + + def _check_stop(self) -> None: + if self._ctx.stop_event.is_set(): + raise InterruptedError('决战维修期间收到停止请求') + + def read_complete_snapshot( + self, + page: DecisiveBattlePreparationPage, + *, + fresh: bool = False, + expected: Sequence[str | None] | None = None, + recheck_fleet: Callable[[], None] | None = None, + ) -> tuple[list[str | None], dict[int, ShipDamageState]]: + """舰名或伤情没读全时重新截图;舰名或顺序与预期不符时,核对编队后再读一次。""" + names, damage = read_complete_fleet(page, self._ctx.stop_event, fresh=fresh) + if expected is not None and list(map(ship_name_identity, names)) != list( + map(ship_name_identity, expected) + ): + if recheck_fleet is None: + raise ActionFailedError('决战维修复核的舰船名称或顺序与已确认编队不一致') + _log.info('[决战] 准备页读到的舰名或顺序与预期不符,重新核对编队 {}', names) + recheck_fleet() + return self.read_complete_snapshot(page, fresh=True, expected=expected) + return names, damage + + def _quick_repair( + self, + page: DecisiveBattlePreparationPage, + fleet: Sequence[str | None], + slot: int, + identity: str, + recheck_fleet: Callable[[], None] | None, + ) -> RepairSnapshot: + """按舰名和编队顺序找到要快修的船,确认它已达到出征标准后才计入用桶数。""" + limited = self._settings.quick_repair_threshold_seconds is not None + selected = _named_ships(fleet).keys() & self._configured.keys() + while True: + names, damage = self.read_complete_snapshot( + page, fresh=True, expected=fleet, recheck_fleet=recheck_fleet + ) + self._record_fleet(names, damage) + state = damage[slot] + ready = self._healthy_count(self._configured.keys() & self._acquired.keys()) + missing = max(0, self.target_size - ready) + attempts = self._unconfirmed_bucket[1] if self._unconfirmed_bucket else 0 + if state < self._config.repair_level and identity not in self.blocked_identities: + if attempts: + self._ctx.quick_repair_used += 1 + self._unconfirmed_bucket = None + _log.info('[决战] 已确认 {} 快修后可出击,仍缺 {} 艘', names[slot], missing) + return names, damage + unavailable = self._is_repairing(identity) + if attempts and (attempts >= (1 if limited else 3) or unavailable): + raise ActionFailedError(f'决战快修后未确认 {names[slot]} 恢复') + if unavailable: + return names, damage + if limited and ( + not missing + or identity not in selected + or identity not in self._long_repairs + or self.needs_dispatch + or self._healthy_count(selected) + len(selected & self._long_repairs) + < self.target_size + ): + return names, damage + if self._settings.repair_manually or not self._config.use_quick_repair: + raise ActionFailedError('需要进行手动修理') + _log.info( + '[决战] 快修前有 {} 艘可出击,缺 {} 艘,对 {} 使用一个快修桶', + ready, + missing, + names[slot], + ) + self._check_stop() + self._unconfirmed_bucket = identity, attempts + 1 + page.repair_slots([slot]) + if self._ctx.stop_event.is_set(): + return names, damage + + def _record_fleet( + self, fleet: Sequence[str | None], damage: Mapping[int, ShipDamageState] + ) -> dict[int, str] | None: + """核对在队舰船的名称和伤情,并按编队顺序登记需要维修的舰船。""" + if len(fleet) != 6: + raise ValueError(f'准备页共有 6 个编队位置(含空位),本次读到 {len(fleet)} 个') + present = _named_ships(fleet) + if len(present) != sum(bool(name) for name in fleet): + raise ValueError('准备页存在同名舰船,无法确定维修目标') + if not present.keys() <= self._acquired.keys(): + raise ValueError('准备页出现未登记的舰船,请复核库存') + if not is_complete_fleet(fleet, damage): + return None + required: dict[int, str] = {} + for slot, raw_name in enumerate(fleet): + identity = ship_name_identity(raw_name) + if identity is None: + continue + state = damage[slot] + self._record_health(identity, state) + if state >= self._config.repair_level: + required[slot] = identity + self._pending[identity] = present[identity] + return required + + def prepare( + self, + page: DecisiveBattlePreparationPage, + *, + fleet: Sequence[str | None], + damage: Mapping[int, ShipDamageState], + acquired: Iterable[str], + chapter: int, + stage: int, + recheck_fleet: Callable[[], None] | None = None, + ) -> RepairOutcome: + """核对实际编队,按缺额快修或暂离前往浴室。""" + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + self.observe_inventory(acquired, chapter=chapter, stage=stage) + required = self._record_fleet(fleet, damage) + if required is None: + return self._outcome(RepairStatus.RECHECK, detail='无法确认当前舰名或伤情') + if self._settings.repair_manually and self.damaged_identities: + raise ActionFailedError('需要进行手动修理') + last_snapshot = None + if self._unconfirmed_bucket is not None: + identity, _ = self._unconfirmed_bucket + slots = [ship_name_identity(name) for name in fleet] + if identity not in slots: + raise ActionFailedError( + f'用桶后在准备页找不到 {self._acquired[identity].name},无法确认快修结果' + ) + slot = slots.index(identity) + last_snapshot = self._quick_repair(page, fleet, slot, identity, recheck_fleet) + required.pop(slot, None) + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + if self.needs_dispatch and self._settings.quick_repair_threshold_seconds is not None: + return self._outcome(RepairStatus.NEEDS_BATH) + # 先核对能否用这些长修候选补齐整队,以免只修一部分后仍需等待。 + selected = _named_ships(fleet).keys() & self._configured.keys() + possible = self._healthy_count(selected) + len(selected & self._long_repairs) + if self._settings.quick_repair_threshold_seconds is None or possible >= self.target_size: + for slot, identity in required.items(): + if self._is_repairing(identity): + continue + last_snapshot = self._quick_repair(page, fleet, slot, identity, recheck_fleet) + if self._ctx.stop_event.is_set(): + break + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + return self._check_readiness(selected, last_snapshot) + + def _check_readiness( + self, selected: set[str], snapshot: RepairSnapshot | None + ) -> RepairOutcome: + healthy = self._healthy_count(selected) + if healthy >= self.target_size and healthy > 0: + self._saved = False + return self._outcome(RepairStatus.READY, snapshot=snapshot) + if self._pending: + return self._outcome(RepairStatus.NEEDS_BATH) + return self._outcome( + RepairStatus.RECHECK, + detail=f'本小关需要 {self.target_size} 艘舰船,当前编队有 {healthy} 艘可以出征', + ) + + def park_after_settlement(self) -> bool: + """已回到总览,可直接处理终点产生或浴室满时保留的伤舰。""" + remaining = self._pending.keys() - self._long_repairs - self._deadlines.keys() + if not remaining: + return False + self._check_stop() + if self._settings.repair_manually: + raise ActionFailedError('需要进行手动修理') + self._saved = self._settled = True + return True + + def save_progress( + self, + preparation: DecisiveBattlePreparationPage | None, + map_controller: DecisiveMapController, + ) -> None: + """暂离并确认返回章节总览,交由调度器按名派修。""" + self._check_stop() + if self._settings.repair_manually and self.needs_dispatch: + raise ActionFailedError('需要进行手动修理') + if not self._pending or self._chapter_stage is None: + raise RuntimeError('缺少可确认的维修目标,无法暂离') + if preparation is not None and preparation.is_current_page(self._ctx.ctrl.screenshot()): + self._check_stop() + preparation.go_back() + self._check_stop() + map_controller.leave_to_overview() + self._saved = True + self._check_stop() + _log.info( + '[决战] 已暂离第 {} 章第 {} 小关,待处理舰船:{}', + *self._chapter_stage, + '、'.join(self._pending.values()), + ) + + @staticmethod + def _card_signature(cards: Sequence[RepairShipInfo]) -> tuple: + return tuple((card.name, round(card.position[0], 2)) for card in cards) + + def _find_card(self, page: BathPage, identity: str) -> RepairShipInfo | None: + self._check_stop() + if page.has_choose_repair_overlay(self._ctx.ctrl.screenshot()): + page.close_choose_repair_overlay() + self._check_stop() + page.go_to_choose_repair() + # 弹窗可能保留上次的滚动位置,两边都查到页尾。遇到目标舰即按这张卡的时长处理。 + for toward_start in (True, False): + seen = set() + while True: + self._check_stop() + cards = page.recognize_repair_ships() + matches = [card for card in cards if ship_name_identity(card.name) == identity] + if len(matches) > 1: + raise ActionFailedError('浴室出现多个同名维修目标,无法区分') + if matches: + return matches[0] + signature = self._card_signature(cards) + if signature in seen: + break + seen.add(signature) + self._check_stop() + if toward_start: + self._ctx.ctrl.swipe(*SWIPE_END, *SWIPE_START, duration=SWIPE_DURATION) + self._ctx.stop_event.wait(SWIPE_DELAY) + else: + page._swipe_left() + return None + + def _quote_and_dispatch(self, page: BathPage, identity: str, name: str) -> bool: + """读取时长并处理一艘舰。浴室无法接单时暂停本批操作。""" + try: + card = self._find_card(page, identity) + except NavigationError: + self._check_stop() + screen = self._ctx.ctrl.screenshot() + if not page.is_current_page(screen) or page.has_choose_repair_overlay(screen): + raise + # 浴室没有打开选船页,等有空闲浴位后再派这艘船入浴。 + self._retry_at[identity] = self._clock() + max( + 5.0, self._ctx.bathroom.get_waiting_time() + ) + return False + seconds = parse_repair_duration(card.repair_time) if card else None + decision = decide_repair( + required=True, + repairing=False, + repair_seconds=seconds, + quick_threshold_seconds=self._settings.quick_repair_threshold_seconds, + ) + if decision.action is RepairAction.RECHECK: + self._failed_quotes.add(identity) + self._retry_at.pop(identity, None) + _log.warning('[决战] 在浴室未读到 {} 的维修时长,本次跳过这艘船', name) + return True + if decision.action is RepairAction.QUICK: + self._long_repairs.add(identity) + self._retry_at.pop(identity, None) + _log.info('[决战] {} 需修 {} 秒,保留为缺员时的快修候选', name, seconds) + return True + assert card is not None + assert decision.action is RepairAction.BATH + if not self._ctx.bathroom.is_available(): + self._retry_at[identity] = self._clock() + max( + 1.0, self._ctx.bathroom.get_waiting_time() + ) + return True + self._check_stop() + dispatched_at = self._clock() + self._ctx.ctrl.click(*card.position) + if not page.wait_repair_accepted(): + self._ctx.bathroom.mark_unknown() + self._retry_at[identity] = self._clock() + 5.0 + return False + assert seconds is not None + deadline = dispatched_at + seconds + self._acquired[identity].record_bath(deadline) + self._retry_at.pop(identity, None) + _log.info('[决战] {} 已入浴,{} 秒后复查', name, seconds) + self._ctx.bathroom.occupy(seconds) + self._check_stop() + return True + + def dispatch_pending(self) -> RepairOutcome: + """到浴室逐一核实待修舰名和耗时,立即安排短修。""" + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + if not self._saved: + raise RuntimeError('尚未确认决战暂离,请先保存进度') + needs_quote = self._dispatchable() + if not needs_quote: + return self.poll() + goto_page(self._ctx, PageName.BATH) + self._check_stop() + page = BathPage(self._ctx) + self._ctx.bathroom.slot_count = self._settings.bathroom_count + for identity, name in tuple(self._pending.items()): + if identity not in needs_quote: + continue + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + if self._is_repairing(identity): + return self._outcome(RepairStatus.RECHECK, detail=f'需复核舰船在修状态:{name}') + if not self._quote_and_dispatch(page, identity, name): + break + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + if page.has_choose_repair_overlay(self._ctx.ctrl.screenshot()): + self._check_stop() + page.close_choose_repair_overlay() + self._check_stop() + goto_page(self._ctx, PageName.MAIN) + return self.poll() + + def poll(self) -> RepairOutcome: + """根据当前时间、可用舰和维修队列决定下一步。""" + if self._ctx.stop_event.is_set(): + return self._outcome(RepairStatus.STOPPED) + if not self._saved: + raise RuntimeError('没有已保存的决战维修进度') + now = self._clock() + pool = self._acquired.keys() & self._configured.keys() + if self._dispatchable(): + return self._outcome(RepairStatus.NEEDS_BATH) + return self._next_resume(now, pool) + + def _next_resume(self, now: float, pool: set[str]) -> RepairOutcome: + slot_waits = [at - now for at in self._retry_at.values() if at > now] + if self._settled: + if slot_waits: + return self._outcome(RepairStatus.WAITING, wait_seconds=min(slot_waits)) + return self._outcome(RepairStatus.REENTER) + # 有些候补舰只知道舰名,要换入编队后才能核对伤情。 + if self._failed_quotes and len(pool - self._failed_quotes) < self.target_size: + names = '、'.join(self._pending[key] for key in sorted(self._failed_quotes & pool)) + return self._outcome( + RepairStatus.RECHECK, detail=f'未读到维修时长,缺少可补位的舰船,保留存档:{names}' + ) + if self.can_continue_without_pending or self.due_identities: + return self._outcome(RepairStatus.REENTER) + future = slot_waits + [end - now for end in self._deadlines.values() if end > now] + if future: + return self._outcome(RepairStatus.WAITING, wait_seconds=min(future)) + return self._outcome(RepairStatus.RECHECK, detail='未能确认有足够的舰船可以出征') + + def validate_resume(self, battle_page: DecisiveBattlePage) -> None: + """重入前核实保存的章节与小关。""" + self._check_stop() + if not self._saved or self._chapter_stage is None: + raise RuntimeError('未找到可恢复的决战维修进度') + self.validate_stage(battle_page, *self._chapter_stage) + + def validate_stage(self, battle_page: DecisiveBattlePage, chapter: int, stage: int) -> None: + """暂离重进或切换小关时,先核实总览的真实存档入口。""" + self._check_stop() + status = battle_page.detect_entry_status(timeout=5.0) + self._check_stop() + if status not in {DecisiveEntryStatus.CHALLENGING, DecisiveEntryStatus.REFRESHED}: + raise RuntimeError('当前决战入口无法继续已保存的进度') + screen = self._ctx.ctrl.screenshot() + if battle_page._read_chapter(screen) != chapter: + raise RuntimeError(f'准备继续决战第 {chapter} 章,总览未显示该章节') + actual_stage = battle_page.detect_stage(screen, chapter) + self._check_stop() + if type(actual_stage) is not int or actual_stage != stage: + raise RuntimeError(f'准备继续决战第 {chapter} 章第 {stage} 小关,总览未显示该小关') diff --git a/autowsgr/ops/decisive/state.py b/autowsgr/ops/decisive/state.py index c3d1eb2f9..bf2f5517a 100644 --- a/autowsgr/ops/decisive/state.py +++ b/autowsgr/ops/decisive/state.py @@ -42,6 +42,13 @@ class DecisiveState: fleet: list[str] = field(default_factory=lambda: [''] * 7) ship_stats: list[ShipDamageState] = field(default_factory=lambda: [ShipDamageState.NO_SHIP] * 6) + # 战果已提交后,收完选路、战备或掉落,才能在下一节点交回调度。 + node_completed: bool = False + at_node_boundary: bool = False + # 其他任务接管过页面时,先导航回总览,并核对将要进入的小关。 + navigate_to_entry: bool = False + expected_stage: int | None = None + def reset(self) -> None: """重置状态 (保留 chapter)。""" chapter = self.chapter diff --git a/autowsgr/scheduler/daily_plan.py b/autowsgr/scheduler/daily_plan.py index db723d785..168a45ca3 100644 --- a/autowsgr/scheduler/daily_plan.py +++ b/autowsgr/scheduler/daily_plan.py @@ -3,9 +3,9 @@ 激活 dev 的「死配置」``daily_automation``: 读取其字段, 为每个启用的日常任务 (远征 / 战役 / 演习 / 常规战) 构造触发器并注册到 :class:`TaskScheduler`。 -优先级 (数值小先执行, 由 :mod:`autowsgr.scheduler.triggers` 定义):: +优先级 (数值小先执行):: - 远征 0 < 奖励 1 < 战役 5 < 演习 10 < 常规战 100 < 浴室修理 200 (空闲填充, 最后执行) + 远征 0、奖励 1、战役 5、演习 10、决战派修 40、决战节点 50、常规战 100、空闲维修 200 使用方式:: @@ -39,7 +39,7 @@ from pathlib import Path from autowsgr.context import GameContext - from autowsgr.infra.config import DailyAutomationConfig + from autowsgr.infra.config import DailyAutomationConfig, UserConfig from autowsgr.scheduler.scheduler import TaskScheduler _log = get_logger('scheduler') @@ -49,6 +49,8 @@ PRIO_BONUS = 1 PRIO_CAMPAIGN = 5 PRIO_EXERCISE = 10 +PRIO_REQUESTED_REPAIR = 40 +PRIO_DECISIVE = 50 PRIO_NORMAL_FIGHT = 100 # 浴室修理: 空闲填充, 排在所有战斗任务之后 —— 仅当战役/演习/常规战都无 pending # 任务 (常规战 _is_exhausted、战役演习 _exhausted) 时才出队执行, 还原 classic @@ -85,6 +87,8 @@ def build_daily_plan( ctx: GameContext, *, expedition_interval: float = DEFAULT_EXPEDITION_INTERVAL, + decisive_session: bool = False, + user_config: UserConfig | None = None, ) -> None: """读取 ``ctx.config.daily_automation``, 注册各触发器到 ``scheduler``。 @@ -96,13 +100,19 @@ def build_daily_plan( 游戏上下文 (提供 config / 控制器)。 expedition_interval: 远征定时触发的轮询间隔 (秒)。 + decisive_session: + 决战期间关闭常规战。战役、演习操作失败后等下个检查周期再试,避免抢占每一个决战节点。 + user_config: + 本次会话实际采用的用户配置,默认使用上下文配置。 """ - cfg = ctx.config.daily_automation + settings = user_config if user_config is not None else ctx.config + cfg = settings.daily_automation if cfg is None: _log.warning('[daily] 未配置 daily_automation, 不注册任何触发器') return _log.info('[daily] 构建 auto_daily 计划') + retry_interval = expedition_interval if decisive_session else 0.0 # ── 远征 (定时, prio 0) ── if cfg.auto_expedition: @@ -166,6 +176,7 @@ def build_daily_plan( task_factory=lambda c: CampaignRunner(c, battle_type, times=1), priority=PRIO_CAMPAIGN, name=f'战役/{battle_type}', + retry_interval=retry_interval, ), ) @@ -179,18 +190,19 @@ def build_daily_plan( task_factory=lambda c: ExerciseOnceRunner(c, fleet_id), priority=PRIO_EXERCISE, name='演习', + retry_interval=retry_interval, ), ) # ── 常规战 (条件, prio 100, 空闲填充) ── - if cfg.auto_normal_fight and cfg.normal_fight_tasks: - _register_normal_fight(scheduler, cfg, plan_root=ctx.config.plan_root) + if not decisive_session and cfg.auto_normal_fight and cfg.normal_fight_tasks: + _register_normal_fight(scheduler, cfg, plan_root=settings.plan_root) # ── 浴室修理被无限常规战抢占的告警 ── # 改 prio 后浴室修理 (200) 排在常规战 (100) 之后; 若存在无限常规战 # (times=None) 且未开任何停止上限, 常规战会持续产出 prio=100 任务、 # 永远抢占浴室修理致其无声失效。这是 classic 没有的 dev 新场景, 显式提示。 - if _bath_repair_starved_by_normal_fight(cfg): + if not decisive_session and _bath_repair_starved_by_normal_fight(cfg): _log.warning( '[daily] 已启用浴室修理, 但存在无限常规战 (times 未设置) 且未开启任何' '停止上限 (stop_max_ship / stop_max_loot / quick_repair_limit)。' @@ -198,7 +210,7 @@ def build_daily_plan( '或开启任一停止上限。', ) - if not scheduler._triggers: + if not decisive_session and not scheduler._triggers: _log.warning('[daily] 未启用任何日常任务, run_daily 将空转') diff --git a/autowsgr/scheduler/decisive.py b/autowsgr/scheduler/decisive.py new file mode 100644 index 000000000..f8dd9b72c --- /dev/null +++ b/autowsgr/scheduler/decisive.py @@ -0,0 +1,107 @@ +"""一轮决战在就绪队列中的节点任务、具名维修任务和到期通知。""" + +from __future__ import annotations + +import time +from dataclasses import dataclass +from typing import TYPE_CHECKING + +from autowsgr.infra.logger import get_logger +from autowsgr.scheduler.daily_plan import PRIO_DECISIVE, PRIO_REQUESTED_REPAIR + + +if TYPE_CHECKING: + from collections.abc import Callable + + from autowsgr.ops.decisive.controller import DecisiveResult + from autowsgr.ops.decisive.repair import RepairOutcome + from autowsgr.scheduler.scheduler import FightTask, TaskScheduler + + +_log = get_logger('scheduler') + + +@dataclass(eq=False, slots=True) +class ScheduledAction: + name: str + priority: int + run: Callable[[], None] + + +class DecisiveRound: + """同一轮最多各排一个续战和派修;等待维修时只记录下一次唤醒时间。""" + + def __init__( + self, + scheduler: TaskScheduler, + advance: Callable[[], DecisiveResult | None], + next_repair: Callable[[], RepairOutcome], + dispatch: Callable[[], RepairOutcome], + resume: Callable[[RepairOutcome], None], + park: Callable[[], bool] | None, + ) -> None: + self.scheduler = scheduler + self.advance = advance + self.next_repair = next_repair + self.resume = resume + self.park = park + self.node = ScheduledAction('决战节点', PRIO_DECISIVE, self._run_node) + self.repair = ScheduledAction( + '决战舰船入浴', PRIO_REQUESTED_REPAIR, lambda: self._route(dispatch()) + ) + self.resume_with: RepairOutcome | None = None + self.wake_at: float | None = None + self.result: DecisiveResult | None = None + # 冷启动也可能正停在决战里。第一次让出设备同样先确认现场。 + self.owns_ui = True + + def select(self, head: FightTask | ScheduledAction) -> FightTask | ScheduledAction: + """只有队首要操作其他页面时才暂离;未到安全页面则先恢复本节点。""" + if head is not self.node and self.owns_ui: + if self.park is None or not self.park(): + return self.node + self.owns_ui = False + return head + + def _run_node(self) -> None: + from autowsgr.ops.decisive.controller import DecisiveResult + + self.owns_ui = True + if self.resume_with is not None: + action, self.resume_with = self.resume_with, None + self.resume(action) + result = self.advance() + if result in (DecisiveResult.NODE_COMPLETE, DecisiveResult.RETRY): + self.scheduler._enqueue(self.node) + elif result is None: + # 控制器已确认暂离(或通关总览),可以把设备交给其他任务。 + self.owns_ui = False + self._route(self.next_repair()) + else: + self.result = result + + def _route(self, action: RepairOutcome) -> None: + from autowsgr.ops.decisive.controller import DecisiveResult + from autowsgr.ops.decisive.repair import RepairStatus + + self.wake_at = None + if action.status is RepairStatus.NEEDS_BATH: + self.scheduler._enqueue(self.repair) + if action.resume_immediately: + self.scheduler._enqueue(self.node) + elif action.status is RepairStatus.WAITING: + if action.wait_seconds is None or action.wait_seconds <= 0: + raise ValueError('缺少有效的决战维修复查时间') + self.scheduler._discard(self.node) + self.wake_at = time.monotonic() + action.wait_seconds + _log.info('[调度] {:.1f} 秒后复查决战维修,等待期间可执行日常任务', action.wait_seconds) + elif action.status is RepairStatus.STOPPED: + self.result = DecisiveResult.STOPPED + else: + self.resume_with = action + self.scheduler._enqueue(self.node) + + def wake_if_due(self) -> None: + if self.wake_at is not None and time.monotonic() >= self.wake_at: + # 只计算维修结果及入队。所有导航都在对应任务拿到设备后执行。 + self._route(self.next_repair()) diff --git a/autowsgr/scheduler/scheduler.py b/autowsgr/scheduler/scheduler.py index 069e4a24d..fd7740f6b 100644 --- a/autowsgr/scheduler/scheduler.py +++ b/autowsgr/scheduler/scheduler.py @@ -36,6 +36,10 @@ from collections.abc import Callable from autowsgr.context import GameContext + from autowsgr.infra.config import UserConfig + from autowsgr.ops.decisive.controller import DecisiveResult + from autowsgr.ops.decisive.repair import RepairOutcome + from autowsgr.scheduler.decisive import ScheduledAction from autowsgr.scheduler.triggers import Trigger _log = get_logger('scheduler') @@ -150,7 +154,7 @@ def __init__( self._last_expedition_time: float = 0.0 # 触发器调度 (auto_daily 长期挂机) self._triggers: list[Trigger] = [] - self._queue: list[FightTask] = [] + self._queue: list[FightTask | ScheduledAction] = [] self._last_date: date = date.today() # noqa: DTZ011 # 跨日按本地墙上时钟 (游戏 0 点刷新) # ── 任务管理 ── @@ -204,6 +208,50 @@ def run(self) -> list[FightTask]: self._print_summary() return list(self._tasks) + def run_decisive( + self, + advance: Callable[[], DecisiveResult | None], + next_repair: Callable[[], RepairOutcome], + dispatch: Callable[[], RepairOutcome], + resume: Callable[[RepairOutcome], None], + *, + park: Callable[[], bool] | None = None, + ) -> DecisiveResult: + """将一轮决战的节点和维修放进日常任务的同一队列,到大关结算后返回。""" + from autowsgr.ops.decisive.controller import DecisiveResult + from autowsgr.scheduler.decisive import DecisiveRound + + chapter = DecisiveRound(self, advance, next_repair, dispatch, resume, park) + stop = self._ctx.stop_event + self._enqueue(chapter.node) + try: + while not stop.is_set() and chapter.result is None: + chapter.wake_if_due() + if chapter.result is not None or stop.is_set(): + break + if self._run_ready(chapter.select) or stop.is_set(): + continue + # 等待期间设备空闲,仍按日常调度间隔检查远征、奖励等触发器。 + if chapter.wake_at is None: + raise RuntimeError('决战缺少待执行的任务或维修结束时间') + delay = max(0.0, chapter.wake_at - time.monotonic()) + stop.wait(min(self._idle_sleep, delay) if self._triggers else delay) + return chapter.result if chapter.result is not None else DecisiveResult.STOPPED + finally: + self._discard(chapter.node) + self._discard(chapter.repair) + + @classmethod + def for_decisive( + cls, ctx: GameContext, *, user_config: UserConfig | None = None + ) -> TaskScheduler: + """构建决战会话。跨轮复用,保留日常触发器的时钟和未完成任务。""" + from autowsgr.scheduler.daily_plan import build_daily_plan + + scheduler = cls(ctx, expedition_interval=0) + build_daily_plan(scheduler, ctx, decisive_session=True, user_config=user_config) + return scheduler + def _ensure_main_page_clean(self) -> None: """常驻弹窗检查: 每日首次消除主页面浮层 (新闻公告 / 每日签到 / 活动预约)。 @@ -222,7 +270,7 @@ def _ensure_main_page_clean(self) -> None: exc, ) - def _run_task(self, task: FightTask) -> None: + def _run_task(self, task: FightTask, *, check_expedition: bool = True) -> None: """执行单个任务的全部轮次。""" # 统一用 BatchRunnerAdapter 包装: 完整保留 run()→list[CombatResult], # 对 run()→单个 CombatResult 规范化为单元素列表, 兼容两类 runner @@ -251,7 +299,8 @@ def _run_task(self, task: FightTask) -> None: ) # 远征检查 (战斗前) — 仅旧 run() 路径有效;run_daily() 下由触发器接管 - self._maybe_collect_expedition() + if check_expedition: + self._maybe_collect_expedition() try: results = runner.run() @@ -357,43 +406,7 @@ def run_daily(self) -> None: self._sync_initial_counts() while not self._ctx.stop_event.is_set(): - self._check_daily_reset() - - # 收集触发器产出的新任务 - for trigger in self._triggers: - try: - task = trigger.should_fire(self._ctx) - except Exception as exc: - _log.opt(exception=True).warning( - '[Scheduler] 触发器 {} 异常: {}', - trigger.name, - exc, - ) - continue - if task is not None: - self._enqueue(task) - - # 取队首执行 - task = self._dequeue() - if task is not None: - try: - self._run_task(task) - except Exception as exc: - # _run_task 自身异常 (非 runner.run, 极少见) 兜底: 复位触发器 - # _idle 避免该触发器卡死不再产出, 继续主循环, 不崩溃脚本。 - _log.opt(exception=True).error( - '[Scheduler] 子任务 {} 执行崩溃, 已跳过: {}', - task.name, - exc, - ) - if task.on_done is not None: - try: - task.on_done( - CombatResult(flag=ConditionFlag.ACTION_FAILED), - ) - except Exception: # noqa: S110 # on_done 回调异常不应影响主循环 - pass - else: + if not self._run_ready(): # 队列空:所有触发器暂无任务 (常规战打满 / 只等远征定时) → 挂机等待 # 挂机期间顺带做常驻弹窗检查, 保证回到主页面时浮层不残留 self._ensure_main_page_clean() @@ -402,10 +415,50 @@ def run_daily(self) -> None: _log.info('[Scheduler] 收到停止信号, 调度结束') self._print_summary() - def _enqueue(self, task: FightTask) -> None: + def _run_ready( + self, + select: Callable[[FightTask | ScheduledAction], FightTask | ScheduledAction] | None = None, + ) -> bool: + """收集触发器产出的任务,串行执行一次。现场安全交接后才取走队首。""" + self._check_daily_reset() + for trigger in self._triggers: + try: + task = trigger.should_fire(self._ctx) + except Exception as exc: + _log.opt(exception=True).warning( + '[Scheduler] 触发器 {} 异常: {}', trigger.name, exc + ) + continue + if task is not None: + self._enqueue(task) + if not self._queue or self._ctx.stop_event.is_set(): + return False + selected = self._queue[0] + if select is not None: + selected = select(selected) + if self._ctx.stop_event.is_set(): + return True + self._discard(selected) + if not isinstance(selected, FightTask): + selected.run() + return True + try: + self._run_task(selected, check_expedition=False) + except Exception as exc: + _log.opt(exception=True).error('[Scheduler] 子任务 {} 执行崩溃: {}', selected.name, exc) + if selected.on_done is not None: + try: + selected.on_done(CombatResult(flag=ConditionFlag.ACTION_FAILED)) + except Exception as error: + _log.warning('[Scheduler] {} 结束回调失败: {}', selected.name, error) + return True + + def _enqueue(self, task: FightTask | ScheduledAction) -> None: """按 priority 插入队列 (数值小先出;同 priority FIFO)。""" idx = len(self._queue) for i, existing in enumerate(self._queue): + if existing is task: + return if existing.priority > task.priority: idx = i break @@ -417,7 +470,10 @@ def _enqueue(self, task: FightTask) -> None: len(self._queue), ) - def _dequeue(self) -> FightTask | None: + def _discard(self, task: FightTask | ScheduledAction) -> None: + self._queue[:] = [queued for queued in self._queue if queued is not task] + + def _dequeue(self) -> FightTask | ScheduledAction | None: """取出队首任务 (priority 最小者)。""" if not self._queue: return None diff --git a/autowsgr/scheduler/triggers.py b/autowsgr/scheduler/triggers.py index eac8eca13..86bd78fc7 100644 --- a/autowsgr/scheduler/triggers.py +++ b/autowsgr/scheduler/triggers.py @@ -88,8 +88,7 @@ def should_fire(self, ctx: GameContext) -> FightTask | None: raise NotImplementedError def reset(self) -> None: - """跨日/跨时段重置。子类按需重写。""" - self._idle = True + """跨日/跨时段只重置周期数据。已经排队的任务仍由完成回调解锁。""" def _build_task( self, @@ -125,12 +124,15 @@ def __init__( task_factory: TaskFactory, priority: int, name: str, + retry_interval: float = 0.0, ) -> None: super().__init__(priority=priority, name=name, task_factory=task_factory) self._exhausted = False + self._retry_interval = retry_interval + self._retry_after = 0.0 def should_fire(self, ctx: GameContext) -> FightTask | None: - if not self._idle or self._exhausted: + if not self._idle or self._exhausted or time.monotonic() < self._retry_after: return None self._idle = False return self._build_task(ctx, on_done=self._on_done) @@ -144,10 +146,16 @@ def _on_done(self, result: CombatResult) -> None: self.name, result.flag, ) + elif self._retry_interval and ( + result.flag in (ConditionFlag.ACTION_FAILED, ConditionFlag.SL) + or (result.flag is ConditionFlag.DOCK_FULL and not result.dock_full_destroyed) + ): + # 战役和演习优先于决战。页面一直出错时,留出一段时间让决战继续。 + self._retry_after = time.monotonic() + self._retry_interval + _log.warning('[调度] {} 本次未完成,{:.0f} 秒后重试', self.name, self._retry_interval) def reset(self) -> None: self._exhausted = False - self._idle = True # ═══════════════════════════════════════════════════════════════════════════════ @@ -212,8 +220,11 @@ def __init__( task_factory: TaskFactory, priority: int, name: str, + retry_interval: float = 0.0, ) -> None: - super().__init__(task_factory=task_factory, priority=priority, name=name) + super().__init__( + task_factory=task_factory, priority=priority, name=name, retry_interval=retry_interval + ) self._last_slot = self._current_slot() @staticmethod @@ -235,7 +246,6 @@ def should_fire(self, ctx: GameContext) -> FightTask | None: slot, ) self._exhausted = False - self._idle = True self._last_slot = slot return super().should_fire(ctx) @@ -435,6 +445,4 @@ def _on_done(self, result: CombatResult) -> None: def reset(self) -> None: for plan in self._plans: plan.completed = 0 - self._idle = True - self._current = None self._round_robin = 0 diff --git a/autowsgr/server/routes/task.py b/autowsgr/server/routes/task.py index 55c5aa4df..2d7cc9193 100644 --- a/autowsgr/server/routes/task.py +++ b/autowsgr/server/routes/task.py @@ -317,6 +317,8 @@ def executor(_task_info: Any) -> TaskOutcome: task_manager.update_progress(current_round=i + 1, current_node='决战') _log.info('[Task] 决战第 {}/{} 轮', i + 1, request.decisive_rounds) result = controller.run() + if result.value == 'stopped': + return TaskOutcome(results=results, success=False) is_error = result.value == 'error' converted = { 'round': i + 1, diff --git a/testing/ops/test_decisive_lifecycle.py b/testing/ops/test_decisive_lifecycle.py index 10603bb0e..ae309697f 100644 --- a/testing/ops/test_decisive_lifecycle.py +++ b/testing/ops/test_decisive_lifecycle.py @@ -4,7 +4,7 @@ import threading from types import SimpleNamespace -from unittest.mock import MagicMock +from unittest.mock import MagicMock, call import cv2 import numpy as np @@ -12,18 +12,25 @@ from autowsgr.combat.node_fusion.map import TrackingMap from autowsgr.combat.node_fusion.model import FusionTracker +from autowsgr.context import GameContext from autowsgr.emulator.frame import CapturedFrame from autowsgr.image_resources import Templates -from autowsgr.infra import DecisiveConfig +from autowsgr.infra import DecisiveConfig, EmulatorConfig, UserConfig from autowsgr.ops.decisive import handlers as handlers_module from autowsgr.ops.decisive.config import MapData -from autowsgr.ops.decisive.controller import DecisiveController +from autowsgr.ops.decisive.controller import DecisiveController, DecisiveResult from autowsgr.ops.decisive.logic import DecisiveLogic +from autowsgr.ops.decisive.repair import DecisiveRepairCoordinator from autowsgr.ops.decisive.state import DecisiveState from autowsgr.ops.decisive.tracking import DecisiveTrackingSession -from autowsgr.types import DecisiveEntryStatus, DecisivePhase, ShipDamageState +from autowsgr.types import DecisiveEntryStatus, DecisivePhase, OSType, ShipDamageState from autowsgr.ui.battle.fleet_change._detect import FleetSnapshot -from autowsgr.ui.decisive.battle_page import DecisiveBattlePage +from autowsgr.ui.decisive.battle_page import ( + CLICK_RESET_CHAPTER, + DecisiveBattlePage, + ResetConfirmationTimeoutError, +) +from autowsgr.vision import ImageChecker def _chapter_overview(visible_nodes: int, *, chapter: int = 6) -> np.ndarray: @@ -35,7 +42,7 @@ def _chapter_overview(visible_nodes: int, *, chapter: int = 6) -> np.ndarray: (round(template.width * 1280 / 960), round(template.height * 720 / 540)), ) height, width = patch.shape[:2] - image[600 : 600 + height, 500 : 500 + width] = patch + image[645 : 645 + height, 580 : 580 + width] = patch points = { 1: ((0.4115, 0.4019), (0.6604, 0.4630), (0.8396, 0.7093)), 6: ((0.606, 0.375), (0.532, 0.703), (0.862, 0.644)), @@ -59,25 +66,29 @@ def controller(monkeypatch: pytest.MonkeyPatch) -> DecisiveController: monkeypatch.setattr(handlers_module.time, 'sleep', lambda _: None) fleet = ['U1206', 'U2540', 'U1405', 'U47', 'U96', 'M296'] ctrl = DecisiveController.__new__(DecisiveController) - ctrl._ctx = SimpleNamespace( - stop_event=threading.Event(), - update_ship_damage=MagicMock(), - is_ship_available=lambda _name: True, - config=SimpleNamespace(log=SimpleNamespace(dir=None, node_fusion_replay=False)), - ) ctrl._ctrl = MagicMock() ctrl._ocr = MagicMock() - ctrl._config = DecisiveConfig(chapter=6, level1=fleet, useful_skill=False) + ctrl._config = DecisiveConfig(chapter=6, level1=fleet, flagship_priority=[], useful_skill=False) ctrl._state = DecisiveState(chapter=6, stage=1, phase=DecisivePhase.PREPARE_COMBAT) + ctrl._settings = UserConfig( + emulator=EmulatorConfig(serial='local', path='/tmp/emulator'), os_type=OSType.linux + ) + ctrl._ctx = GameContext(ctrl=ctrl._ctrl, ocr=ctrl._ocr, config=ctrl._settings) + ctrl._repairs = DecisiveRepairCoordinator(ctrl._ctx, ctrl._config, user_config=ctrl._settings) ctrl._logic = DecisiveLogic(ctrl._config, ctrl._state, ctx=ctrl._ctx) ctrl._map = MagicMock() + ctrl._map.try_leave_interrupted_sortie.return_value = False frame = CapturedFrame(np.zeros((2, 2, 3), dtype=np.uint8), 1, 1.0) ctrl._ctrl.screenshot.return_value = _chapter_overview(1) ctrl._map.wait_for_stable_map_frame.return_value = frame ctrl._map.detect_decisive_phase.return_value = DecisivePhase.PREPARE_COMBAT ctrl._map.recognize_node.return_value = None ctrl._map.is_skill_used.return_value = True - ctrl._map.check_fleet.return_value = (fleet, {}, set(fleet)) + ctrl._map.check_fleet.return_value = ( + fleet, + dict.fromkeys(range(6), ShipDamageState.NORMAL), + set(fleet), + ) ctrl._battle_page = MagicMock() ctrl._battle_page.detect_entry_status.return_value = DecisiveEntryStatus.CHALLENGING ctrl._battle_page.detect_stage.side_effect = DecisiveBattlePage.recognize_stage @@ -90,6 +101,7 @@ def controller(monkeypatch: pytest.MonkeyPatch) -> DecisiveController: page.change_fleet.return_value = True page.detect_fleet_snapshot.return_value = FleetSnapshot(fleet[:], [True] * 6) page.detect_ship_damage.return_value = dict.fromkeys(range(6), ShipDamageState.NORMAL) + page.read_repair_snapshot.return_value = (fleet[:], page.detect_ship_damage.return_value) monkeypatch.setattr( handlers_module, 'DecisiveBattlePreparationPage', MagicMock(return_value=page) ) @@ -125,11 +137,13 @@ def test_chapter_one_unknown_entry_preserves_recovery_scan(controller: DecisiveC def test_stop_during_repair_never_starts_another_battle(controller: DecisiveController) -> None: page = handlers_module.DecisiveBattlePreparationPage.return_value - page.apply_repair.side_effect = lambda *_args, **_kwargs: controller._ctx.stop_event.set() + _, damage = page.read_repair_snapshot.return_value + damage[5] = ShipDamageState.SEVERE + page.repair_slots.side_effect = lambda *_args, **_kwargs: controller._ctx.stop_event.set() controller._handle_prepare_combat() - page.apply_repair.assert_called_once() + page.repair_slots.assert_called_once() page.start_battle.assert_not_called() assert controller.state.phase == DecisivePhase.FINISHED assert not any( @@ -197,6 +211,91 @@ def test_unlit_nodes_do_not_identify_first_stage() -> None: assert DecisiveBattlePage.recognize_stage(_chapter_overview(0), 6) == 0 +def test_reset_timeout_retries_only_the_saved_first_stage(controller: DecisiveController) -> None: + page = controller._battle_page + controller._ctx.ctrl = controller._ctrl + page.detect_entry_status.side_effect = [ + DecisiveEntryStatus.REFRESH, + DecisiveEntryStatus.REFRESH, + DecisiveEntryStatus.REFRESHED, + ] + page._read_chapter.return_value = 6 + page.reset_chapter.side_effect = ResetConfirmationTimeoutError('第一小关未亮') + with pytest.raises(ResetConfirmationTimeoutError): + controller._handle_enter_map() + with pytest.raises(RuntimeError, match='无法继续'): + controller._handle_enter_map() + page.click_enter_map.assert_not_called() + controller._handle_enter_map() + page.reset_chapter.assert_called_once_with(6) + page.click_enter_map.assert_called_once() + + +@pytest.mark.parametrize('delayed', [False, True]) +def test_reset_waits_for_real_first_stage_without_repeating_clicks( + monkeypatch: pytest.MonkeyPatch, delayed: bool +) -> None: + ctx = SimpleNamespace(ctrl=MagicMock(), ocr=MagicMock(), stop_event=threading.Event()) + page = DecisiveBattlePage(ctx) + dialog = _chapter_overview(0) + wrong_chapter = _chapter_overview(1) + transition = [_chapter_overview(0), _chapter_overview(2), wrong_chapter] if delayed else [] + ctx.ctrl.screenshot.side_effect = [dialog, *transition, _chapter_overview(1)] + page._read_chapter = lambda screen: 5 if screen is wrong_chapter else 6 + wait = MagicMock() + monkeypatch.setattr(ctx.stop_event, 'wait', wait) + monkeypatch.setattr('autowsgr.ui.page.get_current_page', lambda *_args, **_kw: None) + match = ImageChecker.find_any + button = (0.6, 0.5) + monkeypatch.setattr( + ImageChecker, + 'find_any', + lambda screen, *args, **kw: ( + SimpleNamespace(center=button) if screen is dialog else match(screen, *args, **kw) + ), + ) + monkeypatch.setattr(ImageChecker, 'template_exists', lambda *_args, **_kw: False) + assert page.reset_chapter(6) + assert ctx.ctrl.click.call_args_list == [call(*CLICK_RESET_CHAPTER), call(*button)] + assert wait.call_count == len(transition) + + +@pytest.mark.parametrize( + ('chapter', 'status', 'stage', 'expected'), + [ + (6, DecisiveEntryStatus.CHALLENGING, 2, DecisiveResult.STOPPED), + (6, DecisiveEntryStatus.REFRESHED, 3, DecisiveResult.STOPPED), + (5, DecisiveEntryStatus.CHALLENGING, 2, DecisiveResult.ERROR), + (None, DecisiveEntryStatus.CHALLENGING, 2, DecisiveResult.ERROR), + (6, DecisiveEntryStatus.REFRESH, 1, DecisiveResult.ERROR), + (6, DecisiveEntryStatus.CHALLENGING, 0, DecisiveResult.ERROR), + ], +) +def test_cold_start_reenters_only_verified_saved_stage( + controller: DecisiveController, + chapter: int | None, + status: DecisiveEntryStatus, + stage: int, + expected: DecisiveResult, +) -> None: + controller._map.try_leave_interrupted_sortie.return_value = True + controller._battle_page._read_chapter.return_value = chapter + controller._battle_page.wait_for_entry_status.return_value = status, _chapter_overview(stage) + controller._prepare_entry_state = MagicMock() + controller._advance_until_repair = MagicMock(return_value=DecisiveResult.STOPPED) + + assert controller.run() is expected + controller._map.try_leave_interrupted_sortie.assert_called_once() + controller._prepare_entry_state.assert_not_called() + controller._battle_page.reset_chapter.assert_not_called() + if expected is DecisiveResult.STOPPED: + controller._battle_page.click_enter_map.assert_called_once() + assert controller.state.stage == stage + assert controller.state.phase == DecisivePhase.WAITING_FOR_MAP + else: + controller._battle_page.click_enter_map.assert_not_called() + + def test_unverified_retreat_does_not_create_a_start_prior(controller: DecisiveController) -> None: controller._known_start_stage = 1 controller._inventory_refresh_required = False @@ -208,6 +307,27 @@ def test_unverified_retreat_does_not_create_a_start_prior(controller: DecisiveCo assert controller._ensure_tracking().tracker.initial is None +def test_retreat_reenters_actual_stage_with_fresh_inventory(controller: DecisiveController) -> None: + controller._state.phase = DecisivePhase.RETREAT + controller._state.stage = 2 + controller._state.ships = {'旧舰'} + controller._ctrl.screenshot.return_value = _chapter_overview(2) + controller._map.wait_for_entry_phase.return_value = DecisivePhase.PREPARE_COMBAT + + def stop_on_prepare() -> None: + controller._ctx.stop_event.set() + + controller._handle_prepare_combat = MagicMock(side_effect=stop_on_prepare) + assert controller._main_loop() == DecisiveResult.STOPPED + controller._map.confirm_retreat.assert_called_once() + controller._battle_page.reset_chapter.assert_not_called() + controller._battle_page.click_enter_map.assert_called_once() + assert controller.state.stage == 2 + assert controller.state.ships == set() + assert controller._inventory_refresh_required + assert controller._known_start_stage is None + + def test_metadata_reports_missing_facts_without_disabling_decisive_history() -> None: metadata = TrackingMap.from_dict({'A': {'next': ['B']}, 'B': {'next': []}}) reasons = ';'.join(metadata.degradation_reasons) @@ -217,3 +337,184 @@ def test_metadata_reports_missing_facts_without_disabling_decisive_history() -> assert '停用' not in reasons tracker = FusionTracker(metadata, dynamics='decisive', initial={'A': 1.0}) assert tracker.estimate.current_node == 'A' + + +@pytest.mark.parametrize('value', [-1, False, True, 1.5, '60']) +def test_repair_threshold_requires_a_nonnegative_integer(value: object) -> None: + from pydantic import ValidationError + + with pytest.raises(ValidationError, match='quick_repair_threshold_seconds'): + UserConfig( + emulator=EmulatorConfig(serial='local', path='/tmp/emulator'), + os_type=OSType.linux, + quick_repair_threshold_seconds=value, + ) + + +@pytest.mark.parametrize( + ('failures', 'expected'), [(2, DecisiveResult.CHAPTER_CLEAR), (3, DecisiveResult.ERROR)] +) +def test_transient_failures_share_three_attempts( + controller: DecisiveController, failures: int, expected: DecisiveResult +) -> None: + controller._prepare_entry_state = MagicMock() + controller._advance_until_repair = MagicMock( + side_effect=[ + *[TimeoutError('识别超时') for _ in range(failures)], + DecisiveResult.CHAPTER_CLEAR, + ] + ) + controller._battle_page.is_current_page.return_value = True + assert controller.run() is expected + assert controller._advance_until_repair.call_count == 3 + controller._prepare_entry_state.assert_called_once() + + +def test_waiting_can_stop_without_restarting_the_round(controller: DecisiveController) -> None: + from autowsgr.ops.decisive.repair import RepairOutcome, RepairStatus + + controller._prepare_entry_state = MagicMock() + + def begin_wait() -> None: + controller.state.phase = DecisivePhase.WAITING_FOR_REPAIR + + controller._handle_enter_map = MagicMock(side_effect=begin_wait) + controller._repairs.poll = MagicMock(return_value=RepairOutcome(RepairStatus.WAITING, 4, 180)) + controller._ctx.stop_event.wait = MagicMock( + side_effect=lambda _: controller._ctx.stop_event.set() + ) + assert controller.run_for_times(2) == [DecisiveResult.STOPPED] + controller._prepare_entry_state.assert_called_once() + controller._handle_enter_map.assert_called_once() + controller._map.confirm_retreat.assert_not_called() + + +@pytest.mark.parametrize('saved_chapter', [6, 5]) +def test_run_resumes_saved_repair_only_after_fresh_health( + controller: DecisiveController, monkeypatch: pytest.MonkeyPatch, saved_chapter: int +) -> None: + """从本轮入口穿过保存、两次等待、重入库存核实,最后才允许首次出击。""" + controller._ctx.ctrl = controller._ctrl + controller._battle_page._read_chapter.return_value = saved_chapter + controller._map.wait_for_entry_phase.return_value = DecisivePhase.PREPARE_COMBAT + controller._map.is_map_page.side_effect = [False, True] + navigate = MagicMock() + monkeypatch.setattr('autowsgr.ops.navigate.goto_page', navigate) + page = handlers_module.DecisiveBattlePreparationPage.return_value + names, initial = page.read_repair_snapshot.return_value + damage = dict(initial) + damage[5] = ShipDamageState.REPAIRING + now = 0.0 + controller._repairs._clock = lambda: now + monkeypatch.setattr('autowsgr.scheduler.decisive.time.monotonic', lambda: now) + + def read_slots(*, fresh: bool = False) -> tuple[list[str], dict[int, ShipDamageState]]: + if fresh: + assert now == 180 + damage[5] = ShipDamageState.NORMAL + return names, damage.copy() + + def wait(seconds: float) -> bool: + nonlocal now + expected = 180 - now + assert seconds == expected + page.start_battle.assert_not_called() + controller._battle_page.click_enter_map.assert_called_once() + now += min(seconds, 179) + return False + + page.read_repair_snapshot.side_effect = read_slots + controller._ctx.stop_event.wait = MagicMock(side_effect=wait) + page.start_battle.side_effect = controller._ctx.stop_event.set + result = controller.run() + assert now == 180 + assert controller._ctx.stop_event.wait.call_count == 2 + controller._map.leave_to_overview.assert_called_once() + controller._battle_page.reset_chapter.assert_not_called() + controller._battle_page.navigate_to_chapter.assert_called_once_with(6) + page.repair_slots.assert_not_called() + if saved_chapter == 6: + assert result is DecisiveResult.STOPPED + page.read_repair_snapshot.assert_any_call(fresh=True) + assert controller._map.check_fleet.call_count == 2 + assert controller._battle_page.click_enter_map.call_count == 2 + page.start_battle.assert_called_once() + else: + assert result is DecisiveResult.ERROR + controller._battle_page.click_enter_map.assert_called_once() + assert controller._repairs.saved + page.start_battle.assert_not_called() + + +def test_full_dock_enters_destroy_directly_from_dialog( + controller: DecisiveController, monkeypatch: pytest.MonkeyPatch +) -> None: + destroy = MagicMock(return_value=True) + monkeypatch.setattr('autowsgr.ops.destroy.destroy_ships_auto', destroy) + controller._config = DecisiveConfig(full_destroy=True) + controller._do_dock_full_destroy() + destroy.assert_called_once_with(controller._ctx, from_dialog=True) + controller._ctrl.click.assert_not_called() + + +def test_node_yields_after_overlays_before_next_formation(controller: DecisiveController) -> None: + controller.state.node_completed = True + controller.state.phase = DecisivePhase.CHOOSE_FLEET + order = [] + + def finish_purchase() -> None: + order.append('购舰') + controller.state.phase = DecisivePhase.PREPARE_COMBAT + + def stable_map() -> bool: + order.append('确认下一节点地图') + return True + + controller._handle_choose_fleet = finish_purchase + controller._prepare_map_tracking = stable_map + assert controller._advance_node() is DecisiveResult.NODE_COMPLETE + assert order == ['购舰', '确认下一节点地图'] + assert controller.state.at_node_boundary + controller._map.enter_formation.assert_not_called() + controller._map.leave_to_overview.assert_not_called() + + # 只有外部任务真正拿到设备才暂离。同一小关保留定位和战斗历史。 + session = controller._tracking + assert controller._park_for_daily() + assert controller._park_for_daily() + controller._map.leave_to_overview.assert_called_once() + assert controller.state.expected_stage == 1 + assert controller._tracking is session + assert controller.state.navigate_to_entry + + +def test_retry_after_reentry_recovers_inside_map(controller: DecisiveController) -> None: + controller._repairs._saved = True + controller.state.phase = DecisivePhase.WAITING_FOR_MAP + controller._battle_page.is_current_page.return_value = False + controller._map.is_fleet_preparation.return_value = False + controller._map.detect_decisive_phase.return_value = DecisivePhase.PREPARE_COMBAT + controller._advance_until_repair = MagicMock( + side_effect=[TimeoutError(), DecisiveResult.NODE_COMPLETE] + ) + controller._prepare_entry_state = MagicMock() + + assert controller._advance_node() is DecisiveResult.RETRY + assert not controller._park_for_daily() + assert controller._advance_node() is DecisiveResult.NODE_COMPLETE + assert controller.state.phase is DecisivePhase.PREPARE_COMBAT + controller._prepare_entry_state.assert_not_called() + controller._battle_page.click_enter_map.assert_not_called() + + +def test_inventory_survives_temporary_leave_only_on_same_map( + controller: DecisiveController, +) -> None: + controller.state.ships = {'U-96'} + controller.state.fleet[1] = 'U-96' + controller._enter_verified_stage(1) + assert controller.state.ships == {'U-96'} + assert controller.state.fleet[1] == 'U-96' + controller._enter_verified_stage(2) + assert not controller.state.ships + assert not any(controller.state.fleet) diff --git a/testing/ops/test_decisive_node_handoff.py b/testing/ops/test_decisive_node_handoff.py new file mode 100644 index 000000000..1eabfda37 --- /dev/null +++ b/testing/ops/test_decisive_node_handoff.py @@ -0,0 +1,178 @@ +"""按 6-2 E 战果至 F 出征的实机记录,验证战备、暂离、入浴与续战顺序。""" + +from __future__ import annotations + +import itertools +import time +from typing import TYPE_CHECKING +from unittest.mock import MagicMock + +import numpy as np + +from autowsgr.combat.history import CombatResult +from autowsgr.context import GameContext +from autowsgr.emulator.frame import CapturedFrame +from autowsgr.infra import DecisiveConfig, EmulatorConfig, UserConfig +from autowsgr.ops.decisive.controller import DecisiveController, DecisiveResult +from autowsgr.scheduler import TaskScheduler +from autowsgr.types import ConditionFlag, DecisiveEntryStatus, DecisivePhase, FleetSelection, OSType +from autowsgr.types import ShipDamageState as Damage +from autowsgr.ui.bath_page.page import RepairShipInfo +from autowsgr.ui.bath_page.signatures import SWIPE_DELAY + + +if TYPE_CHECKING: + from collections.abc import Callable + + import pytest + + from autowsgr.combat.plan import CombatPlan + + +_E_FLEET = ['U-1405', 'U-1206', '351', 'U-2540', '鲃鱼', 'U-47'] + + +def _stub_pages( + ctrl: DecisiveController, monkeypatch: pytest.MonkeyPatch, events: list[str] +) -> None: + def record(name: str, result: object = None) -> Callable[..., object]: + def observed(*_args: object, **_kwargs: object) -> object: + events.append(name) + return result + + return observed + + sequence = itertools.count(1) + screen = np.zeros((2, 2, 3), dtype=np.uint8) + + def capture() -> CapturedFrame: + return CapturedFrame(screen, next(sequence), time.monotonic()) + + ctrl._ctrl.capture_frame.side_effect = capture + ctrl._map = map_page = MagicMock() + map_page.is_stage_clear.return_value = False + map_page.detect_decisive_phase.side_effect = [ + DecisivePhase.CHOOSE_FLEET, + DecisivePhase.PREPARE_COMBAT, + DecisivePhase.PREPARE_COMBAT, + ] + offer = FleetSelection('肌肉记忆', 3, (0.8, 0.5)) + map_page.recognize_fleet_options.return_value = (3, {offer.name: offer}) + map_page.buy_fleet_option.side_effect = record('购买肌肉记忆') + map_page.close_fleet_overlay.side_effect = record('关闭战备', True) + + def stable_map() -> CapturedFrame: + events.append('确认稳定地图') + return capture() + + map_page.wait_for_stable_map_frame.side_effect = stable_map + map_page.recognize_node.side_effect = record('识别 F', 'F') + map_page.leave_to_overview.side_effect = record('暂离至总览') + map_page.wait_for_entry_phase.return_value = DecisivePhase.PREPARE_COMBAT + map_page.is_skill_used.side_effect = record('检查 F 技能', True) + map_page.enter_formation.side_effect = record('打开 F 编队') + ctrl._battle_page = overview = MagicMock() + overview.detect_entry_status.return_value = DecisiveEntryStatus.CHALLENGING + overview._read_chapter.return_value, overview.detect_stage.return_value = 6, 2 + overview.click_enter_map.side_effect = record('重进 6-2') + monkeypatch.setattr('autowsgr.ops.navigate.goto_page', MagicMock()) + monkeypatch.setattr('autowsgr.ops.decisive.repair.goto_page', MagicMock()) + bath = MagicMock() + bath.has_choose_repair_overlay.return_value = False + card = RepairShipInfo('351', (0.3, 0.4), '00:12:18') + bath.recognize_repair_ships.return_value = [card] + bath.wait_repair_accepted.side_effect = record('确认 351 入浴', True) + monkeypatch.setattr('autowsgr.ops.decisive.repair.BathPage', lambda _ctx: bath) + + fleet = _E_FLEET.copy() + + def snapshot(**_kwargs: bool) -> tuple[list[str], dict[int, Damage]]: + return fleet.copy(), { + i: Damage.REPAIRING if name == '351' else Damage.NORMAL for i, name in enumerate(fleet) + } + + def swap(_fleet_id: int | None, target: list[str]) -> bool: + assert target == [ship for ship in _E_FLEET if ship != '351'] + ['U-96'] + events.append('换入 U-96') + fleet[:] = target + return True + + map_page.check_fleet.side_effect = lambda _observer: (*snapshot(), {*_E_FLEET, 'U-96'}) + prep = MagicMock() + prep.change_fleet.side_effect = swap + prep.read_repair_snapshot.side_effect = snapshot + prep.start_battle.side_effect = record('F 出征') + monkeypatch.setattr( + 'autowsgr.ops.decisive.handlers.DecisiveBattlePreparationPage', lambda *_: prep + ) + + +def test_351_enters_bath_after_f_purchase_then_u96_sorties_once( + monkeypatch: pytest.MonkeyPatch, +) -> None: + config = UserConfig( + emulator=EmulatorConfig(serial='local', path='/tmp/emulator'), + os_type=OSType.linux, + quick_repair_threshold_seconds=900, + repair_manually=False, + ) + ctx = GameContext(ctrl=MagicMock(), ocr=MagicMock(), config=config) + ctrl = DecisiveController(ctx, DecisiveConfig(chapter=6, level1=_E_FLEET, level2=['U-96'])) + ctrl._scheduler = TaskScheduler(ctx, expedition_interval=0) + ctrl.state.stage, ctrl.state.node, ctrl.state.phase = 2, 'E', DecisivePhase.IN_COMBAT + ctrl.state.fleet, ctrl.state.ships = ['', *_E_FLEET], {*_E_FLEET, 'U-96'} + ctrl._has_chosen_fleet = True + events = [] + _stub_pages(ctrl, monkeypatch, events) + + # U-96 可以马上补位。调度器若误等 738 秒,应立即让本次测试失败。 + def wait(seconds: float) -> bool: + assert seconds <= SWIPE_DELAY + return False + + monkeypatch.setattr(ctx.stop_event, 'wait', wait) + session = ctrl._ensure_tracking() + session.map_ready(ctx.ctrl.capture_frame(), 'E') + assert session.current_node == 'E' + e_encounter = ctrl._battle_encounter_id = session.encounter_id + health = [Damage.NORMAL] * 6 + + def combat(plan: CombatPlan) -> CombatResult: + if plan.name == '决战-2-E': + events.append('E 战果 351 中破') + return CombatResult( + flag=ConditionFlag.OPERATION_SUCCESS, + ship_stats=[*health[:2], Damage.MODERATE, *health[3:]], + ) + assert plan.name == '决战-2-F' + events.append('F 战斗') + ctx.stop_event.set() + return CombatResult(flag=ConditionFlag.OPERATION_SUCCESS, ship_stats=health) + + monkeypatch.setattr(ctrl, '_run_combat', combat) + assert ctrl._main_loop() is DecisiveResult.STOPPED + # 暂离前可能已经认出了 F,重进地图后仍要从新画面识别 F。 + left = events.index('暂离至总览') + assert [event for event in events[:left] if event != '识别 F'] == [ + 'E 战果 351 中破', + '购买肌肉记忆', + '关闭战备', + '确认稳定地图', + ] + assert events[left:] == [ + '暂离至总览', + '确认 351 入浴', + '重进 6-2', + '确认稳定地图', + '识别 F', + '检查 F 技能', + '打开 F 编队', + '换入 U-96', + 'F 出征', + 'F 战斗', + ] + assert session.completed_encounter(e_encounter).decision_node == 'E' + assert ctrl._tracking is session + ctrl._map.buy_fleet_option.assert_called_once_with((0.8, 0.5)) + ctx.ctrl.click.assert_called_once_with(0.3, 0.4) + assert ctx.quick_repair_used == 0 diff --git a/testing/ops/test_decisive_purchases.py b/testing/ops/test_decisive_purchases.py index 2e1d9c46a..362379b0c 100644 --- a/testing/ops/test_decisive_purchases.py +++ b/testing/ops/test_decisive_purchases.py @@ -1,25 +1,33 @@ -"""库存必须完整核实,技能筛选和目标编队消费实际快照。""" +"""购买和技能使用后核实编队与首屏可选舰船。""" from __future__ import annotations import threading from types import SimpleNamespace +from typing import TYPE_CHECKING from unittest.mock import MagicMock import numpy as np import pytest +from autowsgr.context import GameContext from autowsgr.infra import DecisiveConfig, EmulatorConfig, UserConfig from autowsgr.ops.decisive.controller import DecisiveController from autowsgr.types import DecisivePhase, FleetSelection, OSType, ShipDamageState -from autowsgr.ui.battle.fleet_change._detect import FleetSnapshot from autowsgr.ui.decisive.fleet_ocr import recognize_fleet_options +from autowsgr.vision import OCRResult -def _controller(*, strict: bool = False) -> DecisiveController: +if TYPE_CHECKING: + from collections.abc import Callable + + +def _controller( + *, strict: bool = False, reserves: tuple[str, ...] = (), threshold: int | None = None +) -> DecisiveController: config = DecisiveConfig( level1=['U-2540', 'U-96', 'U-1206', 'M-296', 'U-47', '351'], - level2=[], + level2=list(reserves), flagship_priority=['U-2540', 'U-1206'], useful_skill=strict, useful_skill_strict=strict, @@ -32,11 +40,14 @@ def _controller(*, strict: bool = False) -> DecisiveController: emulator=EmulatorConfig(serial='127.0.0.1:5555', path='/tmp/emulator'), os_type=OSType.linux, decisive_battle=config, + quick_repair_threshold_seconds=threshold, ), stop_event=threading.Event(), update_ship_damage=MagicMock(), + ship_registry={}, is_ship_available=lambda _name: True, ) + ctx.get_ship = GameContext.get_ship.__get__(ctx) controller = DecisiveController(ctx, config) controller.state.stage = 1 controller.state.node = 'B' @@ -53,12 +64,24 @@ def _controller(*, strict: bool = False) -> DecisiveController: return controller +def _damage(names: list[str | None]) -> dict[int, ShipDamageState]: + return { + slot: ShipDamageState.NORMAL if name else ShipDamageState.NO_SHIP + for slot, name in enumerate(names) + } + + def _page(monkeypatch: pytest.MonkeyPatch, names: list[str | None]) -> MagicMock: page = MagicMock() + current = ['U-1206', 'M-296', None, None, None, None] + + def read_snapshot(**_options: bool) -> tuple[list[str | None], dict[int, ShipDamageState]]: + visible = names if page.change_fleet.called else current + return visible[:], _damage(visible) + + page.read_repair_snapshot.side_effect = read_snapshot page.change_fleet.return_value = True - page.detect_fleet_snapshot.return_value = FleetSnapshot( - names=names[:], occupied=[name is not None for name in names] - ) + page.read_first_screen_candidates.return_value = {name for name in names if name} page.detect_ship_damage.return_value = { slot: ShipDamageState.NORMAL if name else ShipDamageState.NO_SHIP for slot, name in enumerate(names) @@ -100,7 +123,7 @@ def test_zero_budget_replaces_previous_budget(after_refresh: bool) -> None: controller._handle_choose_fleet() assert controller.state.score == 0 controller._map.buy_fleet_option.assert_not_called() - assert not controller._inventory_refresh_required + assert controller._inventory_refresh_required assert controller._map.refresh_fleet.call_count == int(after_refresh) @@ -130,7 +153,7 @@ def test_preparation_uses_scanned_inventory_after_purchase( available = {'U-1206', 'M-296'} | ({'U-2540'} if actually_owned else set()) controller._map.check_fleet.return_value = ( ['U-1206', 'M-296', None, None, None, None], - {}, + _damage(['U-1206', 'M-296', None, None, None, None]), available, ) expected = ( @@ -157,7 +180,7 @@ def test_skill_ocr_also_requires_real_inventory( available = {'U-1206', 'M-296', 'U-81'} controller._map.check_fleet.return_value = ( ['U-1206', 'M-296', None, None, None, None], - {}, + _damage(['U-1206', 'M-296', None, None, None, None]), available, ) page = _page(monkeypatch, ['U-1206', 'M-296', None, None, None, None]) @@ -184,11 +207,11 @@ def test_inventory_refresh_failure_preserves_previous_snapshot( elif failure == 'missing_member': controller._map.check_fleet.return_value = (fleet, {}, set()) elif failure == 'sync': - controller._map.check_fleet.return_value = (fleet, {}, {'U-1206'}) + controller._map.check_fleet.return_value = (fleet, _damage(fleet), {'U-1206'}) controller._ctx.update_ship_damage.side_effect = RuntimeError('registry unavailable') else: - def stopped_scan() -> tuple: + def stopped_scan(_report: object) -> tuple: controller._ctx.stop_event.set() return fleet, {}, {'U-1206'} @@ -250,7 +273,7 @@ def test_verified_inventory_without_changes_skips_scan_but_checks_actual_fleet( controller._handle_prepare_combat() controller._map.check_fleet.assert_not_called() page.change_fleet.assert_not_called() - page.detect_fleet_snapshot.assert_called_once_with() + page.read_repair_snapshot.assert_called_once_with() assert not controller._inventory_refresh_required page.start_battle.assert_called_once() @@ -260,7 +283,7 @@ def test_refresh_copies_complete_snapshot_and_clears_old_tail() -> None: controller._inventory_refresh_required = True fleet = ['U-1206', None, None, None, None, None] inventory = {'U-1206', 'U-96'} - controller._map.check_fleet.return_value = (fleet, {}, inventory) + controller._map.check_fleet.return_value = (fleet, _damage(fleet), inventory) controller._refresh_inventory() assert controller.state.fleet == ['', 'U-1206', '', '', '', '', ''] assert controller.state.ship_stats == [ShipDamageState.NORMAL] + [ShipDamageState.NO_SHIP] * 5 @@ -271,6 +294,24 @@ def test_refresh_copies_complete_snapshot_and_clears_old_tail() -> None: assert not controller._inventory_refresh_required +def test_resume_retains_previously_seen_reserves_until_stage_changes() -> None: + controller = _controller(reserves=('大青花鱼',)) + ships = [*controller._config.level1, '大青花鱼'] + fleet = [*ships[:5], None] + controller._map.check_fleet.return_value = (fleet, _damage(fleet), set(ships)) + controller._refresh_inventory() + + controller._map.check_fleet.return_value = (fleet, _damage(fleet), set(ships[:5])) + controller._refresh_inventory() + assert controller.state.ships == set(ships) + assert sum(bool(name) for name in controller._logic.get_best_fleet()) == 6 + + controller._repairs.reset_stage() + controller.state.stage = 2 + controller._refresh_inventory() + assert controller.state.ships == set(ships[:5]) + + def test_refresh_publishes_three_in_team_ships_without_reserve_inventory() -> None: """UI 已合并空候选与在队成员;这里只验证完整三元组的业务发布。""" controller = _controller() @@ -290,7 +331,7 @@ def test_refresh_publishes_three_in_team_ships_without_reserve_inventory() -> No controller._refresh_inventory() - controller._map.check_fleet.assert_called_once_with() + controller._map.check_fleet.assert_called_once() assert controller.state.ships == {'U-1206', 'M-296', '351'} assert controller.state.fleet == ['', 'U-1206', 'M-296', '351', '', '', ''] assert controller.state.ship_stats == stats @@ -310,7 +351,7 @@ def test_strict_skill_refreshes_full_pre_skill_inventory_before_duplicate_check( controller._map.is_skill_used.return_value = False all_ships = set(controller._config.level1) | {f'other-{index}' for index in range(9)} trace = [] - controller._map.check_fleet.side_effect = lambda: ( + controller._map.check_fleet.side_effect = lambda _report: ( trace.append('scan') or ([None] * 6, {}, all_ships) ) controller._map.use_skill.side_effect = lambda: trace.append('skill') or ['U-96'] @@ -336,11 +377,11 @@ def test_skill_and_purchase_refreshes_merge_unless_strict_needs_pre_skill_snapsh before = {'U-1206', 'M-296'} after = before | {'U-96'} - def scan() -> tuple: + def scan(_report: object) -> tuple: trace.append('scan') return ( ['U-1206', 'M-296', None, None, None, None], - {}, + _damage(['U-1206', 'M-296', None, None, None, None]), before if trace == ['scan'] else after, ) @@ -355,7 +396,16 @@ def scan() -> tuple: @pytest.mark.parametrize( - 'failure', ['false_return', 'wrong_name', 'unknown', 'extra_ship', 'wrong_occupancy'] + 'failure', + [ + 'false_return', + 'wrong_name', + 'wrong_order', + 'wrong_and_unknown', + 'extra_ship', + 'empty_slot', + 'wrong_occupancy', + ], ) def test_unverified_fleet_change_never_repairs_or_starts( monkeypatch: pytest.MonkeyPatch, failure: str @@ -363,21 +413,225 @@ def test_unverified_fleet_change_never_repairs_or_starts( controller = _controller() controller.state.ships.add('U-2540') old_fleet = controller.state.fleet[:] - page = _page(monkeypatch, ['U-2540', 'U-1206', 'M-296', None, None, None]) + names = ['U-2540', 'U-1206', 'M-296', None, None, None] + damage = _damage(names) + page = _page(monkeypatch, names) if failure == 'false_return': page.change_fleet.return_value = False elif failure == 'wrong_name': - page.detect_fleet_snapshot.return_value.names[0] = 'U-96' - elif failure == 'unknown': - page.detect_fleet_snapshot.return_value.names[0] = None + names[0] = 'U-96' + elif failure == 'wrong_order': + names[:2] = ['U-1206', 'U-2540'] + elif failure == 'wrong_and_unknown': + names[:2] = [None, 'U-96'] + elif failure == 'empty_slot': + names[0] = None + damage[0] = ShipDamageState.NO_SHIP elif failure == 'wrong_occupancy': - page.detect_fleet_snapshot.return_value.occupied[0] = False + damage[0] = ShipDamageState.NO_SHIP else: - page.detect_fleet_snapshot.return_value.names[5] = 'U-96' - page.detect_fleet_snapshot.return_value.occupied[5] = True - with pytest.raises(RuntimeError, match='编队'): + names[5] = 'U-96' + damage[5] = ShipDamageState.NORMAL + before = old_fleet[1:] + page.read_repair_snapshot.side_effect = lambda **_: ( + (names, damage) if page.change_fleet.called else (before, _damage(before)) + ) + with pytest.raises(RuntimeError, match=r'编队|未能确认全部舰船'): controller._handle_prepare_combat() assert controller.state.fleet == old_fleet assert controller._inventory_refresh_required + assert all(c.kwargs['fresh'] for c in page.read_repair_snapshot.call_args_list[1:]) page.apply_repair.assert_not_called() page.start_battle.assert_not_called() + + +@pytest.mark.parametrize('fresh_flagship', ['U-1405', 'U-505', None]) +def test_occupied_slot_without_name_verifies_entire_fresh_fleet(fresh_flagship: str | None) -> None: + controller = _controller() + target = ['', 'U-1405', 'U-1206', '351', 'U-2540', '鲃鱼', 'U-47'] + controller.state.fleet = target.copy() + page = MagicMock() + # 实机 UI405 同时匹配 U-1405 和 U-505,前一帧的编队不能证明这一槽的身份。 + first = ([None, *target[2:]], _damage(target[1:])) + later = ([fresh_flagship, *target[2:]], _damage(target[1:])) + page.read_repair_snapshot.side_effect = [first, *([later] * 5)] + if fresh_flagship == 'U-1405': + controller._verify_prepared_fleet(page, target) + assert not controller._inventory_refresh_required + else: + with pytest.raises(RuntimeError, match=r'编队|未能确认全部舰船'): + controller._verify_prepared_fleet(page, target) + assert controller._inventory_refresh_required + assert page.read_repair_snapshot.call_args_list[0].kwargs == {'fresh': True} + assert controller.state.fleet == target + page.change_fleet.assert_not_called() + page.read_first_screen_candidates.assert_not_called() + + +def test_first_node_prefers_two_new_ships_then_primary_then_lowest_cost() -> None: + controller = _controller(reserves=('替补',)) + controller.state.ships = {'未配置'} + controller.state.score = 6 + offers = { + name: FleetSelection(name, cost, (0.25, 0.5)) + for name, cost in [ + ('U-2540', 6), + ('U-96', 3), + ('U-1206', 2), + ('351', 3), + ('替补', 0), + ] + } + assert controller._logic.choose_ships(offers, first_node=True) == ['U-96', 'U-1206'] + + +def test_full_fleet_buys_missing_primary_before_upgrade() -> None: + controller = _controller(reserves=('替补',)) + controller.state.ships = {*controller._config.level1[1:], '替补'} + controller.state.score = 4 + offers = { + name: FleetSelection(name, cost, (0.25, 0.5)) + for name, cost in [ + ('U-2540', 3), + ('U-96', 2), + ('U-1206', 1), + ('替补', 0), + ] + } + assert controller._logic.choose_ships(offers) == ['U-2540', 'U-1206'] + + +def test_close_failure_buys_cheapest_remaining_affordable_ship_then_retreats() -> None: + controller = _controller() + frame = np.zeros((54, 96, 3), dtype=np.uint8) + initial = {'U-2540': FleetSelection('U-2540', 1, (0.25, 0.5))} + remaining = { + name: FleetSelection(name, cost, (x, 0.5)) + for name, cost, x in [ + ('U-2540', 0, 0.25), + ('长跑训练', 0, 0.375), + ('舰乙', 2, 0.5), + ('舰丙', 1, 0.625), + ] + } + controller._recognize_fleet_options_with_retry = MagicMock( + side_effect=[(frame, 3, initial), (frame, 2, remaining)] + ) + controller._map.close_fleet_overlay.side_effect = [False, True] + controller._handle_choose_fleet() + assert [click.args[0] for click in controller._map.buy_fleet_option.call_args_list] == [ + (0.25, 0.5), + (0.625, 0.5), + ] + assert controller.state.phase == DecisivePhase.RETREAT + assert controller.state.ships == {'U-1206', 'M-296'} + + +def test_missing_or_ambiguous_price_cannot_shift_adjacent_cards() -> None: + frame = np.zeros((720, 1280, 3), dtype=np.uint8) + ocr = MagicMock() + ocr.recognize_number.return_value = 8 + ocr.recognize.return_value = [ + OCRResult('x5', 0.9, (380, 4, 402, 26)), # 第三张卡 + OCRResult('x1', 0.9, (55, 4, 80, 26)), # 第一张卡的两次读数冲突 + OCRResult('x4', 0.9, (65, 4, 92, 26)), + OCRResult('x3', 0.9), + ] + ocr.recognize_ship_name.return_value = 'U-96' + _, available = recognize_fleet_options(ocr, frame) + assert available == {'U-96': FleetSelection('U-96', 5, (0.5, 0.5))} + + +def test_short_fleet_at_a_retreats_after_reading_inventory(monkeypatch: pytest.MonkeyPatch) -> None: + controller = _controller() + controller.state.node = 'A' + controller._inventory_refresh_required = True + fleet = ['U-96', None, None, None, None, None] + controller._map.check_fleet.return_value = (fleet, _damage(fleet), {'U-96'}) + page = _page(monkeypatch, fleet) + controller._handle_prepare_combat() + assert controller.state.phase == DecisivePhase.RETREAT + page.start_battle.assert_not_called() + + +def test_repairing_primary_uses_healthy_reserve_before_departure( + monkeypatch: pytest.MonkeyPatch, +) -> None: + controller = _controller(reserves=('替补',)) + fleet = controller._config.level1[:] + replacement = [*fleet[1:], '替补'] + replacement[0], replacement[1] = replacement[1], replacement[0] + controller.state.ships = {*fleet, '替补'} + page = _page(monkeypatch, replacement) + + def observe(**_options: bool) -> tuple[list[str | None], dict[int, ShipDamageState]]: + names = replacement if page.change_fleet.called else fleet + health = _damage(names) + if names == fleet: + health[0] = ShipDamageState.REPAIRING + return names, health + + page.read_repair_snapshot.side_effect = observe + controller._handle_prepare_combat() + page.change_fleet.assert_called_once_with(None, replacement) + assert controller.state.fleet[1:] == replacement + assert controller._repairs.blocked_identities + page.start_battle.assert_called_once() + + +def test_inventory_scan_starts_blind_timer_on_first_observation() -> None: + controller = _controller() + repairs = controller._repairs + clock = MagicMock(return_value=100.0) + repairs._clock = clock + + def scan(report: Callable[[str], None]) -> tuple: + report('U-96') + clock.return_value += 179 + report('U-96') + assert not repairs.due_identities + clock.return_value += 1 + report('U-96') + assert repairs.due_identities + fleet = ['U-96', None, None, None, None, None] + # 旧快照不解除到期标志,回到准备页时从新帧核实。 + return fleet, _damage(fleet), {'U-96'} + + controller._map.check_fleet.side_effect = scan + controller._refresh_inventory() + assert repairs.due_identities + + +def test_verified_fleet_change_uses_new_snapshot_without_opening_inventory( + monkeypatch: pytest.MonkeyPatch, +) -> None: + controller = _controller() + target = ['', 'M-296', 'U-1206', '', '', '', ''] + page = _page(monkeypatch, [name or None for name in target[1:]]) + names, damage = controller._verify_prepared_fleet(page, target) + assert names == [name or None for name in target[1:]] + assert damage == _damage(names) + page.read_repair_snapshot.assert_called_once_with(fresh=True) + page.read_first_screen_candidates.assert_not_called() + + +@pytest.mark.parametrize('threshold', [None, 600]) +def test_damaged_primary_keeps_configured_priority_without_timed_repairs( + threshold: int | None, +) -> None: + controller = _controller(reserves=('候补',), threshold=threshold) + fleet = controller._config.level1[:] + controller.state.ships = {*fleet, '候补'} + controller.state.fleet = ['', *fleet] + controller.state.ship_stats = [ShipDamageState.MODERATE, *([ShipDamageState.NORMAL] * 5)] + selected = controller._logic.get_best_fleet() + assert set(selected[1:]) == (set(fleet) if threshold is None else {*fleet[1:], '候补'}) + + +def test_severe_primary_yields_to_available_reserve_without_timed_repairs() -> None: + controller = _controller(reserves=('候补',)) + fleet = controller._config.level1[:] + controller.state.ships = {*fleet, '候补'} + controller.state.fleet = ['', *fleet] + controller.state.ship_stats = [ShipDamageState.SEVERE, *([ShipDamageState.NORMAL] * 5)] + assert set(controller._logic.get_best_fleet()[1:]) == {*fleet[1:], '候补'} diff --git a/testing/ops/test_decisive_quote_retries.py b/testing/ops/test_decisive_quote_retries.py new file mode 100644 index 000000000..08deaa184 --- /dev/null +++ b/testing/ops/test_decisive_quote_retries.py @@ -0,0 +1,97 @@ +"""验证在浴室读不出维修时长时,决战能否换上候补或等其他舰船修好。""" + +from __future__ import annotations + +from unittest.mock import MagicMock + +import pytest + +from autowsgr.constants import ship_name_identity +from autowsgr.ops.decisive.controller import DecisiveResult +from autowsgr.types import DecisivePhase +from autowsgr.types import ShipDamageState as Damage +from autowsgr.ui.bath_page.page import RepairShipInfo +from testing.ops.test_decisive_repair import _bath, _controller, _snapshot + + +@pytest.mark.parametrize( + ('count', 'waiting_ship', 'expected_waits', 'expected'), + [ + (7, False, [], DecisiveResult.CHAPTER_CLEAR), + (7, True, [7], DecisiveResult.CHAPTER_CLEAR), + (1, False, [], DecisiveResult.ERROR), + (2, True, [], DecisiveResult.ERROR), + (7, True, [7], DecisiveResult.STOPPED), + ], + ids=['reserve', 'repair-can-fill', 'only-ship', 'repair-cannot-fill', 'stop-during-wait'], +) +def test_failed_quote_through_scheduler( + monkeypatch: pytest.MonkeyPatch, + count: int, + waiting_ship: bool, + expected_waits: list[int], + expected: DecisiveResult, +) -> None: + ctrl, clock = _controller(count=count) + monkeypatch.setattr('autowsgr.scheduler.decisive.time.monotonic', clock) + ctrl.state.chapter = ctrl.state.stage = 1 + ships = ctrl._config.level1 + ctrl.state.ships = set(ships) + ctrl.state.fleet = ['', *ships[:6], *([''] * max(0, 6 - count))] + health = dict.fromkeys(ships, Damage.NORMAL) + health[ships[0]] = Damage.SEVERE + if waiting_ship: + health[ships[1]] = Damage.REPAIRING + ctrl._ctx.get_ship(ships[1]).repair_end_time = clock() + 7 + ctrl._map = MagicMock() + page = MagicMock() + bath = _bath(monkeypatch, ctrl, [RepairShipInfo(ships[0], (0.1, 0.5), '')]) + monkeypatch.setattr('autowsgr.ops.decisive.repair.goto_page', MagicMock()) + monkeypatch.setattr(ctrl, '_prepare_entry_state', MagicMock()) + observed_waits = [] + + def wait(seconds: float) -> None: + observed_waits.append(seconds) + if expected is DecisiveResult.STOPPED: + ctrl._ctx.stop_event.set() + else: + clock.return_value += seconds + + monkeypatch.setattr(ctrl._ctx.stop_event, 'wait', wait) + + def snapshot(**_kwargs: object) -> tuple[list[str | None], dict[int, Damage]]: + return _snapshot({name: health[name] for name in ctrl.state.fleet[1:] if name}) + + page.read_repair_snapshot.side_effect = snapshot + + def change(_page: object, fleet: list[str]) -> tuple[list[str | None], dict[int, Damage]]: + ctrl.state.fleet = fleet.copy() + return snapshot() + + monkeypatch.setattr(ctrl, '_verify_prepared_fleet', change) + + def reenter() -> None: + for name in ships: + end = ctrl._ctx.get_ship(name).repair_end_time + if end and clock() >= end: + health[name] = Damage.NORMAL + if ctrl._prepare_available_fleet(page): + page.start_battle() + ctrl.state.phase = DecisivePhase.CHAPTER_CLEAR + + monkeypatch.setattr(ctrl, '_handle_enter_map', reenter) + assert not ctrl._prepare_available_fleet(page) + assert ctrl._main_loop() is expected + if expected is DecisiveResult.ERROR: + assert '保留存档:U-0' in ctrl._repairs.poll().detail + assert ctrl._repairs.saved + assert observed_waits == expected_waits + bath.go_to_choose_repair.assert_called_once() + ctrl._ctx.ctrl.click.assert_not_called() + page.repair_slots.assert_not_called() + assert page.start_battle.call_count == int(expected is DecisiveResult.CHAPTER_CLEAR) + assert ctrl._ctx.get_ship(ships[0]).repair_end_time == 0 + if expected is DecisiveResult.CHAPTER_CLEAR: + assert ship_name_identity(ships[0]) in ctrl._repairs.blocked_identities + assert ships[0] not in ctrl.state.fleet + ctrl._map.leave_to_overview.assert_called_once() diff --git a/testing/ops/test_decisive_repair.py b/testing/ops/test_decisive_repair.py new file mode 100644 index 000000000..2b514c6b9 --- /dev/null +++ b/testing/ops/test_decisive_repair.py @@ -0,0 +1,646 @@ +"""决战修理按同帧舰名确认,到期后必须重新观察。""" + +from __future__ import annotations + +from unittest.mock import MagicMock + +import numpy as np +import pytest + +from autowsgr.constants import ship_name_identity +from autowsgr.context import GameContext +from autowsgr.emulator.frame import CapturedFrame +from autowsgr.infra import ActionFailedError, DecisiveConfig, EmulatorConfig, UserConfig +from autowsgr.ops.decisive.controller import DecisiveController +from autowsgr.ops.decisive.repair import RepairOutcome, RepairStatus +from autowsgr.types import OSType +from autowsgr.types import ShipDamageState as Damage +from autowsgr.ui.bath_page.page import RepairShipInfo +from autowsgr.ui.bath_page.recognition import _ocr_card +from autowsgr.ui.battle.blood import BLOOD_GREEN, classify_blood +from autowsgr.ui.battle.constants import BLOOD_BAR_PROBE +from autowsgr.ui.decisive.preparation import ( + _REPAIR_MARKER, + _REPAIR_SLOT_OFFSETS, + DecisiveBattlePreparationPage, +) +from autowsgr.ui.utils.navigation import NavigationError +from autowsgr.vision import Color +from autowsgr.vision.ocr import OCRResult + + +def _controller(threshold: int | None = 60, count: int = 4) -> tuple[DecisiveController, MagicMock]: + settings = UserConfig( + emulator=EmulatorConfig(serial='127.0.0.1:5555', path='/tmp/emulator'), + os_type=OSType.linux, + repair_manually=False, + ) + config = DecisiveConfig(level1=[f'U-{i}' for i in range(count)], level2=[]) + ctx = GameContext(ctrl=MagicMock(), config=settings, ocr=MagicMock()) + ctrl = DecisiveController( + ctx, + config, + user_config=settings.model_copy(update={'quick_repair_threshold_seconds': threshold}), + ) + clock = MagicMock(return_value=1000) + ctrl._repairs._clock = clock + return ctrl, clock + + +def _snapshot(states: dict[str, Damage]) -> tuple[list[str | None], dict[int, Damage]]: + names = list(states) + names.extend([None] * (6 - len(names))) + return names, {i: states[name] if name else Damage.NO_SHIP for i, name in enumerate(names)} + + +def _prepare( + controller: DecisiveController, states: dict[str, Damage], page: MagicMock | None = None +) -> RepairOutcome: + names, damage = _snapshot(states) + return controller._repairs.prepare( + page or MagicMock(), + fleet=names, + damage=damage, + acquired=controller._config.level1, + chapter=1, + stage=1, + ) + + +def _save(controller: DecisiveController, monkeypatch: pytest.MonkeyPatch) -> RepairOutcome: + monkeypatch.setattr('autowsgr.ops.decisive.repair.goto_page', MagicMock()) + controller._repairs.save_progress(MagicMock(), MagicMock()) + return controller._repairs.dispatch_pending() + + +def test_marker_precedes_green_blood_and_reads_names_on_same_frame() -> None: + frame = np.zeros((540, 960, 3), dtype=np.uint8) + for slot, offset in enumerate(_REPAIR_SLOT_OFFSETS): + for x, y, color in _REPAIR_MARKER: + frame[y, x + offset] = color.as_rgb_tuple() + bx, by = BLOOD_BAR_PROBE[slot] + frame[int(by * 540), int(bx * 960)] = BLOOD_GREEN.as_rgb_tuple() + + page = object.__new__(DecisiveBattlePreparationPage) + page._ctrl = MagicMock() + page._ctrl.screenshot.return_value = frame + page.detect_fleet = MagicMock(return_value=[f'U-{i}' for i in range(6)]) + names, damage = page.read_repair_snapshot() + assert len(names) == 6 + assert list(damage.values()) == [Damage.REPAIRING] * 6 + page.detect_fleet.assert_called_once_with(frame) + page._ctrl.screenshot.assert_called_once() + frame[220, 49] = 0 + assert page.detect_repair_damage(frame)[0] is Damage.NORMAL + frame[int(BLOOD_BAR_PROBE[0][1] * 540), int(BLOOD_BAR_PROBE[0][0] * 960)] = 255 + assert page.detect_repair_damage(frame)[0] is classify_blood(Color.of(255, 255, 255)) + + +def test_missing_flagship_and_reserve_names_require_one_complete_frame() -> None: + ctrl, _ = _controller() + fleet = ['U-47', 'U-1206', '351', '鲃鱼', 'U-96', 'M-296'] + ctrl._state.ships = set(fleet) + ctrl._repairs.observe_inventory = MagicMock() + damage = dict.fromkeys(range(6), Damage.NORMAL) + page = MagicMock() + # 实机首槽「147」、第四槽「鱼」均与舰名库的多个名字并列,各自留下空名。 + page.read_repair_snapshot.side_effect = [ + ([None, *fleet[1:]], {**damage, 1: Damage.SEVERE}), + ([*fleet[:3], None, *fleet[4:]], {**damage, 2: Damage.SEVERE}), + (fleet, damage), + ] + assert ctrl._observe_repairs(page) == (fleet, damage) + calls = page.read_repair_snapshot.call_args_list + assert len(calls) == 3 + assert not calls[0].kwargs + assert all(c.kwargs['fresh'] and 0 < c.kwargs['timeout'] <= 2 for c in calls[1:]) + assert ctrl._state.fleet[1:] == fleet + ctrl._repairs.observe_inventory.assert_called_once_with( + set(fleet), + chapter=ctrl._state.chapter, + stage=ctrl._state.stage, + damage=dict.fromkeys(fleet, Damage.NORMAL), + ) + + +@pytest.mark.parametrize('stale', [False, True]) +def test_unresolved_slot_keeps_original_failure_and_inventory(stale: bool) -> None: + ctrl, _ = _controller() + ctrl._repairs.observe_inventory = MagicMock() + page = MagicMock() + # 第三次实机失败时,末槽的 U-96 被读作「496」,但血条仍在。 + partial = ( + ['U-2540', 'U-1206', '351', '鲃鱼', 'U-47', None], + dict.fromkeys(range(6), Damage.NORMAL), + ) + if stale: + page.read_repair_snapshot.side_effect = [partial, ActionFailedError('未取得新帧')] + else: + page.read_repair_snapshot.return_value = partial + with pytest.raises(RuntimeError, match='决战准备页未能确认全部舰船的名称和伤情'): + ctrl._observe_repairs(page) + assert page.read_repair_snapshot.call_count == (2 if stale else 6) + ctrl._repairs.observe_inventory.assert_not_called() + page.repair_slots.assert_not_called() + + +def test_blind_recheck_uses_actual_identity_and_deadline(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, clock = _controller() + repairs = ctrl._repairs + states = dict.fromkeys(ctrl._config.level1, Damage.NORMAL) + states['U-0'] = Damage.REPAIRING + assert _prepare(ctrl, states).status is RepairStatus.NEEDS_BATH + outcome = _save(ctrl, monkeypatch) + assert (outcome.status, outcome.wait_seconds, outcome.target_size) == ( + RepairStatus.WAITING, + 180, + 4, + ) + clock.return_value += 179 + _prepare(ctrl, states) + assert repairs.poll().wait_seconds == 1 + clock.return_value += 1 + assert repairs.poll().status is RepairStatus.REENTER + # 另一艘舰的绿血不能证明 U-0 已修好。 + repairs.observe_inventory(states, chapter=1, stage=1, damage={'U-1': Damage.NORMAL}) + assert repairs.due_identities == {ship_name_identity('U-0')} + assert repairs.blocked_identities + _prepare(ctrl, states) + assert repairs.poll().wait_seconds == 180 + clock.return_value += 180 + states['U-0'] = Damage.NORMAL + assert _prepare(ctrl, states).status is RepairStatus.READY + assert not repairs.blocked_identities + + +def test_known_end_time_honored_then_rechecked(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, clock = _controller(count=1) + ctrl._ctx.get_ship('U-0').repair_end_time = clock() + 12 + _prepare(ctrl, {'U-0': Damage.REPAIRING}) + assert _save(ctrl, monkeypatch).wait_seconds == 12 + clock.return_value += 12 + assert ctrl._repairs.poll().status is RepairStatus.REENTER + _prepare(ctrl, {'U-0': Damage.REPAIRING}) + assert ctrl._repairs.poll().wait_seconds == 180 + + +def test_inventory_only_reserve_wakes_at_its_registered_deadline( + monkeypatch: pytest.MonkeyPatch, +) -> None: + ctrl, clock = _controller(count=2) + reserve = ctrl._ctx.get_ship('U-1') + reserve.repair_end_time = clock() + 738 + assert _prepare(ctrl, {'U-0': Damage.NORMAL}).status is RepairStatus.NEEDS_BATH + waiting = _save(ctrl, monkeypatch) + assert (waiting.status, waiting.wait_seconds, waiting.target_size) == ( + RepairStatus.WAITING, + 738, + 2, + ) + clock.return_value += 738 + assert ctrl._repairs.poll().status is RepairStatus.REENTER + assert ship_name_identity('U-1') in ctrl._repairs.blocked_identities + assert _prepare(ctrl, {'U-0': Damage.NORMAL, 'U-1': Damage.NORMAL}).status is RepairStatus.READY + assert reserve.repair_end_time == 0 + + +def test_blind_recheck_survives_stage_change_without_transferring_ownership() -> None: + ctrl, clock = _controller(count=2) + repairs = ctrl._repairs + repairs.observe_inventory(['U-0'], chapter=1, stage=1, damage={'U-0': Damage.REPAIRING}) + assert ctrl._ctx.get_ship('U-0').repair_recheck_at == clock() + 180 + clock.return_value += 120 + repairs.reset_stage() + repairs.observe_inventory(['U-1'], chapter=1, stage=2) + assert repairs.acquired == ('U-1',) + assert repairs.target_size == 1 + assert not repairs.blocked_identities + repairs.observe_inventory(['U-0'], chapter=1, stage=2) + assert repairs.target_size == 2 + assert ship_name_identity('U-0') in repairs.blocked_identities + clock.return_value += 60 + assert repairs.due_identities == {ship_name_identity('U-0')} + repairs.observe_inventory(['U-1'], chapter=1, stage=2, damage={'U-1': Damage.NORMAL}) + assert repairs.due_identities == {ship_name_identity('U-0')} + repairs.observe_inventory(['U-0'], chapter=1, stage=2, damage={'U-0': Damage.NORMAL}) + assert not repairs.due_identities + + +def test_registered_aliases_share_the_same_repair_record() -> None: + ctrl, clock = _controller() + canonical = ctrl._ctx.get_ship('赛尔弗里吉') + canonical.record_bath(clock() + 17) + alias = ctrl._ctx.get_ship('塞尔弗里奇') + assert alias is canonical + ctrl._repairs.observe_inventory([alias.name, '塞尔弗里奇'], chapter=1, stage=1) + assert ctrl._repairs.acquired == (canonical.name,) + clock.return_value += 17 + assert ctrl._repairs.due_identities == {ship_name_identity('塞尔弗里奇')} + + +def test_six_healthy_reserves_release_eight_ship_pool(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, _ = _controller(count=8) + states = dict.fromkeys(ctrl._config.level1[:6], Damage.NORMAL) + states['U-0'] = states['U-1'] = Damage.REPAIRING + _prepare(ctrl, states) + assert _save(ctrl, monkeypatch).target_size == 6 + ctrl._repairs.observe_inventory( + ctrl._config.level1, chapter=1, stage=1, damage={'U-6': Damage.NORMAL, 'U-7': Damage.NORMAL} + ) + assert ctrl._repairs.poll().status is RepairStatus.REENTER + healthy = dict.fromkeys(ctrl._config.level1[2:], Damage.NORMAL) + assert _prepare(ctrl, healthy).status is RepairStatus.READY + + +def _bath( + monkeypatch: pytest.MonkeyPatch, ctrl: DecisiveController, cards: list[RepairShipInfo] +) -> MagicMock: + bath = MagicMock() + bath.has_choose_repair_overlay.return_value = False + bath.is_current_page.return_value = True + bath.wait_repair_accepted.return_value = True + bath.recognize_repair_ships.return_value = cards + monkeypatch.setattr('autowsgr.ops.decisive.repair.BathPage', lambda _ctx: bath) + monkeypatch.setattr(ctrl._ctx.stop_event, 'wait', lambda _: None) + return bath + + +@pytest.mark.parametrize('duration', ['', '00:99:00']) +def test_unreadable_duration_fails_without_dispatch( + monkeypatch: pytest.MonkeyPatch, duration: str +) -> None: + ctrl, _ = _controller(threshold=0, count=1) + card = RepairShipInfo('U-0', (0.1, 0.5), duration) + bath = _bath(monkeypatch, ctrl, [card]) + _prepare(ctrl, {'U-0': Damage.SEVERE}) + outcome = _save(ctrl, monkeypatch) + assert outcome.status is RepairStatus.RECHECK + assert outcome.targets == ('U-0',) + assert outcome.wait_seconds is None + assert 'U-0' in outcome.detail + bath._swipe_left.assert_not_called() + bath.recognize_repair_ships.assert_called_once() + ctrl._ctx.ctrl.click.assert_not_called() + assert not ctrl._repairs.due_identities + assert ctrl._ctx.get_ship('U-0').repair_end_time == 0 + + +@pytest.mark.parametrize(('duration', 'seconds'), [('00:00:00', 0), ('00:00:59', 59)]) +def test_valid_short_quote_dispatched_once( + monkeypatch: pytest.MonkeyPatch, duration: str, seconds: int +) -> None: + ctrl, clock = _controller(count=1) + card = RepairShipInfo('U-0', (0.1, 0.5), duration) + _bath(monkeypatch, ctrl, [card]) + _prepare(ctrl, {'U-0': Damage.SEVERE}) + outcome = _save(ctrl, monkeypatch) + assert outcome.status is (RepairStatus.REENTER if seconds == 0 else RepairStatus.WAITING) + ctrl._repairs.dispatch_pending() + ctrl._ctx.ctrl.click.assert_called_once_with(*card.position) + assert ctrl._ctx.get_ship('U-0').repair_end_time == clock() + seconds + + +@pytest.mark.parametrize('threshold', [0, 60]) +def test_equal_threshold_authorizes_bucket_only_for_matching_name( + monkeypatch: pytest.MonkeyPatch, threshold: int | None +) -> None: + ctrl, _ = _controller(threshold=threshold, count=1) + damaged = {'U-0': Damage.SEVERE} + duration = '00:01:00' if threshold else '00:00:00' + card = RepairShipInfo('U-0', (0.1, 0.5), duration) + _bath(monkeypatch, ctrl, [card]) + _prepare(ctrl, damaged) + assert _save(ctrl, monkeypatch).status is RepairStatus.REENTER + ctrl._ctx.ctrl.click.assert_not_called() + page = MagicMock() + page.read_repair_snapshot.side_effect = [_snapshot(damaged), _snapshot({'U-0': Damage.NORMAL})] + assert _prepare(ctrl, damaged, page).status is RepairStatus.READY + page.repair_slots.assert_called_once_with([0]) + assert all(call.kwargs == {'fresh': True} for call in page.read_repair_snapshot.call_args_list) + + +def test_default_repair_needs_no_quote() -> None: + ctrl, _ = _controller(threshold=None, count=1) + page = MagicMock() + state = {'U-0': Damage.SEVERE} + page.read_repair_snapshot.side_effect = [_snapshot(state), _snapshot({'U-0': Damage.NORMAL})] + outcome = _prepare(ctrl, state, page) + assert outcome.status is RepairStatus.READY + assert outcome.snapshot == _snapshot({'U-0': Damage.NORMAL}) + assert page.read_repair_snapshot.call_count == 2 + page.repair_slots.assert_called_once_with([0]) + assert all(call.kwargs == {'fresh': True} for call in page.read_repair_snapshot.call_args_list) + + +def test_full_bath_retains_name_and_stops_before_next_click( + monkeypatch: pytest.MonkeyPatch, +) -> None: + ctrl, clock = _controller(count=1) + ctrl._ctx.bathroom = MagicMock() + ctrl._ctx.bathroom.is_available.return_value = False + ctrl._ctx.bathroom.get_waiting_time.return_value = 25 + card = RepairShipInfo('U-0', (0.1, 0.5), '00:00:15') + _bath(monkeypatch, ctrl, [card]) + _prepare(ctrl, {'U-0': Damage.SEVERE}) + outcome = _save(ctrl, monkeypatch) + assert (outcome.targets, outcome.wait_seconds) == (('U-0',), 25) + clock.return_value += 25 + assert ctrl._repairs.poll().status is RepairStatus.NEEDS_BATH + ctrl._ctx.stop_event.set() + assert ctrl._repairs.dispatch_pending().status is RepairStatus.STOPPED + ctrl._ctx.ctrl.click.assert_not_called() + + +def test_stop_after_opening_quick_repair_panel_spends_no_bucket() -> None: + ctrl, _ = _controller(threshold=None, count=1) + page = DecisiveBattlePreparationPage(ctrl._ctx, ctrl._config, MagicMock()) + page.select_panel = MagicMock(side_effect=lambda _panel: ctrl._ctx.stop_event.set()) + page.repair_slots([0]) + ctrl._ctx.ctrl.click.assert_not_called() + + +def test_fresh_snapshot_skips_cached_decoded_frame(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, _clock = _controller(count=1) + page = DecisiveBattlePreparationPage(ctrl._ctx, ctrl._config, MagicMock()) + stale = np.zeros((540, 960, 3), dtype=np.uint8) + new = np.zeros_like(stale) + page._ctrl.capture_frame.side_effect = [ + CapturedFrame(stale, 42, 120), + CapturedFrame(new, 43, 181), + ] + monkeypatch.setattr('autowsgr.ui.decisive.preparation.time.monotonic', lambda: 180.0) + page.detect_fleet = MagicMock(return_value=['胡德', *([None] * 5)]) + page.detect_repair_damage = MagicMock(return_value={0: Damage.NORMAL}) + page.read_repair_snapshot(fresh=True) + assert page.detect_fleet.call_args.args[0] is new + assert page.detect_repair_damage.call_args.args[0] is new + + +@pytest.mark.parametrize('raw', ['', '00:00:00']) +def test_real_bath_card_preserves_missing_time(raw: str) -> None: + ocr = MagicMock() + name = OCRResult('胡德', 1, (10, 125, 60, 140)) + ocr.recognize.side_effect = [[name], [OCRResult(raw, 1, (0, 0, 60, 10))]] + card = _ocr_card(np.zeros((480, 160, 3), np.uint8), ocr, 100, 160, 1280) + assert card is not None + assert (card.name, card.repair_time) == ('胡德', raw) + + +def test_bath_refuses_to_open_keeps_pending_and_backs_off(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, clock = _controller(count=1) + bath = _bath(monkeypatch, ctrl, []) + bath.go_to_choose_repair.side_effect = NavigationError('overlay unavailable') + _prepare(ctrl, {'U-0': Damage.SEVERE}) + result = _save(ctrl, monkeypatch) + assert (result.status, result.wait_seconds, result.targets) == ( + RepairStatus.WAITING, + 5, + ('U-0',), + ) + clock.return_value += 5 + assert ctrl._repairs.poll().status is RepairStatus.NEEDS_BATH + ctrl._ctx.ctrl.click.assert_not_called() + + +def test_controller_requests_a_fresh_frame_only_after_expiry( + monkeypatch: pytest.MonkeyPatch, +) -> None: + ctrl, clock = _controller(count=1) + ctrl._state.chapter = ctrl._state.stage = 1 + ctrl._state.ships = {'U-0'} + states = {'U-0': Damage.REPAIRING} + page = MagicMock() + page.read_repair_snapshot.return_value = _snapshot(states) + ctrl._observe_repairs(page) + _prepare(ctrl, states) + assert _save(ctrl, monkeypatch).wait_seconds == 180 + clock.return_value += 179 + ctrl._observe_repairs(page) + page.read_repair_snapshot.assert_called_with() + assert ctrl._repairs.poll().wait_seconds == 1 + clock.return_value += 1 + page.read_repair_snapshot.return_value = _snapshot({'U-0': Damage.NORMAL}) + ctrl._observe_repairs(page) + page.read_repair_snapshot.assert_called_with(fresh=True) + assert not ctrl._repairs.blocked_identities + assert ctrl._repairs.poll().status is RepairStatus.REENTER + + +def test_bucket_retry_requires_a_fresh_frame_after_first_click() -> None: + ctrl, _ = _controller(threshold=None, count=1) + page = MagicMock() + states = {'U-0': Damage.SEVERE} + page.read_repair_snapshot.side_effect = [_snapshot(states), ActionFailedError('没有新帧')] + with pytest.raises(ActionFailedError, match='没有新帧'): + _prepare(ctrl, states, page) + page.read_repair_snapshot.assert_called_with(fresh=True) + page.repair_slots.assert_called_once_with([0]) + + +@pytest.mark.parametrize('after_click', [False, True]) +def test_other_slots_must_match_before_and_after_each_bucket(after_click: bool) -> None: + ctrl, _ = _controller(threshold=None, count=3) + states = {'U-0': Damage.SEVERE, 'U-1': Damage.NORMAL, 'U-2': Damage.NORMAL} + names, damage = _snapshot(states) + ctrl.state.fleet = ['', *(name or '' for name in names)] + ctrl.state.ships = set(states) + changed = (['U-0', 'U-2', 'U-1', None, None, None], {**damage, 0: Damage.NORMAL}) + recovered = (names, {**damage, 0: Damage.NORMAL}) + corrected = recovered if after_click else (names, damage) + page = MagicMock() + ctrl._verify_prepared_fleet = MagicMock() + frames = [(names, damage)] # 准备页入口 + if after_click: + frames.append((names, damage)) + frames.extend([changed, corrected]) + if not after_click: + frames.append(recovered) + page.read_repair_snapshot.side_effect = [*frames, recovered] + + def verify(*_args, **_kwargs) -> None: + assert page.repair_slots.call_count == int(after_click) + assert ctrl._ctx.quick_repair_used == 0 + + ctrl._verify_prepared_fleet.side_effect = verify + assert ctrl._prepare_repairs(page) + ctrl._verify_prepared_fleet.assert_called_once_with(page, ctrl.state.fleet, force_change=True) + page.repair_slots.assert_called_once_with([0]) + assert ctrl._ctx.quick_repair_used == 1 + + +@pytest.mark.parametrize('after_click', [False, True]) +def test_missing_other_name_never_partially_updates_or_repeats_bucket(after_click: bool) -> None: + ctrl, _ = _controller(threshold=None, count=2) + states = {'U-0': Damage.SEVERE, 'U-1': Damage.NORMAL} + names, damage = _snapshot(states) + unreadable = (['U-0', *([None] * 5)], {**damage, 0: Damage.NORMAL}) + page = MagicMock() + page.read_repair_snapshot.side_effect = ([(names, damage)] if after_click else []) + [ + unreadable, + unreadable, + ActionFailedError('未取得新帧'), + ] + with pytest.raises(RuntimeError, match='未能确认全部舰船'): + _prepare(ctrl, states, page) + assert page.repair_slots.call_count == int(after_click) + assert ctrl._ctx.quick_repair_used == 0 + assert ctrl._repairs.damaged_identities == {ship_name_identity('U-0')} + + +@pytest.mark.parametrize(('threshold', 'clicks'), [(60, 1), (None, 3)]) +def test_unconfirmed_bucket_rechecks_identity_before_any_next_click( + threshold: int | None, clicks: int +) -> None: + ctrl, _ = _controller(threshold=threshold, count=2) + states = {'U-0': Damage.SEVERE, 'U-1': Damage.SEVERE} + names, damage = _snapshot(states) + repairs = ctrl._repairs + repairs.observe_inventory(states, chapter=1, stage=1, damage=states) + if threshold is not None: + repairs._long_repairs.update(ship_name_identity(name) for name in states) + page = MagicMock() + page.read_repair_snapshot.return_value = (names, damage) + for _ in range(2): + with pytest.raises(ActionFailedError, match='未确认 U-0 恢复'): + _prepare(ctrl, states, page) + assert [c.args[0] for c in page.repair_slots.call_args_list] == [[0]] * clicks + assert ctrl._ctx.quick_repair_used == 0 + partially_recovered = (names, {**damage, 0: Damage.NORMAL}) + page.read_repair_snapshot.side_effect = [ + partially_recovered, + partially_recovered, + (names, {**damage, 0: Damage.NORMAL, 1: Damage.NORMAL}), + ] + assert _prepare(ctrl, states, page).status is RepairStatus.READY + assert [c.args[0] for c in page.repair_slots.call_args_list] == [[0]] * clicks + [[1]] + assert ctrl._ctx.quick_repair_used == 2 + assert all(c.kwargs == {'fresh': True} for c in page.read_repair_snapshot.call_args_list) + + +def test_no_frame_sequence_requires_changed_pixels_to_prove_redraw() -> None: + ctrl, _ = _controller(count=1) + page = DecisiveBattlePreparationPage(ctrl._ctx, ctrl._config, MagicMock()) + stale = np.zeros((1, 1, 3), np.uint8) + new = np.ones_like(stale) + page._ctrl.capture_frame.side_effect = [ + CapturedFrame(stale, None, 0), + CapturedFrame(stale.copy(), None, 10), + CapturedFrame(new, None, 20), + ] + page.detect_fleet = MagicMock(return_value=['胡德', *([None] * 5)]) + page.detect_repair_damage = MagicMock(return_value={0: Damage.NORMAL}) + page.read_repair_snapshot(fresh=True) + assert page.detect_fleet.call_args.args[0] is new + assert page.detect_repair_damage.call_args.args[0] is new + + +@pytest.mark.parametrize(('count', 'buckets'), [(8, 1), (9, 0)]) +def test_short_bath_precedes_lineup_and_buckets_cover_only_shortfall( + monkeypatch: pytest.MonkeyPatch, count: int, buckets: int +) -> None: + # 三艘受伤,一艘短修,两艘长修;健康替补数决定要不要用桶。 + ctrl, _ = _controller(threshold=1800, count=count) + ctrl.state.chapter = ctrl.state.stage = 1 + ships = ctrl._config.level1 + ctrl.state.ships = set(ships) + ctrl.state.fleet = ['', *ships[:6]] + health = dict.fromkeys(ships, Damage.NORMAL) + health.update(dict.fromkeys(ships[:3], Damage.SEVERE)) + events = [] + page = MagicMock() + + def snapshot(**_kwargs: bool) -> tuple[list[str | None], dict[int, Damage]]: + return _snapshot({name: health[name] for name in ctrl.state.fleet[1:] if name}) + + def change(_page: object, target: list[str]) -> tuple[list[str | None], dict[int, Damage]]: + events.append('编队') + ctrl.state.fleet = target.copy() + return snapshot() + + def bucket(slots: list[int]) -> None: + [slot] = slots + name = ctrl.state.fleet[slot + 1] + events.append(name) + health[name] = Damage.NORMAL + + page.read_repair_snapshot.side_effect = snapshot + page.repair_slots.side_effect = bucket + monkeypatch.setattr(ctrl, '_verify_prepared_fleet', change) + ctrl._map = MagicMock() + ctrl._route_repair = MagicMock() + monkeypatch.setattr('autowsgr.ops.decisive.repair.goto_page', MagicMock()) + _bath( + monkeypatch, + ctrl, + [ + RepairShipInfo(ships[0], (0.1, 0.5), '00:29:59'), + RepairShipInfo(ships[1], (0.3, 0.5), '00:30:00'), + RepairShipInfo(ships[2], (0.5, 0.5), '00:30:01'), + ], + ) + ctrl._ctx.ctrl.click.side_effect = lambda *_pos: events.append('入浴') + assert not ctrl._prepare_available_fleet(page) + assert events == [] + assert ctrl._repairs.dispatch_pending().status is RepairStatus.REENTER + assert events == ['入浴'] + ctrl._ctx.ctrl.click.assert_called_once_with(0.1, 0.5) + assert ctrl._prepare_available_fleet(page) + assert page.repair_slots.call_count == buckets + if buckets: + assert events[-1] == ships[1] + assert ships[0] not in ctrl.state.fleet + assert all(health[name] is Damage.NORMAL for name in ctrl.state.fleet[1:]) + + +def test_short_repairs_rejoin_only_after_verified_completion( + monkeypatch: pytest.MonkeyPatch, +) -> None: + ctrl, clock = _controller(threshold=1800, count=2) + states = {'U-0': Damage.NORMAL, 'U-1': Damage.SEVERE} + _bath(monkeypatch, ctrl, [RepairShipInfo('U-1', (0.1, 0.5), '00:29:59')]) + page = MagicMock() + assert _prepare(ctrl, states, page).status is RepairStatus.NEEDS_BATH + result = _save(ctrl, monkeypatch) + assert (result.status, result.wait_seconds) == (RepairStatus.WAITING, 1799) + clock.return_value += 1799 + assert ctrl._repairs.poll().status is RepairStatus.REENTER + states['U-1'] = Damage.REPAIRING + assert _prepare(ctrl, states, page).status is RepairStatus.NEEDS_BATH + assert ctrl._repairs.poll().wait_seconds == 180 + clock.return_value += 180 + states['U-1'] = Damage.NORMAL + assert _prepare(ctrl, states, page).status is RepairStatus.READY + page.repair_slots.assert_not_called() + + +def test_final_battle_damage_is_dispatched_from_overview(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, _ = _controller(threshold=1800) + names = ctrl._config.level1 + ctrl._repairs.observe_inventory( + names, chapter=6, stage=3, damage={names[0]: Damage.SEVERE, names[1]: Damage.SEVERE} + ) + _bath( + monkeypatch, + ctrl, + [ + RepairShipInfo(names[0], (0.1, 0.5), '00:01:00'), + RepairShipInfo(names[1], (0.5, 0.5), '01:00:00'), + ], + ) + monkeypatch.setattr('autowsgr.ops.decisive.repair.goto_page', MagicMock()) + assert ctrl._repairs.park_after_settlement() + assert ctrl._repairs.dispatch_pending().status is RepairStatus.REENTER + ctrl._ctx.ctrl.click.assert_called_once_with(0.1, 0.5) + + +def test_bath_deadline_counts_from_dispatch_click(monkeypatch: pytest.MonkeyPatch) -> None: + ctrl, clock = _controller(threshold=1800, count=1) + bath = _bath(monkeypatch, ctrl, [RepairShipInfo('U-0', (0.1, 0.5), '00:00:30')]) + + def confirm() -> bool: + clock.return_value += 2 + return True + + bath.wait_repair_accepted.side_effect = confirm + _prepare(ctrl, {'U-0': Damage.MODERATE}) + assert _save(ctrl, monkeypatch).wait_seconds == 28 diff --git a/testing/ops/test_decisive_tracking.py b/testing/ops/test_decisive_tracking.py index 44b0528a9..9b7ff6eff 100644 --- a/testing/ops/test_decisive_tracking.py +++ b/testing/ops/test_decisive_tracking.py @@ -227,6 +227,36 @@ def test_ignored_completion_keeps_local_encounter(monkeypatch: pytest.MonkeyPatc assert session.current_node == 'A' +@pytest.mark.parametrize('overlay', [DecisivePhase.ADVANCE_CHOICE, DecisivePhase.CHOOSE_FLEET]) +def test_late_overlay_after_result_preempts_map( + monkeypatch: pytest.MonkeyPatch, overlay: DecisivePhase +) -> None: + now = [0.0] + monkeypatch.setattr(tracking_module.time, 'monotonic', lambda: now[0]) + monkeypatch.setattr( + tracking_module.time, 'sleep', lambda delay: now.__setitem__(0, now[0] + delay) + ) + controller = DecisiveController.__new__(DecisiveController) + controller._ctx = SimpleNamespace(stop_event=threading.Event()) + controller._state = DecisiveState(chapter=6, stage=1) + controller._ctrl = MagicMock() + controller._ctrl.capture_frame.side_effect = [frame(i) for i in (1, 1, 2, 3)] + controller._map = MagicMock() + controller._map.is_stage_clear.return_value = False + controller._map.detect_decisive_phase.side_effect = [ + None, + DecisivePhase.PREPARE_COMBAT, + overlay, + ] + session = MagicMock() + controller._wait_for_post_combat_page(session) + + assert controller.state.phase is overlay + controller._map.continue_combat_result.assert_called_once() + session.map_ready.assert_called_once() + assert session.map_ready.call_args.args[0].sequence == 3 + + @pytest.mark.parametrize('real_clear', [False, True]) def test_controller_waits_for_page_and_submits_one_step( monkeypatch: pytest.MonkeyPatch, real_clear: bool @@ -238,6 +268,8 @@ def test_controller_waits_for_page_and_submits_one_step( controller = DecisiveController.__new__(DecisiveController) controller._ctx = SimpleNamespace(stop_event=threading.Event()) controller._ctrl = MagicMock() + controller._repairs = MagicMock() + controller._repairs.park_after_settlement.return_value = False controller._ctrl.capture_frame.return_value = frame(4) controller._state = DecisiveState(chapter=6, stage=1, node=session.current_node) controller._tracking = session diff --git a/testing/ops/test_scheduler_unit.py b/testing/ops/test_scheduler_unit.py index 48995fab8..c80c8d8fe 100644 --- a/testing/ops/test_scheduler_unit.py +++ b/testing/ops/test_scheduler_unit.py @@ -9,6 +9,7 @@ import threading import types +from typing import TYPE_CHECKING from unittest.mock import MagicMock import pytest @@ -20,6 +21,10 @@ from autowsgr.types import ConditionFlag +if TYPE_CHECKING: + from collections.abc import Callable + + # ── 假 runner ── @@ -679,3 +684,244 @@ def test_register_normal_fight_passes_condition(monkeypatch: pytest.MonkeyPatch) trigger = sched._triggers[-1] assert trigger._plans[0].conditions == (GradeCondition('F', 'S'),) + + +def test_decisive_round_resumes_after_scheduled_repair(monkeypatch: pytest.MonkeyPatch) -> None: + """维修还差 738 秒时队列里没有决战、派修;远征到点能执行,到期只续战一次。""" + import time + + from autowsgr.ops.decisive.controller import DecisiveResult + from autowsgr.ops.decisive.repair import RepairOutcome, RepairStatus + from autowsgr.scheduler.triggers import ExpeditionTrigger + + ctx = _FakeCtx() + scheduler = TaskScheduler(ctx, expedition_interval=0, idle_sleep=300) + clock = 0.0 + monkeypatch.setattr(time, 'monotonic', lambda: clock) + trips: list[float] = [] + runner = MagicMock() + runner.run.side_effect = lambda: ( + trips.append(clock) or CombatResult(flag=ConditionFlag.OPERATION_SUCCESS) + ) + scheduler.register_trigger( + ExpeditionTrigger(name='远征', priority=0, interval=300, task_factory=lambda _ctx: runner) + ) + + def wait(seconds: float) -> None: + nonlocal clock + assert not scheduler._queue + clock += seconds + + monkeypatch.setattr(ctx.stop_event, 'wait', wait) + advance = MagicMock(side_effect=[None, DecisiveResult.CHAPTER_CLEAR]) + reenter = RepairOutcome(RepairStatus.REENTER) + next_repair = MagicMock(side_effect=[RepairOutcome(RepairStatus.NEEDS_BATH), reenter]) + dispatch = MagicMock(return_value=RepairOutcome(RepairStatus.WAITING, wait_seconds=738)) + resume = MagicMock() + + assert ( + scheduler.run_decisive(advance, next_repair, dispatch, resume) + is DecisiveResult.CHAPTER_CLEAR + ) + dispatch.assert_called_once_with() + assert clock == 738 + assert trips == [300, 600] + resume.assert_called_once_with(reenter) + assert advance.call_count == 2 + + +@pytest.mark.parametrize('expedition_due', [False, True]) +def test_decisive_nodes_only_park_for_ready_task(expedition_due: bool) -> None: + from autowsgr.ops.decisive.controller import DecisiveResult + + ctx = _FakeCtx() + scheduler = TaskScheduler(ctx) + order = [] + foreign = MagicMock() + foreign.run.side_effect = lambda: ( + order.append('远征') or CombatResult(flag=ConditionFlag.OPERATION_SUCCESS) + ) + scheduler._maybe_collect_expedition = MagicMock(side_effect=AssertionError('绕过远征触发器')) + + def advance() -> DecisiveResult: + if not order: + order.append('A') + if expedition_due: + scheduler._enqueue(FightTask(foreign, priority=0)) + return DecisiveResult.NODE_COMPLETE + order.append('B') + return DecisiveResult.CHAPTER_CLEAR + + def park() -> bool: + order.append('确认暂离') + return True + + assert scheduler.run_decisive(advance, MagicMock(), MagicMock(), MagicMock(), park=park) is ( + DecisiveResult.CHAPTER_CLEAR + ) + assert order == (['A', '确认暂离', '远征', 'B'] if expedition_due else ['A', 'B']) + scheduler._maybe_collect_expedition.assert_not_called() + + +def test_decisive_recovery_precedes_an_unsafe_handoff() -> None: + from autowsgr.ops.decisive.controller import DecisiveResult + + scheduler = TaskScheduler(_FakeCtx()) + order = [] + foreign = MagicMock() + foreign.run.side_effect = lambda: ( + order.append('远征') or CombatResult(flag=ConditionFlag.OPERATION_SUCCESS) + ) + foreign_task = FightTask(foreign, priority=0) + + def advance() -> DecisiveResult: + if not order: + order.append('A超时') + scheduler._enqueue(foreign_task) + return DecisiveResult.RETRY + if '恢复A' not in order: + assert scheduler._queue == [foreign_task] + order.append('恢复A') + return DecisiveResult.NODE_COMPLETE + order.append('B') + return DecisiveResult.CHAPTER_CLEAR + + park = MagicMock(side_effect=[False, True]) + assert scheduler.run_decisive(advance, MagicMock(), MagicMock(), MagicMock(), park=park) is ( + DecisiveResult.CHAPTER_CLEAR + ) + assert order == ['A超时', '恢复A', '远征', 'B'] + + +@pytest.mark.parametrize('stop', [False, True]) +def test_decisive_interrupted_handoff_preserves_pending_task(stop: bool) -> None: + from autowsgr.ops.decisive.controller import DecisiveResult + + ctx = _FakeCtx() + scheduler = TaskScheduler(ctx) + external = FightTask(MagicMock(), priority=0) + + def advance() -> DecisiveResult: + scheduler._enqueue(external) + return DecisiveResult.NODE_COMPLETE + + def park() -> bool: + if stop: + ctx.stop_event.set() + return True + raise RuntimeError('暂离后未确认总览') + + if stop: + assert scheduler.run_decisive( + advance, MagicMock(), MagicMock(), MagicMock(), park=park + ) is (DecisiveResult.STOPPED) + else: + with pytest.raises(RuntimeError, match='暂离后未确认总览'): + scheduler.run_decisive(advance, MagicMock(), MagicMock(), MagicMock(), park=park) + assert scheduler._queue == [external] + external.runner.run.assert_not_called() + + +def test_decisive_immediate_resume_deduplicates_dispatch_callback() -> None: + from autowsgr.ops.decisive.controller import DecisiveResult + from autowsgr.ops.decisive.repair import RepairOutcome, RepairStatus + from autowsgr.scheduler.daily_plan import PRIO_DECISIVE + + scheduler = TaskScheduler(_FakeCtx()) + advance = MagicMock(side_effect=[None, DecisiveResult.CHAPTER_CLEAR]) + reenter = RepairOutcome(RepairStatus.REENTER) + + def dispatch() -> RepairOutcome: + assert [task.priority for task in scheduler._queue] == [PRIO_DECISIVE] + return reenter + + resume = MagicMock() + assert ( + scheduler.run_decisive( + advance, + lambda: RepairOutcome(RepairStatus.NEEDS_BATH, resume_immediately=True), + dispatch, + resume, + ) + is DecisiveResult.CHAPTER_CLEAR + ) + assert not scheduler._queue + assert advance.call_count == 2 + resume.assert_called_once_with(reenter) + + +def test_decisive_mode_only_registers_enabled_dailies() -> None: + from autowsgr.infra.config import DailyAutomationConfig + + cfg = DailyAutomationConfig( + auto_expedition=True, + auto_exercise=False, + auto_battle=False, + auto_gain_bonus=False, + auto_bath_repair=False, + auto_normal_fight=True, + normal_fight_tasks=['示例计划'], + ) + settings = types.SimpleNamespace(daily_automation=cfg) + scheduler = TaskScheduler.for_decisive(_FakeCtx(), user_config=settings) + assert [trigger.name for trigger in scheduler._triggers] == ['远征'] + + +def test_failed_daily_fights_let_decisive_node_run(monkeypatch: pytest.MonkeyPatch) -> None: + """高优先级战役或演习导航失败后,仍能执行已排队的决战节点。""" + import time + + from autowsgr.infra.config import DailyAutomationConfig + from autowsgr.ops.decisive.controller import DecisiveResult + + cfg = DailyAutomationConfig( + auto_battle=True, + auto_exercise=True, + auto_expedition=False, + auto_gain_bonus=False, + auto_bath_repair=False, + ) + ctx = _FakeCtx() + scheduler = TaskScheduler.for_decisive( + ctx, user_config=types.SimpleNamespace(daily_automation=cfg) + ) + attempts: list[str] = [] + clock = 100.0 + monkeypatch.setattr(time, 'monotonic', lambda: clock) + + def failing_factory(name: str) -> Callable[[GameContext], object]: + def factory(_ctx: GameContext) -> object: + attempts.append(name) + if len(attempts) > len(scheduler._triggers): + ctx.stop_event.set() + runner = MagicMock() + runner.run.side_effect = RuntimeError('未能进入页面') + return runner + + return factory + + for trigger in scheduler._triggers: + monkeypatch.setattr(trigger, '_task_factory', failing_factory(trigger.name)) + + result = scheduler.run_decisive( + lambda: DecisiveResult.CHAPTER_CLEAR, + MagicMock(), + MagicMock(), + MagicMock(), + park=lambda: True, + ) + assert result is DecisiveResult.CHAPTER_CLEAR + assert attempts == [trigger.name for trigger in scheduler._triggers] + clock += 600 + assert all(trigger.should_fire(ctx) is not None for trigger in scheduler._triggers) + + +def test_pending_normal_fight_survives_midnight_without_duplicate() -> None: + plan = NormalFightPlan(factory=lambda _ctx: object(), name='x', fleet_id=1, target=1) + trigger = NormalFightTrigger(priority=100, name='常规战', plans=[plan]) + ctx = _FakeCtx() + pending = trigger.should_fire(ctx) + trigger.reset() + assert trigger.should_fire(ctx) is None + pending.on_done(CombatResult(flag=ConditionFlag.OPERATION_SUCCESS)) + assert plan.completed == 1 diff --git a/testing/server/test_task_routes.py b/testing/server/test_task_routes.py index 9108e71b1..53e6a34f3 100644 --- a/testing/server/test_task_routes.py +++ b/testing/server/test_task_routes.py @@ -1,4 +1,4 @@ -"""Task route admission tests.""" +"""任务接口的启动条件测试。""" from __future__ import annotations @@ -6,6 +6,7 @@ from dataclasses import dataclass, field from types import SimpleNamespace from typing import TYPE_CHECKING, Any +from unittest.mock import MagicMock import pytest from fastapi import HTTPException @@ -86,7 +87,7 @@ def start_task( def test_task_start_rejects_concurrent_task(monkeypatch: pytest.MonkeyPatch) -> None: - """Task admission rejects a second running task under the lifecycle lock.""" + """持有任务锁时拒绝启动第二个任务。""" monkeypatch.setattr(task, 'task_manager', _TaskManager(is_running=True)) with pytest.raises(HTTPException) as exc_info: @@ -96,7 +97,7 @@ def test_task_start_rejects_concurrent_task(monkeypatch: pytest.MonkeyPatch) -> def test_task_start_requires_system_context(monkeypatch: pytest.MonkeyPatch) -> None: - """Task admission fails after system shutdown removed the context.""" + """系统关闭并释放上下文后无法启动任务。""" monkeypatch.setattr(task, 'task_manager', _TaskManager()) monkeypatch.setattr(server_main, '_ctx', None) @@ -107,7 +108,7 @@ def test_task_start_requires_system_context(monkeypatch: pytest.MonkeyPatch) -> def test_task_start_reports_device_conflict(monkeypatch: pytest.MonkeyPatch) -> None: - """Task lease conflicts are returned synchronously as HTTP 409.""" + """任务占用冲突应同步返回 HTTP 409。""" manager = _TaskManager() ctx = type('Context', (), {'stop_event': None})() @@ -139,7 +140,7 @@ def test_task_start_dispatches_request_with_shared_context( task_request: object, helper_name: str, ) -> None: - """Each supported request is admitted with the current context and stop token.""" + """各类任务使用当前上下文和停止标志启动。""" manager = _TaskManager() ctx = type('Context', (), {'stop_event': None})() calls: list[tuple[object, object]] = [] @@ -163,7 +164,7 @@ async def start_helper(received_ctx: object, received_request: object) -> object def test_decisive_error_result_marks_task_failed( monkeypatch: pytest.MonkeyPatch, ) -> None: - """A decisive ERROR is a task failure, not a successful completed round.""" + """决战发生错误时应报告本轮失败。""" from autowsgr import ops from autowsgr.ops import DecisiveResult @@ -193,10 +194,24 @@ def run(self) -> DecisiveResult: ] +def test_decisive_stop_does_not_record_a_completed_round(monkeypatch: pytest.MonkeyPatch) -> None: + from autowsgr import ops + from autowsgr.ops import DecisiveResult + + manager = _ExecutingTaskManager() + monkeypatch.setattr(task, 'task_manager', manager) + controller = MagicMock() + controller.run.return_value = DecisiveResult.STOPPED + monkeypatch.setattr(ops, 'DecisiveController', lambda *_args: controller) + asyncio.run(task._start_decisive(object(), DecisiveRequest(decisive_rounds=2))) + controller.run.assert_called_once() + assert manager.outcome.results == [] + + def test_decisive_leave_result_remains_successful( monkeypatch: pytest.MonkeyPatch, ) -> None: - """An intentional decisive leave remains a successful terminal result.""" + """主动暂离时任务正常结束。""" from autowsgr import ops from autowsgr.ops import DecisiveResult @@ -240,12 +255,12 @@ def run(self) -> DecisiveResult: def test_round_result_schema_preserves_existing_detail_shapes( detail: dict[str, Any], ) -> None: - """Typed task results must not strip or synthesize detail fields.""" + """任务结果应保留实际提供的详情字段。""" assert RoundResult.model_validate(detail).model_dump(exclude_unset=True) == detail def test_task_status_openapi_exposes_typed_data() -> None: - """The status endpoint documents TaskStatusResponse instead of untyped Any.""" + """状态接口应声明 TaskStatusResponse 响应类型。""" schema = server_main.app.openapi() response_schema = schema['paths']['/api/task/status']['get']['responses']['200']['content'][ 'application/json' @@ -257,7 +272,7 @@ def test_task_status_openapi_exposes_typed_data() -> None: def test_typed_task_status_preserves_terminal_wire_payload() -> None: - """Typed envelope round-trips terminal details without adding absent fields.""" + """结果序列化往返后保留原有详情字段。""" payload = { 'success': True, 'data': { @@ -282,7 +297,7 @@ def test_typed_task_status_preserves_terminal_wire_payload() -> None: def test_task_status_returns_typed_envelope(monkeypatch: pytest.MonkeyPatch) -> None: - """The route validates manager status through its typed response contract.""" + """路由应按声明的响应模型验证任务状态。""" status = { 'task_id': None, 'status': 'idle', @@ -437,7 +452,7 @@ def run_event_fight( def test_normal_route_enters_real_runner_with_resolved_selection( monkeypatch: pytest.MonkeyPatch, ) -> None: - """HTTP route reaches the public ops entry and constructs the real runner.""" + """HTTP 路由应调用公开的操作入口并创建实际执行器。""" manager = _ExecutingTaskManager() captured: list[ResolvedFleetSelection] = [] diff --git a/testing/tools/test_decisive_collection.py b/testing/tools/test_decisive_collection.py index 9a5575768..28c3758b6 100644 --- a/testing/tools/test_decisive_collection.py +++ b/testing/tools/test_decisive_collection.py @@ -28,7 +28,14 @@ from autowsgr.ops.decisive.logic import DecisiveLogic from autowsgr.ops.decisive.state import DecisiveState from autowsgr.ops.decisive.tracking import DecisiveTrackingSession -from autowsgr.types import ConditionFlag, DecisiveEntryStatus, DecisivePhase, Formation, OSType +from autowsgr.types import ( + ConditionFlag, + DecisiveEntryStatus, + DecisivePhase, + Formation, + OSType, + ShipDamageState, +) from autowsgr.ui.decisive.map_controller import DecisiveMapController from tools.decisive.collect import CollectionController, RecordingCombatEngine, main, parse_args @@ -66,6 +73,7 @@ def test_only_completed_combat_reaches_node_result( flag: ConditionFlag, stopped: bool, expected: DecisivePhase ) -> None: controller = DecisiveController.__new__(DecisiveController) + controller._repairs = MagicMock() controller._ctx = SimpleNamespace(stop_event=threading.Event()) if stopped: controller._ctx.stop_event.set() @@ -85,7 +93,9 @@ def test_only_completed_combat_reaches_node_result( def test_stop_before_node_result_does_not_increment() -> None: controller = DecisiveController.__new__(DecisiveController) + controller._repairs = MagicMock() controller._ctx = SimpleNamespace(stop_event=threading.Event()) + controller._settings = SimpleNamespace(daily_automation=None) controller._ctx.stop_event.set() controller._state = DecisiveState(stage=1, node='J', phase=DecisivePhase.NODE_RESULT) controller._tracking = None @@ -96,7 +106,9 @@ def test_stop_before_node_result_does_not_increment() -> None: def test_finished_without_clear_is_not_success() -> None: controller = DecisiveController.__new__(DecisiveController) + controller._repairs = MagicMock() controller._ctx = SimpleNamespace(stop_event=threading.Event()) + controller._settings = SimpleNamespace(daily_automation=None) controller._state = DecisiveState(phase=DecisivePhase.FINISHED) controller._tracking = None assert controller._main_loop() == DecisiveResult.ERROR @@ -145,6 +157,9 @@ def _collection_controller() -> CollectionController: controller._battle_page = MagicMock() controller.archive = SimpleNamespace(context={}, record=MagicMock()) controller.round_number = 1 + controller._repairs = MagicMock() + controller._repairs.needs_dispatch = False + controller._repairs.park_after_settlement.return_value = False controller._tracking = None controller._known_start_stage = None controller._battle_encounter_id = None @@ -529,7 +544,7 @@ def test_collector_does_not_duplicate_production_fleet_scan( controller._map.is_skill_used.return_value = True controller._map.check_fleet.return_value = ( ['芝加哥', None, None, None, None, None], - {}, + {0: ShipDamageState.NORMAL}, {'芝加哥'}, ) controller._logic = DecisiveLogic(controller._config, controller._state) From 4432e660775b1de28547d36063965eeb6d04ed21 Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:41 +0800 Subject: [PATCH 7/8] =?UTF-8?q?refactor(log):=20=E6=98=8E=E7=A1=AE?= =?UTF-8?q?=E7=BC=96=E9=98=9F=E4=BD=8D=E7=BD=AE=E5=92=8C=E8=88=B0=E7=A7=8D?= =?UTF-8?q?=E8=AF=86=E5=88=AB=E7=BB=93=E6=9E=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- autowsgr/combat/node_fusion/calibration.py | 12 ++++++------ autowsgr/combat/node_fusion/enemy.py | 13 +++++++------ autowsgr/combat/node_fusion/factors.py | 4 ++-- autowsgr/combat/node_fusion/integration.py | 4 ++-- autowsgr/combat/node_fusion/map.py | 2 +- autowsgr/ui/battle/fleet_change/_change.py | 10 +++++----- autowsgr/ui/battle/fleet_change/_detect.py | 10 +++++----- autowsgr/ui/battle/fleet_change/_rules.py | 2 +- autowsgr/ui/decisive/legacy_fleet_change.py | 4 ++-- testing/combat/node_fusion/test_calibration.py | 2 +- .../combat/node_fusion/test_decisive_recovery.py | 2 +- testing/combat/node_fusion/test_enemy.py | 2 +- testing/combat/node_fusion/test_evidence.py | 2 +- testing/combat/node_fusion/test_sequences.py | 2 +- testing/combat/node_fusion/test_session.py | 2 +- testing/ui/battle_preparation/test_unit.py | 4 ++-- 16 files changed, 39 insertions(+), 38 deletions(-) diff --git a/autowsgr/combat/node_fusion/calibration.py b/autowsgr/combat/node_fusion/calibration.py index 3bbb42569..1776acaa8 100644 --- a/autowsgr/combat/node_fusion/calibration.py +++ b/autowsgr/combat/node_fusion/calibration.py @@ -1,8 +1,8 @@ """使用不含敌情观测的历史定位核对 native 敌舰识别;不符时由会话告警请求反馈。 参照节点仍是独立证据形成的估计,并非人工真值。只比较所有合法敌情变体均一致的 -字段,避免用待测识别结果选择最相似的模板,再把它当作正确答案。普通战第 3 槽 -战利品补给不告警;整队 AP 过期签名的资料豁免是独立规则。 +字段,避免用待测识别结果选择最相似的模板,再把它当作正确答案。普通战敌方编队第三个位置 +出现战利品补给舰时不报警。整队都是补给舰的过期地图记录有单独的豁免规则。 """ from __future__ import annotations @@ -35,7 +35,7 @@ @dataclass(frozen=True) class SlotMismatch: - """确认定位遭遇中与地图签名不符的槽位;保留原始识别码便于反馈排查。""" + """节点已确认时,记录哪艘敌舰的舰种与地图资料不符,并保留原始识别代码。""" node: str slot: int @@ -94,7 +94,7 @@ def _slot_mismatches( for index in range(6): expected = {item.ships[index] if index < len(item.ships) else None for item in variants} if len(expected) != 1 or expected == {None}: - # 变体分歧或空槽没有唯一真值,不可核对。 + # 同一位置在各编队里舰种不同,或一直空着,都无法核对。 continue true_ship = next(iter(expected)) if true_ship not in SHIP_TYPES: @@ -109,7 +109,7 @@ def _slot_mismatches( if value == true_ship: continue if value == _AP_SHIP and combat_mode == CombatMode.NORMAL and index == 2: - # 只有普通战第 3 槽会被战利品补给替换;活动与决战没有此机制。 + # 普通战敌方编队的第三个位置可能出现战利品补给舰。 continue found.append((index + 1, true_ship, code, value)) return found @@ -118,7 +118,7 @@ def _slot_mismatches( def recognition_mismatches( tracker: FusionTracker, *, combat_mode: str = CombatMode.NORMAL ) -> list[SlotMismatch]: - """确认定位遭遇中与地图签名不符的槽位;每个独立遭遇只取最早索敌帧。""" + """用每次遭遇的首张索敌画面,核对已确认节点的敌方编队中哪些位置舰种不符。""" mismatches: list[SlotMismatch] = [] if not any(obs.phase == 'SPOT_ENEMY_SUCCESS' for obs in tracker.observations): return mismatches diff --git a/autowsgr/combat/node_fusion/enemy.py b/autowsgr/combat/node_fusion/enemy.py index 81532b575..6d5178c1a 100644 --- a/autowsgr/combat/node_fusion/enemy.py +++ b/autowsgr/combat/node_fusion/enemy.py @@ -1,7 +1,7 @@ -"""从同一索敌截图采集舰类槽位、阵型和迂回按钮证据。 +"""从同一张索敌截图识别敌方编队每个位置的舰种、敌方阵型和迂回按钮。 -这里只记录识别结果,不推断节点。``None`` 表示没有可用证据;尤其 native 的 -``NO`` 同时可能表示空槽或识别失败,不能据此确定该槽没有舰船。 +识别结果中的 ``None`` 表示该位置的舰种未知。native 返回 ``NO`` 有两种可能: +该位置没有舰船,或识别失败。 """ from __future__ import annotations @@ -38,10 +38,11 @@ @dataclass(frozen=True, slots=True) class EnemyObservation: - """一次截图的原始观察,六槽顺序与现有扫描区域相同。 + """一张索敌截图的识别结果,按敌方编队的六个位置依次记录。 - ``ships`` 使用实际安装 native 枚举的中文舰类名;例如 ``Airfield`` 映射为机场, - ``raw_slots`` 保留原码。无效槽数不补齐原始结果,而令全部六槽证据缺失。 + ``raw_slots`` 保留 native 返回的原始舰种代码,``ships`` 保存对应的中文名称, + 例如 ``Airfield`` 对应机场。若返回的代码数量不是六个,保留原始代码, + 将该帧全部舰种记为未知。 OCR 和模板分数只是各识别器的原始分数,不代表节点正确概率。 """ diff --git a/autowsgr/combat/node_fusion/factors.py b/autowsgr/combat/node_fusion/factors.py index cec949bc6..ac1ed2b4d 100644 --- a/autowsgr/combat/node_fusion/factors.py +++ b/autowsgr/combat/node_fusion/factors.py @@ -98,7 +98,7 @@ def _fleet_factor(self, fleet: EnemyVariant, evidence: tuple[_EnemySignature, .. """已知敌情变体使用联合似然;未知变体不调用此项。""" log_model = self._fleet_score(fleet, evidence) if evidence not in self._background_cache: - # 异常帧可能整体像另一支舰队,不能把它当作各槽独立随机错误。 + # 一帧可能把整队识别成另一支舰队,多个位置的错误可能相关。 # 整帧混合项限制这种一致错误带来的过大优势。 scores = np.array([self._fleet_score(fleet, evidence) for fleet in self._all_variants]) self._background_cache[evidence] = _logsum(scores) - math.log(len(scores)) @@ -151,7 +151,7 @@ def diagnostics(self, obs: FusionObservation) -> dict[str, Any]: enemy.detour, ) if not any(signature.ships) and signature.formation is None and signature.detour is None: - return {'available': False, 'reason': '六槽、阵型及迂回信息均缺失', 'weights': {}} + return {'available': False, 'reason': '未识别到敌方舰种、阵型或迂回按钮', 'weights': {}} robust_scores: dict[str, float] = {} supported_nodes = [] for name, node in self.map_data.nodes.items(): diff --git a/autowsgr/combat/node_fusion/integration.py b/autowsgr/combat/node_fusion/integration.py index 68ac138ae..53cd93bd9 100644 --- a/autowsgr/combat/node_fusion/integration.py +++ b/autowsgr/combat/node_fusion/integration.py @@ -299,12 +299,12 @@ def finish(self) -> None: by_node.setdefault(item.node, []).append(item) for node, items in by_node.items(): detail = ';'.join( - f'槽{item.slot} {item.expected}→{item.code}({item.recognized}) ' + f'敌方编队第 {item.slot} 个位置预期为{item.expected},识别为{item.recognized}({item.code})' f'[事件{item.event_id}, 遭遇{item.encounter_id}]' for item in items ) _log.warning( - '[NodeFusion校验] 舰类识别与地图签名不符,请反馈:模式 {} 地图 {} 节点 {}:{}(native {})', + '[NodeFusion校验] 敌舰舰种与地图资料不符,请反馈:模式 {} 地图 {} 节点 {}:{}(native {})', self.combat_mode, self._map_label, node, diff --git a/autowsgr/combat/node_fusion/map.py b/autowsgr/combat/node_fusion/map.py index 1ee4bdbaf..82ecb846c 100644 --- a/autowsgr/combat/node_fusion/map.py +++ b/autowsgr/combat/node_fusion/map.py @@ -23,7 +23,7 @@ _EVENT_MAP_ROOT = _MAP_ROOT.parent / 'event' _SILENT_TYPES = frozenset({'NULL', 'REWARD', 'LOSS'}) _NODE_TYPES = _SILENT_TYPES | {'FIGHT', 'BOSS', 'LITTLE_BOSS', 'AIR_ATTACK', 'SPECIAL_POINT'} -# 从实际安装的 native 枚举取得中文舰类,空槽哨兵不属于敌舰类别。 +# 从当前安装的 native 枚举取得中文舰种,排除代表空位或识别失败的 NO。 SHIP_TYPES = frozenset( value.as_chinese() for name in dir(VesselType) diff --git a/autowsgr/ui/battle/fleet_change/_change.py b/autowsgr/ui/battle/fleet_change/_change.py index 2102c00b2..c30a6d4b4 100644 --- a/autowsgr/ui/battle/fleet_change/_change.py +++ b/autowsgr/ui/battle/fleet_change/_change.py @@ -154,7 +154,7 @@ def _log_snapshot_debug( snapshot: FleetSnapshot, selectors: Sequence[FleetSlotRule | None], ) -> None: - """记录一轮 OCR 合并后的六槽结果、规则与匹配结论。""" + """合并一轮 OCR 结果后,逐个记录编队位置的识别结果、目标规则和匹配结论。""" ship_types = snapshot.ship_types or [None] * 6 ship_levels = snapshot.ship_levels or [None] * 6 for slot, selector in enumerate(selectors): @@ -308,13 +308,13 @@ def _prepare_members_for_reorder( return current, occupied - # 执行一套六槽舰队的完整换船、排序和验证流程。 + # 按目标编队换船、调整顺序并检查结果。 def change_fleet( self, fleet_id: int | None, ship_names: Sequence[FleetSlotRule], ) -> bool: - """返回最终舰队是否符合六个目标槽位。""" + """检查最终编队中每艘船的位置和预留的空位是否符合配置。""" self._last_changed_fleet = None # Step 1:切换到 YAML 指定的舰队。 # 当前舰队已经正确时,不重复点击舰队按钮。 @@ -322,7 +322,7 @@ def change_fleet( self.select_fleet(fleet_id) time.sleep(0.5) - # Step 2:保存六个槽位的规则,不足六槽时补空。 + # Step 2:按编队顺序保存规则,未配置的位置留空。 selectors: list[FleetSlotRule | None] = list(ship_names[:6]) selectors += [None] * (6 - len(selectors)) @@ -333,7 +333,7 @@ def change_fleet( return False # 第一舰队最后一艘舰船不能移除,但第一舰队本身允许更换编成。 if fleet_id == 1 and assigned[0] is None: - raise ValueError('1 队槽位 0 不能为空') + raise ValueError('第 1 舰队必须指定旗舰') expected_pool = self._ocr_target_pool(selectors) snapshot = self._detect_initial_snapshot(expected_pool, selectors) diff --git a/autowsgr/ui/battle/fleet_change/_detect.py b/autowsgr/ui/battle/fleet_change/_detect.py index 4d2bcbcc3..74c91a78b 100644 --- a/autowsgr/ui/battle/fleet_change/_detect.py +++ b/autowsgr/ui/battle/fleet_change/_detect.py @@ -9,7 +9,7 @@ 7. OCR 文本只能使用其所在槽位的目标解决歧义。 8. 目标上下文只接受明确片段或编辑距离内唯一的最近舰名。 9. 不传 expected_names 时继续使用完整船池匹配。 -最终返回六个槽位的舰名,空槽使用 None。 +按编队从左到右返回舰名,空位或未识别出舰名的位置记为 None。 普通检测和旧决战流程不会启用目标上下文。 """ @@ -55,7 +55,7 @@ @dataclass(slots=True) class FleetSnapshot: - """准备页六个槽位累计得到的最终 OCR 信息。""" + """按编队位置汇总是否有船和识别出的舰名,需要时也记录舰种和等级。""" names: list[str | None] occupied: list[bool] @@ -101,7 +101,7 @@ def has_unknown_details(self) -> bool: return bool(self.unknown_slots or self.unknown_type_slots or self.unknown_level_slots) -# 负责识别准备页当前六个舰队槽位。 +# 负责识别准备页上编队中的舰船。 class FleetDetectMixin(BaseBattlePreparation): """提供准备页舰队 OCR 检测能力。""" @@ -126,7 +126,7 @@ def _match_context_ship_name( _log.debug("[准备页] 目标槽位匹配: '{}' -> '{}'", text, matched) return matched - # 识别截图中的六个舰队槽位,并按需使用目标上下文补全舰名。 + # 识别各编队位置的舰名,必要时参考该位置配置的目标舰名。 def detect_fleet( self, screen: np.ndarray | None = None, @@ -134,7 +134,7 @@ def detect_fleet( expected_names: Sequence[str | None] | None = None, expected_pool: Sequence[str] | None = None, ) -> list[str | None]: - """返回长度为六的舰名列表,未占用槽位返回 None。""" + """按六个编队位置返回舰名列表,空位或未识别出舰名的位置为 None。""" # 未传入截图时直接获取当前屏幕。 if screen is None: screen = self._ctrl.screenshot() diff --git a/autowsgr/ui/battle/fleet_change/_rules.py b/autowsgr/ui/battle/fleet_change/_rules.py index 31f4fb93d..cf6e903a4 100644 --- a/autowsgr/ui/battle/fleet_change/_rules.py +++ b/autowsgr/ui/battle/fleet_change/_rules.py @@ -144,7 +144,7 @@ def _slot_matches( option.search_name, ) - # 验证当前六个槽位是否完整满足目标,并拒绝队内同名舰。 + # 逐个核对编队中的舰船和空位,编队中不能有同名舰。 @classmethod def _validate_with_selector( cls, diff --git a/autowsgr/ui/decisive/legacy_fleet_change.py b/autowsgr/ui/decisive/legacy_fleet_change.py index 2089d29e3..308645edd 100644 --- a/autowsgr/ui/decisive/legacy_fleet_change.py +++ b/autowsgr/ui/decisive/legacy_fleet_change.py @@ -35,7 +35,7 @@ def change_fleet_legacy( ] names += [None] * (6 - len(names)) if fleet_id == 1 and names[0] is None: - raise ValueError('1 队槽位 0 不能为空') + raise ValueError('第 1 舰队必须指定旗舰') if fleet_id and page.get_selected_fleet(page._ctrl.screenshot()) != fleet_id: page.select_fleet(fleet_id) @@ -57,7 +57,7 @@ def change_fleet_legacy( slot = next((index for index in range(6) if not ok[index]), None) if slot is None: - _log.warning("[决战] 无可用槽位放置 '{}'", name) + _log.warning('[决战] 编队中没有可以换入 {} 的位置', name) continue selected = page._change_single_ship( diff --git a/testing/combat/node_fusion/test_calibration.py b/testing/combat/node_fusion/test_calibration.py index 6974d5c42..b362b93a6 100644 --- a/testing/combat/node_fusion/test_calibration.py +++ b/testing/combat/node_fusion/test_calibration.py @@ -1,4 +1,4 @@ -"""识别校验只借助去除敌情后的定位核对,不符槽位告警,其余保持静默。""" +"""独立确认节点后,只对舰种与地图资料不符的敌舰发出告警。""" from __future__ import annotations diff --git a/testing/combat/node_fusion/test_decisive_recovery.py b/testing/combat/node_fusion/test_decisive_recovery.py index f12cb7052..890c4d7e7 100644 --- a/testing/combat/node_fusion/test_decisive_recovery.py +++ b/testing/combat/node_fusion/test_decisive_recovery.py @@ -94,7 +94,7 @@ def test_later_enemy_resolves_partial_evidence_conflict_without_more_letters( assert first.node_weights['C'] == pytest.approx(letter_accuracy) assert set(first.node_weights) == set(names) - # 第一个敌情只有一个有效槽,与错误字母冲突时保留歧义和完整候选。 + # 首次索敌只识别出一艘敌舰的舰种,与错误字母冲突时保留全部候选节点。 partial = _phase( tracker, 'first', diff --git a/testing/combat/node_fusion/test_enemy.py b/testing/combat/node_fusion/test_enemy.py index 93fae0fba..3015788a8 100644 --- a/testing/combat/node_fusion/test_enemy.py +++ b/testing/combat/node_fusion/test_enemy.py @@ -1,4 +1,4 @@ -"""验证敌情观测保留槽位,并从同一张输入截图采集证据。""" +"""验证索敌识别保留敌方编队的顺序,并从同一张截图读取各项结果。""" from __future__ import annotations diff --git a/testing/combat/node_fusion/test_evidence.py b/testing/combat/node_fusion/test_evidence.py index 83f2bdbec..b52839578 100644 --- a/testing/combat/node_fusion/test_evidence.py +++ b/testing/combat/node_fusion/test_evidence.py @@ -499,7 +499,7 @@ def test_identical_spot_after_timing_boundary_keeps_both_explanations() -> None: def test_missing_enemy_fields_cannot_repeatedly_split_pending_detour_prior() -> None: - # 两个节点故意使用相同敌情;丢弃已经识别的槽位不能支持任一种新遭遇解释。 + # 两个节点故意使用相同敌情。即使漏读此前已识别的舰种,也没有据此判定新遭遇的依据。 metadata = TrackingMap.from_dict( { '0': _node(['A'], []), diff --git a/testing/combat/node_fusion/test_sequences.py b/testing/combat/node_fusion/test_sequences.py index cd9be89e6..1ba6490fd 100644 --- a/testing/combat/node_fusion/test_sequences.py +++ b/testing/combat/node_fusion/test_sequences.py @@ -119,7 +119,7 @@ def test_2_5_b_c_g_uses_formation_to_separate_identical_fleets() -> None: at_b = replay.phase(enemy=_enemy(metadata, 'B'), decision_node='B') assert max(at_b.node_weights, key=at_b.node_weights.get) == 'B' replay.fight_and_proceed('B') - # F 与 G 的六槽完全相同,阵型分别是 2 和 4。 + # F 与 G 的敌方编队在每个位置的舰种都相同,阵型分别是 2 和 4。 assert ( metadata.nodes['F'].enemy_formations[0].ships == metadata.nodes['G'].enemy_formations[0].ships diff --git a/testing/combat/node_fusion/test_session.py b/testing/combat/node_fusion/test_session.py index 9da9daa80..c6d230d43 100644 --- a/testing/combat/node_fusion/test_session.py +++ b/testing/combat/node_fusion/test_session.py @@ -458,7 +458,7 @@ def test_finish_warns_with_feedback_details_on_mismatch( assert '请反馈' in text assert '地图 2-1' in text assert '节点 A' in text - assert '槽1 驱逐→BB(战列)' in text + assert '敌方编队第 1 个位置预期为驱逐,识别为战列(BB)' in text def test_arrival_logs_attribution_with_channel_candidates( diff --git a/testing/ui/battle_preparation/test_unit.py b/testing/ui/battle_preparation/test_unit.py index 0028b71db..260f05c23 100644 --- a/testing/ui/battle_preparation/test_unit.py +++ b/testing/ui/battle_preparation/test_unit.py @@ -1374,7 +1374,7 @@ def test_original_flow_changes_first_fleet_before_removing_extra_ship(self): def test_original_flow_rejects_empty_first_fleet(self): page = MagicMock() - with pytest.raises(ValueError, match='1 队槽位 0 不能为空'): + with pytest.raises(ValueError, match='第 1 舰队必须指定旗舰'): change_fleet_legacy(page, 1, []) page.detect_fleet.assert_not_called() @@ -1727,7 +1727,7 @@ def test_first_fleet_cannot_be_empty(self): with ( patch.object(page, 'get_selected_fleet', return_value=1), patch.object(page, 'detect_fleet_snapshot') as detect, - pytest.raises(ValueError, match='1 队槽位 0 不能为空'), + pytest.raises(ValueError, match='第 1 舰队必须指定旗舰'), ): page.change_fleet(1, ()) From 7227739950d046f39ec85a19f5076f794004750a Mon Sep 17 00:00:00 2001 From: YaoerWu Date: Thu, 19 Nov 2026 10:28:47 +0800 Subject: [PATCH 8/8] =?UTF-8?q?docs(decisive):=20=E6=9B=B4=E6=96=B0?= =?UTF-8?q?=E9=80=89=E8=B7=AF=E7=BB=B4=E4=BF=AE=E4=B8=8E=E9=87=87=E9=9B=86?= =?UTF-8?q?=E8=AF=B4=E6=98=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- autowsgr/combat/node_fusion/README.md | 33 ++--- docs/architecture/decisive-fusion.md | 75 ++++------ docs/features/ocr-ship-name-reliability.md | 6 +- docs/features/ocr-ship-recognition.md | 10 +- docs/usage/usage_decisive.md | 159 ++++++++++----------- examples/decisive.py | 3 +- tools/decisive/README.md | 22 ++- 7 files changed, 143 insertions(+), 165 deletions(-) diff --git a/autowsgr/combat/node_fusion/README.md b/autowsgr/combat/node_fusion/README.md index 60580f4d4..b775d2f7f 100644 --- a/autowsgr/combat/node_fusion/README.md +++ b/autowsgr/combat/node_fusion/README.md @@ -12,7 +12,7 @@ - `map.py`:地图校验、能力声明、路径枚举、快照指纹及 native 舰类集合。 - `geometry.py`:资料不足时的几何证据组合,以及已有路由的可达性约束。 - `position.py`:只检测本帧船位,不保存节点状态或复用旧船位。 -- `enemy.py`:从同一索敌截图采集六槽、阵型和迂回按钮证据。 +- `enemy.py`:从同一张索敌截图识别敌方编队每个位置的舰种、敌方阵型和迂回按钮。 - `integration.py`:出征级 `TrackingSession`,适配观测、确认当前节点、保存诊断日志。 - `coordinates.py`:旧 YAML 坐标及入口读取,保留缺失信息,不包含追踪算法。 - `replay.py`:离线重放;`tools/node_fusion/replay.py` 只是命令入口。 @@ -43,9 +43,9 @@ NULL、REWARD、LOSS 可以静默经过,几何证据按真实航段逐段评 战斗节点构成的环路可重复经过;纯静默环路明确报告元数据异常,避免无限枚举。 距离与射线按加权混合组成一个几何因子,不是两次独立投票。帧间隔越大,方向权重越低。 -六槽按位置对应;舰类集合与误识别类别数直接来自实际安装的 native `VesselType`。 -同一次遭遇共享敌情变体,阵型与舰类联合匹配。未知槽位、NO、未知阵型与未检出迂回按钮 -作为缺失证据。整帧异常项保留相关误识别的可能;重复读取只更新同一遭遇的聚合因子, +模型按敌方编队顺序逐个位置比对舰种。舰种集合与误识别类别数来自当前安装的 native `VesselType`。 +同一次遭遇共享敌情变体,阵型与舰种联合匹配。某个位置的舰种未知或识别为 `NO` 时,跳过该位置。 +阵型未知或未检出迂回按钮时也跳过相应证据。整帧异常项保留相关误识别的可能;重复读取只更新同一遭遇的聚合因子, 不按轮询次数连乘。每次真实迂回点击仅分配一次结果先验。 模型默认参数集中在 `FusionProfile`。舰类/阵型正确识别率初值 0.9、整帧异常权重 0.1 @@ -72,8 +72,9 @@ Tracking JSON,文件不存在时回退读取同名旧 YAML(当前 20260930 未知节点类型不会被当作 `NULL` 或战斗点;出现索敌、阵型等页面只确认新证据支持的位置, 不会自动前进一条边。只知道坐标时,没有本航段的新船位证据就不能确认下一个节点。 -决战的 `MapData.tracking_map(chapter, stage)` 从中文 `enemy_spec.yaml` 构造顺序小关。 -移除旧数组首位占位后规范成有序六槽,空槽保留 `None`;缺敌情、敌方阵型和坐标保持未知。 +决战的 `MapData.tracking_map(chapter, stage)` 从 18 份 EX YAML 将真实分支投影为可观测字母。 +有敌情记录时,按编队顺序返回六个位置的中文舰种简称,空位记为 `None`。没有敌情记录时返回 `[]`。 +敌方阵型和坐标在资料中缺失时也保持未知。 `AF→机场`、`BG→大巡`、`BBG→导战`,补给舰与机场独立处理。决战不伪造起点 `0` 或几何资料,由显式决战场景使用其确定推进规则。 @@ -108,7 +109,7 @@ log: | `history_prior` | 历史状态和合法地图转移产生的候选权重 | | `distance` | 全图船位距离、似然及归一化候选,仅作独立观察 | | `ray` | 全图射线距离、有效帧间隔、混合权重及不可用原因 | -| `enemy` | 六槽、阵型、联合敌情的各节点评分与候选 | +| `enemy` | 敌方编队每个位置的舰种、阵型、迂回按钮识别结果,以及据此计算的候选节点评分 | | `geometry` | 模型实际采用的航段评分,或降级后的节点几何评分 | | `fusion` | 最终节点、航行目的点、最佳路线和历史修订 | @@ -131,8 +132,8 @@ log: ## 识别校验 会话结束时核对 native 敌方舰类识别:全程与地图签名一致则保持静默;出现不符时按节点 -汇总 `[NodeFusion校验]` WARNING,携带模式、地图/小关、节点、槽位、期望中文舰类、 -native 原始识别码及中文解释、native 版本,供用户向维护者反馈。每项还保留观测 +汇总 `[NodeFusion校验]` WARNING,列出模式、地图/小关、节点、敌舰在编队中的位置、 +资料记载的舰种、识别到的舰种及其原始代码、native 版本,供用户向维护者反馈。每项还保留观测 `event_id` 与遭遇 `encounter_id`,便于关联采集记录。它不参与战斗控制,不自动修改 native 参数或 `FusionProfile`,也不因页面轮询重复告警。 @@ -140,10 +141,10 @@ native 参数或 `FusionProfile`,也不因页面轮询重复告警。 平滑定位,保留原场景和初始条件,要求权重至少 0.95 且与最佳历史路线一致。决战可使用 确定 A、经确认的推进和地图字母观测。该阈值是模型权重,不是校准后的准确率。 每次遭遇只取最早索敌帧,保留 -首次识别失败;后续证据可以修正此前标签,校验不改写原始观测或已执行动作。只有节点 -全部合法敌情变体中一致的舰类槽位才用于核对,不用待测结果挑选模板。 +首次识别失败;后续证据可以修正此前标签,校验不改写原始观测或已执行动作。 +一个节点可能有多种敌方编队。只有这些编队在同一位置上的舰种都相同时,才核对该位置的识别结果。 -变体分歧槽、空槽、NO/未知原始码无法核对。无法独立定位时保留原始样本,不生成具有 +资料中该位置为空、识别结果为 `NO` 或代码未知时,跳过该位置。无法独立定位时保留原始样本,不生成具有 确定节点标签的异常结论。原始码以当前安装的 native 枚举解释,例如机场通常输出 `Airfield`,资料里的旧 `AF` 只作为机场迁移别名。 @@ -151,13 +152,13 @@ native 参数或 `FusionProfile`,也不因页面轮询重复告警。 | 模式与模板 | native 原始读数 | 处理 | | --- | --- | --- | -| 普通战第 3 槽(数组索引 2),期望非补给 | `AP` | 战利品补给豁免 | -| 普通战其它槽,期望非补给 | `AP` | 正常反馈不符 | -| 活动/决战任何槽,期望非补给 | `AP` | 正常反馈不符 | +| 普通战敌方编队第三个位置(数组索引 2),资料记载非补给 | `AP` | 可能是战利品补给舰,免报告警 | +| 普通战敌方编队的其他位置,资料记载非补给 | `AP` | 报告舰种不符 | +| 活动/决战敌方编队的任意位置,资料记载非补给 | `AP` | 报告舰种不符 | | 任意模式,期望补给 | `AP` | 正常匹配,静默 | | 全部合法变体整队都是补给 | 任意有效识别码 | 资料可能过期,独立整队模板豁免 | -最后一条是已有的资料可信度规则,与普通战第 3 槽战利品机制分开处理。 +最后一条是已有的资料可信度规则,与普通战敌方编队第三个位置出现战利品补给舰的机制分开处理。 ## 回放 diff --git a/docs/architecture/decisive-fusion.md b/docs/architecture/decisive-fusion.md index 4e24a0265..d33bcbb7d 100644 --- a/docs/architecture/decisive-fusion.md +++ b/docs/architecture/decisive-fusion.md @@ -34,13 +34,30 @@ 购舰点击只表示尝试购买,不直接增加 `state.ships`;费用 OCR 错误或余额不足时, 卡片可能没有实际购入。发生购舰点击或使用副官技能后,准备阶段复用现有舰队扫描, 从实际编队及可用舰船刷新库存,再生成目标编队。购买和技能产生的刷新请求合并为 -一次扫描,包括免费卡和技能卡;已有完整舰队且没有购买或使用技能时不会额外扫描。 +一次扫描,包括免费卡和技能卡。购舰窗口未选中卡片时也会实查库存。 分数识别得到的 `0` 会覆盖旧余额,不使用旧值代替零预算。 +## 舰船维修与暂离 + +在用户配置顶层设置 `quick_repair_threshold_seconds`(非负整数,单位为秒)。 +默认值为 `null`,保留原有快修行为。设置阈值后,决战先检查当前编队的舰船名称、 +维修中标记和损伤。达到本场维修标准的舰船才按时长分流:先在浴室确认待修舰的时长,短于阈值立即入浴。 +等于或超过阈值时优先换上健康候补。候补不足时才用快修桶,每用一个桶都先确认这艘船已能出征,再决定是否要修下一艘。浴室显示 `00:00:00` 时按零秒判断。读不出时长就跳过这艘船,优先用候补补齐,其次等待其他已入浴的舰船修好。仍无法补齐时保留存档并报告舰名。 + +调度器按节点串行执行决战,与已启用的日常任务共用优先级队列。战果只推进一次遭遇。处理战后选路、战备卡片并确认下一节点地图后,调度器才交接页面。下个节点可原地继续;其他任务需要设备时,决战先安全暂离到总览。重进时保留本小关的遭遇历史,核对存档并重新定位。终点收完掉落后直接在总览交接。浴室满时保留待派修名单。 +已确认在修的舰船按登记的结束时间复查;结束时间未知时从首次确认起等 180 秒。 +重复看到同一个“维修中”标记不会延后复查。到点后,从新的准备页截图逐艘核对舰名和伤情;仍在修则继续等待, +身份或状态不明则保留待复核。当前已获得的配置主备舰按身份去重,最多需要六艘; +健康替补凑够这一规模即可提前恢复。等待期间可停止,等待不会消耗轮次或异常重试次数。 + +购买时在实际预算内优先凑齐不同舰船,再比较一级舰数和总花费。首节点先凑两艘, +随后补至六艘,再补一级舰和升级。无购买也核实实际库存;撤退重新开始时重新读入口。 +同一节点连续识别失败时,从当前页面恢复,最多尝试三次(含首次)。 + ## 共享内核与场景策略 `FusionTracker` 保留唯一的前向计算、Viterbi 路径、历史平滑、历史修订和观测去重。 -`MapDynamics` 保存普通/活动地图原有转移;`DecisiveDynamics` 提供顺序节点、 +`MapDynamics` 保存普通/活动地图原有转移;`DecisiveDynamics` 提供 EX 图分支、 显式初始分布、已确认战斗推进和真实通关约束。 `EnemyFactor`、`GeometryFactor`、`NodeLabelFactor` 分别为全部合法候选产生对数因子。 @@ -48,9 +65,10 @@ 跨事件历史由模型统一保存,历史和战后 `+1` 属于转移约束,不作为另两份独立投票。 决战地图不伪造入口、坐标或敌方阵型。 -地图敌情采用中文简名,移除旧首位占位后规范为有序六槽。`AF` 对应机场, -`BG` 对应大巡,`BBG` 对应导战,`AP` 对应补给;空槽位置不挤压。 -缺失敌情与已知空槽不同。84 个已有节点的反潜统计和战术选择由回归测试冻结。 +18 份 EX 图保存 319 个节点、401 条边及 154 条敌情。追踪器从图中读取分支、终点和敌方编队, +按编队顺序将每个位置的舰种代码转为中文。`AF` 对应机场,`BG` 对应大巡,`BBG` 对应导战,`AP` 对应补给。 +没有敌情记录时返回 `[]`。有记录时返回六个位置,空位记为 `None`,后面的舰船保留原位。 +EX-4-1 G、EX-4-3 G、EX-6-3 D 采用 EX 原图编成。 ## 主动采样与性能 @@ -74,13 +92,14 @@ 进度及样本路径保存在输出目录。 样本保存稳定地图、节点裁剪、索敌、战果及通关前后画面,关联帧序号、单调采集时间、 -遭遇 ID、native 版本、原始六槽、中文结果、阵型 OCR 和分项耗时。 +遭遇 ID、native 版本、按敌方编队顺序识别的原始舰种代码及其中文名称、阵型 OCR 和分项耗时。 `predicted_node` 与 `label_node` 分开;只有用户确认起点和已经验证的流程推进可产生标签。 未知恢复不能把预测节点写成人工真值。异常现场落盘后停止,修复后按实际剩余进度续采。 native 异常反馈仅帮助维护者复核识别,不自动调整参数,也不改变战斗决策。 独立参考定位重放排除敌情但保留场景、起点和推进规则。无法独立定位时只保留样本。 -只有普通战第 3 槽适用战利品 AP 豁免;活动与决战不适用,其他槽也不适用。 +普通战中,敌方编队第三个位置可能出现战利品补给舰,因此这里识别为 `AP` 时免报舰种不符。 +其他位置以及活动、决战中的敌舰都按地图资料核对。 正常补给匹配静默,整队补给模板过期资料豁免独立保留。 v4 回放冻结场景、初始条件、战斗模式、采样参数、中文地图与原始观测,逐事件核对在线结果。 @@ -130,42 +149,6 @@ v4 回放冻结场景、初始条件、战斗模式、采样参数、中文地 - `state.node` 和引擎节点只记录业务执行快照,不反向约束模型。模型计算、采样阈值与 v4 日志字段不因这些接口调整改变。 -### 完整库存扫描与选船 - -`DecisiveShipListWalker` 共用于库存扫描和决战新旧换船算法。页面身份与“全部舰船/全部” -筛选必须正向确认;国家、舰种、状态或尺寸筛选都会改变综合筛选按钮,因此不能把筛选后的 -空列表当作完整候选列表。系统离队卡须单独识别,不进入舰名集合;在队舰船由准备页六槽补入。 - -遍历器先确认顶部,每个视口等待两个不同解码帧稳定,再按完整卡位绑定规范舰名。向下 -小步滚动须保留至少一整行有序重叠;保留重复舰名及顺序校验,全部验证后才转集合。 -滑块到底还不够:尾部截断卡须继续滚动至完整覆盖。已确认顶部和底部的单屏库存直接完成, -不会为了极端溢出场景让正常单屏库存额外滚动。OCR 原位最多三次、视口稳定最多五秒、 -回顶与向下遍历合计最多八十次滚动,预算耗尽、身份歧义、停止或覆盖丢失均抛扫描异常。 -候选为空也必须正向确认:全量筛选、完整上下端点、无舰名蓝条及整个候选区域的已取证 -深蓝空背景都须成立,再由两个不同解码帧确认稳定;存在离队卡时只排除已识别的控制卡区域。 -从已占用槽和空槽进入分别验证,不能把 OCR 或定位失败当作空候选。 -`scan()` 返回空集合只表示没有可选的备用舰船,不表示总库存为空;完整库存仍合并在队六槽。 - -`check_fleet()` 只有完成列表扫描、返回准备页并验证回到地图后,才返回原有三元组。 -准备页未知占用槽复用既有单槽舰名 OCR,最多补识别两次;不注入预期编队或舰名池, -仍有未知槽或收到停止请求时不进入选船列表。 -控制器一次性发布舰船、六槽编队和血量;失败保留旧业务快照与待刷新标志,并停止本轮。 -`_inventory_refresh_required` 是唯一刷新标志:恢复、重置、小关转换、撤退、购舰点击与 -技能尝试使其失效;完整扫描、返回和发布成功才清除。普通路径合并购买与技能刷新; -严格技能判断在库存失效时先扫描技能前库存,技能后再扫描。 - -决战选船每次重新进入列表都从实际顶部定位,使用当前稳定观察的点击坐标;两种换船算法 -共用既有候选约束与点击逻辑。换船返回成功后仍独立核对实际六槽,再允许修理与开战。 -普通战默认三轮找船与强化库存扫描保持原有业务流程,只复用底层卡片几何和滚动条识别。 - -第三批已完成实机验收:用玩家手动游玩后十五船、六空槽的真实现场确认首屏十四船、 -滚动后新增 U-96、完整扫描及返回地图,以及新旧换船算法选中 U-96 后恢复空编队。 -临时六舰在队后,九艘候选的单屏扫描零滚动,合并库存仍为十五艘;验收后恢复六空槽。 -从溢出现场继承的非顶部位置仍需先回顶,这与单屏正常入口的零滚动路径分别验证。 -空候选验收使用三舰在队、无备用舰船的真实现场;已占用槽与空槽的两个入口均返回零候选, -完整扫描与库存发布仍保留三舰、六槽和血量,验证往返地图,未改动编队或执行战斗。 -这里的“空库”指可选列表为空,不要求总库存为空;筛选所得空列表不能替代该验收。 - -测试应区分算法、接口契约和实际页面验证。合成地图和像素输入用于确定性覆盖边界; -余额测试经过真实重试 helper,小关编号测试经过真实像素识别,采集顺序测试运行生产战后 -处理器并转换其实际输出。控件模拟测试只证明流程协议,不能替代模拟器中的模板和页面验证。 +### 查看可用舰船与换船 + +决战在准备页核对当前舰船,在选船列表使用首屏 OCR 读取可选舰名。购买、使用技能或重入后按需刷新。换船后,再次核对实际编队中的每个位置。浴室查找待修舰船时会检查后续页。 diff --git a/docs/features/ocr-ship-name-reliability.md b/docs/features/ocr-ship-name-reliability.md index 69a116f6b..ac27b5feb 100644 --- a/docs/features/ocr-ship-name-reliability.md +++ b/docs/features/ocr-ship-name-reliability.md @@ -64,11 +64,11 @@ ocr: - `鳟盹` 可由确定性规则修正为鳞鲀,不再误选胡德。 - `帅` 等单字误识别不再猜成其他单字舰名。 - `Il0/ll0/1l0` 可解析为 110,超出 `1-110` 的等级会被拒绝。 -- YAML 目标不再跨槽补名。 +- 某个编队位置漏读舰名时,不会用其他位置配置的舰名来填。 - 用户别名可将四个显示名稳定映射到 `AIII`、`85工程`、`U-47` 和 `巴尔的摩`,无需放宽全船池模糊匹配。 -- 智能换船定向实机测试只搜索 `契卡洛夫`,已有岛风只调位,最终编队逐槽一致。 -- 1 队槽位 0 和整队为空的拒绝逻辑已通过聚焦测试。 +- 智能换船实机测试只搜索了 `契卡洛夫`。岛风已在队,只调整位置,最终舰名和顺序均与配置一致。 +- 测试已验证两种情况都会拒绝换船:第 1 舰队未指定旗舰,或目标编队为空。 ## 不在本轮处理 diff --git a/docs/features/ocr-ship-recognition.md b/docs/features/ocr-ship-recognition.md index 61b1d2b97..c38a6c4a5 100644 --- a/docs/features/ocr-ship-recognition.md +++ b/docs/features/ocr-ship-recognition.md @@ -7,7 +7,7 @@ 测试覆盖: -- 准备页六个槽位的等级和舰种; +- 准备页上每艘舰船的等级和舰种; - ADB 无损截图与 scrcpy H264 截图; - FastOCR、RapidOCR、EasyOCR 和 LuLing-OCR 对照; - 原图与逐 ROI Otsu 二值图; @@ -59,7 +59,7 @@ 样本覆盖个位数、三位数和游戏等级上限。每种模型、每种预处理的统计口径为: ```text -4 支舰队 x 2 种截图源 x 6 个槽位 x 3 轮 = 144 次 +4 支舰队 x 2 种截图源 x 6 个编队位置 x 3 轮 = 144 次 ``` ### 3.2 2592 次识别汇总 @@ -108,7 +108,7 @@ 四支舰队真值: -| 舰队 | 六个槽位 | +| 舰队 | 各位置的舰种(按编队顺序) | |---|---| | 1 | 航母、轻母、装母、战列、航战、战巡 | | 2 | 重巡、航巡、雷巡、轻巡、重炮、驱逐 | @@ -198,7 +198,7 @@ FastOCR 原图平均 10.47ms/槽,EasyOCR 优化原图平均 14.57ms/槽,Easy 先定义统一工作流,由 Agent 独立执行并按准确率、耗时判断优势方案: -- 统一统计口径:`4 队 x 2 截图源 x 6 槽 x 3 轮 = 144 次/模型 x 输入维度`; +- 统一统计口径:`4 队 x 2 截图源 x 6 个编队位置 x 3 轮 = 144 次/模型 x 输入维度`; - 等级识别共执行 2592 次,每个候选组合分别测试原图和 Otsu 二值图; - 候选包含 FastOCR 的五个 PP-OCR 模型、RapidOCR 3.9.2、LuLing-OCR、EasyOCR 原版和优化参数; @@ -229,7 +229,7 @@ FastOCR 原图平均 10.47ms/槽,EasyOCR 优化原图平均 14.57ms/槽,Easy 将人工敲定的识别方案放回完整智能换船链路持续调优: -- 按 1280x720 重新校准六槽等级和舰种 ROI,并统一字符白名单、纠错和 1 至 110 校验; +- 在 1280x720 截图上重新校准六个编队位置各自的等级和舰种识别区域,并统一字符白名单、纠错和 1 至 110 校验; - 准备页以四级快照累积信息,只补未知或严格规则下明确错误的字段; - 用 `verified_slots` 跳过已经在位且满足规则的舰船,避免进入船池后无法找到当前舰船; - 主选身份未知时先使用备选托底,再对主选执行一次回查,失败后保留备选或明确退出; diff --git a/docs/usage/usage_decisive.md b/docs/usage/usage_decisive.md index dae711656..eed1ab06e 100644 --- a/docs/usage/usage_decisive.md +++ b/docs/usage/usage_decisive.md @@ -23,9 +23,9 @@ - **3 个小关** (Stage 1~3),通过全部后大关通关 - **每个小关多节点**,需要逐节点推进 - **舰队获取**: 从卡池中选择舰船组建临时舰队 -- **进阶选择**: 每完成一个小关选择增益 buff -- **修理受限**: 无法使用正常修理,依赖进阶修复卡 -- **掉线惩罚**: 撤退会清空当前章节所有进度 +- **前进点选择**:识别两张或三张路线卡,选择最左侧路线 +- **舰船维修**:按损伤标准快修,也可配置维修时长阈值,暂离入浴后继续本小关 +- **撤退**: 撤退会清空当前章节所有进度 --- @@ -59,15 +59,17 @@ config = DecisiveConfig( | 字段 | 类型 | 默认值 | 说明 | |------|------|--------|------| | `chapter` | int | `6` | 决战章节编号 (1~6) | -| `level1` | list[str] | `[]` | 一级舰队舰船名列表 (核心,优先选择) | -| `level2` | list[str] | `[]` | 二级舰队舰船名列表 (备选,补充选择) | -| `flagship_priority` | list[str] | `[]` | 旗舰优先级队列 (按顺序尝试) | -| `repair_level` | int | `2` | 修理策略: 1=中破即修, 2=大破才修 | -| `full_destroy` | bool | `True` | 船舱满时自动解装 | +| `level1` | list[str] | 鲃鱼、U-1206、U-47、射水鱼、U-96、U-1405 | 一级舰队舰船名列表 (核心,优先选择) | +| `level2` | list[str] | U-81、大青花鱼 | 二级舰队舰船名列表 (备选,补充选择) | +| `flagship_priority` | list[str] | U-1405、U-47、U-96、U-1206 | 旗舰优先级队列 (按顺序尝试) | +| `repair_level` | int | `1` | 修理策略: 1=中破即修, 2=大破才修 | +| `full_destroy` | bool | `False` | 船舱满时自动解装 | -### YAML 配置 (在 user_settings.yaml 中) +### YAML 配置 (在 usersettings.yaml 中) ```yaml +# 顶层用户设置,单位为秒。可省略或设为 null 以沿用原有维修方式。 +quick_repair_threshold_seconds: 1800 decisive_battle: chapter: 6 level1: ["鲃鱼", "U-1206", "射水鱼", "U-96", "U-1405", "U-47"] @@ -79,12 +81,23 @@ decisive_battle: --- +设置为 1800 时,发现需要维修的舰船后,程序会在可以暂离时去浴室查看时长。短于 30 分钟就送入浴室,达到或超过 30 分钟就优先换上健康候补。本小关已获得几艘不同的配置舰船,就需要几艘出征,最多六艘。候补能补齐就继续出征,仍缺船时才给维修时间长的舰船用快修桶。 + +舰船入浴后,到登记的维修结束时间,再到准备页核对这艘船的伤情,候补舰也一样。如果只看到“维修中”标记,第一次看到后等 180 秒再查。如果在浴室读不出待修舰的维修时长,这次就跳过这艘船。候补足够就继续出击;如果还缺船,但有其他舰船修好后能补齐,就等到它们的维修结束时间再查。无法补齐时,程序会保留存档并报告舰名。浴室满时会等空位,期间仍可处理日常任务或停止。 + +每打一场,程序处理完战果、选路和购舰,确认到达下一节点地图后,再检查有没有其他任务。如果接下来还是决战,就留在地图继续打。如果要收远征等奖励,就先暂离,办完后从同一存档继续。打完终点会先领完掉落,回到决战总览,再执行下一项任务。决战期间可以执行已启用的日常任务,普通战只在普通战模式下运行。 + +出征前,程序从同一张准备页截图核对编队。例如只上阵三艘时,要读出这三艘的舰名,从血条或“维修中”标记确认各自的伤情,再确认其余三个位置为空。如果看到了血条却没读出舰名,程序会留在准备页重新截图,两秒内最多再读五次。核对完整后才更新编队和伤情。 + ## 3. 基本用法 +重新启动决战时,如果游戏停在决战地图,程序会先选择“暂离”保存进度。如果停在出征准备页,程序会先核实“主力决战舰队”标题,再返回决战地图暂离。回到总览后,只有存档章节与配置相符且当前小关可识别时才会继续。 + ### 执行一次决战 ```python -from autowsgr.ops.decisive import DecisiveConfig, DecisiveController, DecisiveResult +from autowsgr.infra import DecisiveConfig +from autowsgr.ops.decisive import DecisiveController, DecisiveResult config = DecisiveConfig( chapter=6, @@ -94,7 +107,7 @@ config = DecisiveConfig( repair_level=2, ) -controller = DecisiveController(ctrl, config, image_matcher=image_matcher) +controller = DecisiveController(ctx, config) result = controller.run() match result: @@ -104,6 +117,8 @@ match result: print("撤退 (进度清空)") case DecisiveResult.LEAVE: print("暂离保存") + case DecisiveResult.STOPPED: + print("用户停止,本轮未完成") case DecisiveResult.ERROR: print("异常退出") ``` @@ -117,14 +132,15 @@ for i, r in enumerate(results): print(f"第 {i+1} 轮: {r.value}") ``` -> `run_for_times()` 遇到 `LEAVE` 或 `ERROR` 时自动停止。 +> `run_for_times()` 只在上一轮通关后开始下一轮。 -### 通过 ops 统一导入 +### 传入本次运行的用户配置 ```python -from autowsgr.ops import DecisiveConfig, DecisiveController, DecisiveResult +from autowsgr.infra import DecisiveConfig +from autowsgr.ops.decisive import DecisiveController -controller = DecisiveController(ctrl, config) +controller = DecisiveController(ctx, config, user_config=ctx.config) result = controller.run() ``` @@ -132,57 +148,51 @@ result = controller.run() ## 4. 架构与状态机 -### 模块拆分 (7 个文件) +### 控制器模块 ``` ops/decisive/ ├── __init__.py # 公共导出 -├── _config.py # DecisiveConfig 配置 -├── _state.py # DecisivePhase 枚举 + DecisiveState 状态 -├── _logic.py # DecisiveLogic 纯决策逻辑 -├── _handlers.py # PhaseHandlersMixin 阶段处理器 (12 个) -├── _overlay.py # 决战 overlay/弹窗检测 + 坐标常量 -└── _controller.py # DecisiveController 主控制器 +├── config.py # EX 地图与敌情 +├── state.py # DecisivePhase 枚举 + DecisiveState 状态 +├── logic.py # DecisiveLogic 纯决策逻辑 +├── handlers.py # 决战阶段处理器 +├── repair.py # 按舰名派修、等待及恢复 +└── controller.py # DecisiveController 主控制器 ``` ### 状态机流程 -``` - ┌──────────────────────────────┐ - │ │ -ENTER_MAP ──→ CHOOSE_FLEET ──→ MAP_READY │ - │ │ - ┌──────────────┤ │ - ↓ ↓ │ - ADVANCE_CHOICE PREPARE_COMBAT │ - │ ↓ │ - │ IN_COMBAT │ - │ ↓ │ - │ NODE_RESULT │ - │ │ │ - └──────────────┤ │ - │ │ - ┌──────────────┼──────────────┐ │ - ↓ ↓ ↓ │ - MAP_READY STAGE_CLEAR RETREAT ──┘ - │ - ┌──────────────┤ - ↓ ↓ - ENTER_MAP CHAPTER_CLEAR ──→ FINISHED - ↑ - └── (下一个小关) +```mermaid +flowchart TD + E[进入并核实小关] --> M[等待地图或浮窗] + M -->|上次舰队或选路| M + M -->|购舰并关窗| P[核实库存、编队及维修] + M -->|地图就绪| P + P -->|已获得的舰船不足| R[撤退重入] --> E + P -->|需要派修或等待| W[暂离并保存当前小关] + W -->|到期复查或替补足够| E + P -->|可用舰船足够| B[出征] + B --> N[确认战果与返回页面] + N -->|下一节点| M + N -->|真实通关页| S[结算掉落] + S -->|尚有小关| E + S -->|第三小关完成| F[本轮通关] ``` -### DecisivePhase 枚举 (14 个状态) +### DecisivePhase 枚举 | 阶段 | 说明 | |------|------| | `INIT` | 初始化 | | `ENTER_MAP` | 进入地图 | -| `CHOOSE_FLEET` | 首次选择舰队 | -| `MAP_READY` | 地图就绪,等待行动 | -| `ADVANCE_CHOICE` | 进阶选择 (buff) | +| `CHOOSE_FLEET` | 从战备卡片购买舰船或技能 | +| `WAITING_FOR_MAP` | 确认地图或浮窗 | +| `USE_LAST_FLEET` | 使用上次舰队 | +| `DOCK_FULL` | 船坞已满 | +| `ADVANCE_CHOICE` | 识别两卡或三卡路线,选择最左侧前进点 | | `PREPARE_COMBAT` | 出征准备 | +| `WAITING_FOR_REPAIR` | 保存当前小关,等待派修或复查 | | `IN_COMBAT` | 战斗进行中 | | `NODE_RESULT` | 节点战斗结果 | | `STAGE_CLEAR` | 小关通关 | @@ -199,6 +209,7 @@ ENTER_MAP ──→ CHOOSE_FLEET ──→ MAP_READY │ | `RETREAT` | 撤退 (清空进度) | | `LEAVE` | 暂离保存 (保留进度) | | `ERROR` | 异常退出 | +| `STOPPED` | 用户停止,本轮未完成 | --- @@ -208,18 +219,18 @@ ENTER_MAP ──→ CHOOSE_FLEET ──→ MAP_READY │ 决战中舰队选择由 `DecisiveLogic` 管理: -1. **choose_ships()**: 从卡池中按 level1 → level2 优先级选择舰船 -2. **get_best_fleet()**: 选出最佳 6 人舰队编成 -3. **should_retreat()**: 判断是否需要撤退 (可用舰船不足) -4. **should_repair()**: 根据 `repair_level` 判断是否需要修理 -5. **get_advance_choice()**: 从进阶选项中选择最佳 buff +1. `choose_ships()` 在预算内优先新增不同舰船,再比较一级舰数量和费用 +2. `get_best_fleet()` 从可用主备舰中选择至多六艘 +3. `should_retreat()` 判断当前节点已获得的主备舰数是否足够 +4. 出征前,从同一张准备页截图核对舰名、血条和“维修中”标记,确认哪些船可以出征。 +5. 前进点浮窗按实际卡片数选择最左侧路线。 ### 舰队优先级 ``` Level 1 (一级舰队) → 最高优先级,核心主力 Level 2 (二级舰队) → 补充选择,替补 -其他可用舰船 → 最低优先级 +目标规模 → 已获得的不同主备舰数,最多六艘 ``` ### 旗舰选择 @@ -230,26 +241,10 @@ Level 2 (二级舰队) → 补充选择,替补 ## 6. 进阶用法 -### 自定义 OCR 函数 - -决战的某些操作需要 OCR 识别 (如舰船名称): - -```python -from autowsgr.vision.ocr import OCREngine - -ocr = OCREngine.create("easyocr", gpu=False) - -controller = DecisiveController( - ctrl, config, - ocr_func=ocr.recognize_single, - image_matcher=image_matcher, -) -``` - ### 查询当前状态 ```python -controller = DecisiveController(ctrl, config) +controller = DecisiveController(ctx, config) # 执行过程中可以查看状态 state = controller.state @@ -264,11 +259,11 @@ print(f"舰队血量: {state.ship_stats}") |------|------|------| | `chapter` | int | 当前章节 | | `stage` | int | 当前小关 (1~3) | -| `node` | int | 当前节点 | +| `node` | str | 当前节点 | | `phase` | DecisivePhase | 当前状态机阶段 | | `ship_stats` | list[int] | 6 舰血量 (0=正常) | -| `fleet` | FleetSelection | 当前编队选择 | -| `is_begin` | bool | 是否为本小关首次进入 | +| `fleet` | list[str] | 当前编队,1~6 为舰位 | +| `ships` | set[str] | 已核实的库存 | --- @@ -278,13 +273,13 @@ print(f"舰队血量: {state.ship_stats}") | 维度 | v1 | v2 | |------|----|----| -| 代码组织 | 单文件 `decisive_battle.py` (~500行) | 7 个模块,职责分离 | -| 配置 | `DecisiveBattleConfig` (dataclass) | `DecisiveConfig` (独立 dataclass) | +| 代码组织 | 单文件 `decisive_battle.py` (~500行) | 控制器、UI 与决策模块 | +| 配置 | `DecisiveBattleConfig` (dataclass) | `DecisiveConfig` (Pydantic 模型) | | 战斗逻辑 | 内嵌在 `DecisiveBattle` 中 | 委托 `CombatEngine` | | 决策 | `Logic` 类内嵌 | `DecisiveLogic` 独立 | | 状态管理 | `DecisiveStats` | `DecisiveState` + `DecisivePhase` 枚举 | -| overlay 处理 | 硬编码坐标 | `_overlay.py` 集中管理 | -| 修理 | 自定义实现 | 复用 `apply_repair()` + `BattlePreparationPage` | +| overlay 处理 | 硬编码坐标 | `ui/decisive/overlay.py` 集中管理 | +| 修理 | 自定义实现 | 按舰名核实、快修或暂离入浴 | ### API 对比 @@ -302,7 +297,7 @@ from autowsgr.ops.decisive import DecisiveController from autowsgr.infra import DecisiveConfig config = DecisiveConfig(chapter=6, level1=[...], level2=[...]) -controller = DecisiveController(ctrl, config, image_matcher=matcher) +controller = DecisiveController(ctx, config) results = controller.run_for_times(3) ``` @@ -310,7 +305,7 @@ results = controller.run_for_times(3) | 能力 | v1 | v2 | |------|----|----| -| 状态机可视化 | ❌ | ✅ 14 状态枚举 | +| 状态机可视化 | ❌ | ✅ 阶段枚举 | | 战斗引擎集成 | ❌ 硬编码 | ✅ CombatEngine | | 运行时状态查询 | ❌ | ✅ `controller.state` | | 单元可测试 | ❌ 依赖 timer | ✅ mock ctrl | diff --git a/examples/decisive.py b/examples/decisive.py index 6ebb3ef68..0334717c3 100644 --- a/examples/decisive.py +++ b/examples/decisive.py @@ -1,6 +1,7 @@ """最小示例 — 刷决战 (第 6 章)。 -执行 1 轮完整决战 (3 个小关)。 +每轮执行 1 章(3 个小关)。节点间和等待维修时,调度器会执行配置中已启用的日常任务。 +常规战与决战共用舰船,决战期间关闭常规战触发器。 需根据自己的舰船配置修改 level1 / level2 / flagship_priority。 """ diff --git a/tools/decisive/README.md b/tools/decisive/README.md index 4e8f97662..a6aa5bb13 100644 --- a/tools/decisive/README.md +++ b/tools/decisive/README.md @@ -6,12 +6,13 @@ `testing/fixtures/decisive-clear/` 和 `testing/fixtures/decisive-observations/` 已忽略。 生产识别需要的通用控件模板仍位于 `autowsgr/data/images/decisive/`。 +以下命令从仓库根目录运行。将 `usersettings.yaml` 换成你的配置文件,采集结果写入仓库外的空目录 `../decisive-samples/run-01`。 在固定提交的独立 worktree 运行,使用现有虚拟环境。首次启动保留当前地图; 如果实际位于主页,则导航到第 6 章,核实小关后进入已有进度,不额外重置。 首轮若出现「重置关卡」入口立即保存现场停止。只有完成本轮三小关后才开始下一轮并正常重置章节。 ```powershell -python -m tools.decisive.collect --config D:/Games/autowsgr/user_settings.yaml --output D:/Games/autowsgr/decisive-samples/run-01 --rounds 3 --start-stage 1 --start-node A +python -m tools.decisive.collect --config usersettings.yaml --output ../decisive-samples/run-01 --rounds 3 --start-stage 1 --start-node A ``` `--start-node A` 表示调用者已确认当前点位,采集器不会把 native 预测冒充标签。 @@ -34,18 +35,15 @@ python -m tools.decisive.collect --config D:/Games/autowsgr/user_settings.yaml - 舰队、旗舰、维修设置全部沿用原配置。异常、船坞满、撤退请求或停止时保存现场并退出, 不计作完成节点,也不通过自动重试清空采集进度。 -恢复、购买或技能尝试后的库存由生产完整扫描核实;单屏不滚动,溢出列表按完整重叠行 -遍历,含在队舰船的六槽快照只在验证返回地图后发布。扫描失败或停止保留旧数据并退出, -不能带着部分库存继续编队、维修或开战。新旧决战换船共用该列表遍历器,逐次重新定位。 -候选列表为空时仍须确认未筛选、完整端点和稳定空背景;它只表示没有备用舰船, -在队舰船仍计入完整库存。进入已占用槽时的系统离队卡不计作舰船。 +恢复进度、购舰或使用副官技能后,采集器沿用决战的编队检查。程序在准备页逐一核对在队舰船的舰名和伤情, +再查看选船列表第一页的候补舰。返回地图后才更新编队和已获得的舰船名单。即使第一页没有候补舰,在队舰船也计入名单。 输出包含 `manifest.json`(PID、提交、native 版本、停止入口)、`effective_config.json`、 `effective_log_config.json`、`observations.jsonl`、`progress.json`、`summary.json` 和 `images/`。 输出目录必须为空;已有内容时在连接游戏前停止,防止重新编号覆盖旧图片或混合两次档案。 在输出目录创建空文件 `STOP` 即请求停止;采集器在控制器循环、战斗识别和点击前检查。 -PNG 保留索敌匹配帧、战果、地图字母裁剪与通关页面;JSONL 保留原始六槽、中文结果、 -阵型 OCR、帧序号、单调采集时间、遭遇 ID 及 native/OCR 耗时。 +PNG 保留索敌匹配帧、战果、地图字母裁剪与通关页面。JSONL 按敌方编队顺序列出各位置的原始舰种代码和中文舰种, +另记录阵型 OCR、帧序号、单调采集时间、遭遇 ID 及 native/OCR 耗时。 native 结果直接供本次战斗决策和融合会话使用,不为记录重复识别。采集模式每个遭遇 停采时仍为每个遭遇保留一次稳定地图字母观测,启采时跟随生产读取后续新稳定帧, 同帧不会重复调用 native。定位和裁剪使用同一帧;`used_for_tracking` @@ -64,8 +62,8 @@ native 结果直接供本次战斗决策和融合会话使用,不为记录重 的成功战斗推进及真实通关/重置。模型改写预测节点不会改写标签,重复战果不重复计步。 新档案的 `encounter_complete.observation` 直接归档生产会话已提交的完成事件,保留真实时间和 遭遇标识;随后停止或等待地图超时不会撤销已经发生的完成事件。 -确认 A 才使用确定 A 初始化;未知进度保留全节点候选。索敌未发生记为缺失, -不写入伪造六槽。通关预测仅用于开始检查真实确认控件;控件缺失立即保存现场停止, +确认 A 才使用确定 A 初始化;未知进度保留全节点候选。没有出现索敌画面时,记录为未取得敌方编队信息。 +通关预测仅用于开始检查真实确认控件;控件缺失立即保存现场停止, 完成操作后还必须看到决战入口,才能记录小关完成。采集原始页用于后续构建更具体的 通关页面识别。采集运行内开启 v4 融合回放,文件位于输出目录的 `node-fusion/`,原用户 配置文件保持不变。采集 JSONL 的 `fusion_log`、`encounter_id`、`fusion_event_id` 可以关联 @@ -76,13 +74,13 @@ native 结果直接供本次战斗决策和融合会话使用,不为记录重 旧采集版本只有原始 JSONL 时,可以转换为每轮、每小关独立的 v4 回放: ```powershell -python -m tools.decisive.replay_collection D:/Games/autowsgr/decisive-fusion-validation/collection-02/observations.jsonl --output D:/Games/autowsgr/decisive-fusion-validation/replay-02 +python -m tools.decisive.replay_collection ../decisive-samples/run-01/observations.jsonl --output ../decisive-samples/replay-01 ``` 转换器一次读取完整换行行的固定快照,正在写入的末尾行留到下次;每次运行新建 `snapshot-*` 目录,不覆盖采集或旧报告。初始化只接受首次观测前的明确标签来源, 后续 `label_node` 和 `predicted_node` 不作为节点证据。native 字母仅来自 `map.raw_node`, -敌情直接复用六槽原始码、中文结果和 OCR,不重新识别图片。新采集记录中的 +敌情直接使用归档中敌方各位置的原始舰种代码、中文舰种和阵型 OCR 结果。新采集记录中的 `used_for_tracking=false` 会保留,旧版本没有此字段时按实际存在的字母观测重放。 新档案优先重放生产会话的显式 `encounter_complete`,不从页面日志再次推测完成。