feat(timing): 边界周期修正 + 负费检测 + 录制回放回归框架

边界周期修正 (time_source.py):
- 开局 315 逻辑帧识别边界周期(左闭右闭)，该周期多 1 帧(30→31)
- 满条端点检测：pixel_map 不含满条宽度，边界/后周期手动覆盖
- 边界后 hidden 帧跳过：校准检测到的隐藏辉光帧在左开右闭不存在
- per_cycle 帧偏移对齐 rust 重写版

负费检测(tick.py + time_source.py):
- detect_negative_cost(): COST_SIGN_ROI 内最长纯白横条 ≥12px 判定减号
- time_source 负费相位重投射(周期 ×2)，不叠加边界修正

录制回放回归:
- tools/screencap.py: Win32 无间隔轮询, BMP 存盘 → 批量转 PNG
- tests/replay/: 帧序列 → TimeSource → 比对 expected.json(frames + per_cycle)
- calibration.from_dict() 支持自包含加载
- 边界周期用例: 367 帧(覆盖满条→边界后hidden skip)

Author: Windsland52

aao/app.py

@@ -304,7 +304,9 @@ def _reconnect(self, skip_overlay: bool = False) -> bool:
                 self.overlay = OverlayWindow()
                 self.overlay.show()
             self.worker = MeasurementWorker(
-                controller, self._calibration_data, profile_name=self._profile_name
+                controller,
+                self._calibration_data,
+                profile_name=self._profile_name,
             )
             self.worker_thread = QThread()
             self.worker.moveToThread(self.worker_thread)

aao/config.py

@@ -41,6 +41,12 @@
 GRAY_TOLERANCE = 20
 PIXEL_TOLERANCE = 5  # frame-map nearest-match tolerance
 
+# --- Negative-cost (可露希尔) minus-sign detection ---
+# maafw 截图统一缩放到 1280x720，故减号 ROI 用固定坐标（无需按分辨率换算）。
+# 减号是费用数字前的一段集中横向纯白 run；正数字笔画不会在这条窄横条内产生长 run。
+COST_SIGN_ROI = (1214, 531, 27, 9)  # (x, y, w, h) @ 1280x720
+COST_SIGN_MIN_RUN = 12  # 触发判定的最小连续纯白像素数（实测减号 ≈19px）
+
 # --- Timing (frames / ms) ---
 FRAMES_PER_SECOND = 30
 TICK_MAX_DEFAULT = 30  # 1s = 30 ticks

aao/core/timing/calibration.py

@@ -15,6 +15,7 @@
 from dataclasses import asdict, dataclass
 from pathlib import Path
 from statistics import median
+from typing import Any
 
 import numpy as np
 
@@ -240,9 +241,8 @@ def save(data: FullCalibrationData, basename: str) -> str:
     return filename
 
 
-def load(filename: str) -> FullCalibrationData:
-    path = calibration_dir() / filename
-    raw = json.loads(path.read_text(encoding="utf-8"))
+def from_dict(raw: dict[str, Any]) -> FullCalibrationData:
+    """从已解析的校准 dict 构造 FullCalibrationData（供 replay 等自包含场景使用）。"""
     profiles = [
         CalibrationProfile(total_frames=p["total_frames"], pixel_map=p["pixel_map"])
         for p in raw["profiles"]
@@ -256,6 +256,11 @@ def load(filename: str) -> FullCalibrationData:
     )
 
 
+def load(filename: str) -> FullCalibrationData:
+    path = calibration_dir() / filename
+    return from_dict(json.loads(path.read_text(encoding="utf-8")))
+
+
 def list_files() -> list[str]:
     return sorted(p.name for p in calibration_dir().glob("*.json"))
 

aao/core/timing/tick.py

@@ -149,6 +149,43 @@ def get_logical_frame(frame: np.ndarray, roi: Roi, pixel_map: dict[str, int]) ->
     return best_frame if best_diff <= config.PIXEL_TOLERANCE else None
 
 
+def detect_negative_cost(frame: np.ndarray) -> bool:
+    """检测费用是否为负（可露希尔负费）。
+
+    减号是费用数字前的一段集中横向纯白 run（实测 ≈19px）；正数字笔画不会在
+    这条窄横条 ROI 内产生同等长度的连续纯白 run。在 ``COST_SIGN_ROI`` 内逐行扫描，
+    任一行的最长连续纯白 run ≥ ``COST_SIGN_MIN_RUN`` 即判定为负费。
+
+    maafw 截图统一缩放到 1280x720，故 ROI 用固定坐标。
+
+    Args:
+        frame: BGR ndarray (H, W, 3) uint8。
+
+    Returns:
+        True 表示检测到减号（负费）。
+    """
+    x, y, w, h = config.COST_SIGN_ROI
+    fh, fw = frame.shape[:2]
+    if x < 0 or y < 0 or x + w > fw or y + h > fh:
+        return False
+
+    region = frame[y : y + h, x : x + w].astype(np.int16)  # (h, w, 3) BGR
+    white = (region > config.WHITE_THRESHOLD).all(axis=2)  # (h, w) bool
+
+    # 逐行求最长连续纯白 run：对每行做行内累计，遇非白清零，取全局最大。
+    for row in white:  # pyright: ignore[reportGeneralTypeIssues]
+        if not row.any():
+            continue
+        # 累计连续 True 长度：cumsum 在非白处“断点”归零的经典向量化写法。
+        idx = np.arange(len(row))
+        # 每个位置减去“上一个非白位置”，得到当前连续白的长度。
+        last_false = np.where(row, 0, idx)
+        max_run = int((idx - np.maximum.accumulate(last_false)).max())
+        if max_run >= config.COST_SIGN_MIN_RUN:
+            return True
+    return False
+
+
 def detect(frame: np.ndarray, pixel_map: dict[str, int] | None = None) -> tuple[Roi, int | None]:
     """便捷：算 ROI + 取填充宽（+ 可选逻辑帧）。
 

aao/core/timing/time_source.py

@@ -24,6 +24,7 @@
 
 RESET_TIMEOUT_S = 1.5
 _WRAP_MARGIN = 3  # 帧下降超过此值 → 判定周期 wrap（过滤抖动）
+_BOUNDARY_SWITCH_FRAME = 315  # 开局第 315 逻辑帧所在周期为边界周期
 
 
 def format_timer(total_frames: int, fps: int = config.FRAMES_PER_SECOND) -> str:
@@ -37,6 +38,26 @@ def format_timer(total_frames: int, fps: int = config.FRAMES_PER_SECOND) -> str:
     return f"{minutes:02d}:{seconds:02d}:{frames:02d}"
 
 
+def _compute_boundary_cycle(
+    calibration: FullCalibrationData,
+    switch_frame: int = _BOUNDARY_SWITCH_FRAME,
+) -> int:
+    """计算 boundary_switch_frame 落在哪个周期（0-indexed）。
+
+    从 cycle 0 起累加各 profile 的 total_frames，目标帧落入的 cycle 即为边界周期。
+    """
+    elapsed = 0
+    num = len(calibration.profiles)
+    if num == 0:
+        return 0
+    for i in range(100):  # 安全上限
+        total = calibration.profiles[i % num].total_frames
+        if switch_frame < elapsed + total:
+            return i
+        elapsed += total
+    return 0
+
+
 class TimeSource:
     """费用条时间状态机 + PLL 外推。喂帧驱动，产出周期帧 / 全局计时器。"""
 
@@ -52,6 +73,18 @@ def __init__(self, calibration: FullCalibrationData, reset_timeout: float = RESE
         self.last_detect_time = 0.0
         self._total_frames = 0
 
+        # 负费（可露希尔）状态
+        self._cost_is_negative = False
+
+        # 边界周期：开局第 315 逻辑帧所在的周期（0-indexed），
+        # 该周期多 1 帧（左闭右闭 vs 左闭右开）。
+        # 负费时不叠加边界修正（回费速率不同，边界位置尚未验证）。
+        self._boundary_cycle_index = _compute_boundary_cycle(calibration)
+
+        # 每档 profile 在边界前校准时检测到的隐藏帧数。
+        # 边界后（左开右闭）这些隐藏帧不存在，需从显示中跳过。
+        self._num_hidden = [p.total_frames - len(p.pixel_map) for p in calibration.profiles]
+
         # PLL 外推状态
         self._prev_measured = -1  # 上次测量帧（用于 wrap 检测）
         self._stuck_lf: int | None = None  # 卡住时的测量帧
@@ -71,9 +104,50 @@ def update(self, frame: np.ndarray) -> int | None:
         """喂一帧，更新状态。返回当前周期内逻辑帧（含 PLL 外推，None = 未检出）。"""
         roi = tick.find_cost_bar_roi(frame.shape[1], frame.shape[0])
         profile = self.active_profile
+        total_this = profile.total_frames
+
+        # 负费（可露希尔）检测：每帧判定，适应技能开关。
+        self._cost_is_negative = tick.detect_negative_cost(frame)
+        effective_total = total_this * 2 if self._cost_is_negative else total_this
+
         lf_measured = tick.get_logical_frame(frame, roi, profile.pixel_map)
         now = time.time()
 
+        # 负费相位重投射：pixel_map 按正常速率校准（30f/费），负费时回费减半（60f/费），
+        # 需把校准帧当相位重投射到翻倍周期。
+        if lf_measured is not None and self._cost_is_negative and total_this > 0:
+            phase = lf_measured / total_this
+            lf_measured = round(phase * (effective_total - 1))
+
+        # 边界后周期去掉 hidden 帧：校准在慢速下检测到的隐藏辉光帧（如 frame 1
+        # 无独立宽度）在边界后左开右闭周期里不存在，需从帧序列中跳过。
+        # frame 0（0% 起点）不动，避免超时清空。
+        # 必须在满条修正之前执行，否则 endpoint 值会被误减。
+        if (
+            lf_measured is not None
+            and lf_measured > 0
+            and not self._cost_is_negative
+            and self.cycle_counter > self._boundary_cycle_index
+        ):
+            nh = profile.total_frames - len(profile.pixel_map)
+            if nh > 0:
+                if lf_measured <= nh:
+                    lf_measured = None  # hidden 帧，跳过
+                else:
+                    lf_measured -= nh  # 可见帧，回正到无 hidden 的序号
+
+        # 满条修正：pixel_map 按左闭右开校准，不含满条宽度。满条像素宽可能
+        # 被 nearest-match 误判为 frame 29（容差 5 内），需在端点周期里覆盖。
+        # 需在 None 检查之前执行，否则永远不触发。
+        if not self._cost_is_negative:
+            pw = tick.get_filled_pixel_width(frame, roi)
+            bar_w = roi[1] - roi[0]
+            if pw is not None and pw >= bar_w:
+                if self.cycle_counter == self._boundary_cycle_index:
+                    lf_measured = total_this  # 边界周期：满条 → frame 30
+                elif self.cycle_counter > self._boundary_cycle_index:
+                    lf_measured = total_this - 1  # 之后周期：满条 → frame 29
+
         if lf_measured is None:
             self.previous_frame = -1
             # 不重置 _prev_measured：保留上次有效值，以便 wrap 瞬间的短暂 None 后仍能检测周期
@@ -84,8 +158,6 @@ def update(self, frame: np.ndarray) -> int | None:
                     self._reset_state()
             return None
 
-        total_this = profile.total_frames
-
         # --- wrap 检测（基于测量帧）---
         wrapped = False
         if self._prev_measured >= 0 and lf_measured < self._prev_measured - _WRAP_MARGIN:
@@ -97,7 +169,10 @@ def update(self, frame: np.ndarray) -> int | None:
                 else:
                     self._cycle_period = period
             self._last_wrap_time = now
-            self.cycle_base_frames += total_this
+            inc = effective_total
+            if not self._cost_is_negative and self.cycle_counter == self._boundary_cycle_index:
+                inc += 1  # 边界周期（左闭右闭），多 1 帧
+            self.cycle_base_frames += inc
             self.cycle_counter += 1
             wrapped = True
             self._stuck_lf = None
@@ -150,6 +225,7 @@ def _reset_state(self) -> None:
         self._stuck_since = 0.0
         self._last_wrap_time = 0.0
         self._cycle_period = 0.0
+        self._cost_is_negative = False
 
     # --- 查询 ---
 
@@ -167,14 +243,19 @@ def is_running(self) -> bool:
 
     @property
     def total_frames_in_cycle(self) -> int:
-        return self.active_profile.total_frames
+        base = self.active_profile.total_frames
+        if self._cost_is_negative:
+            return base * 2
+        if self.cycle_counter == self._boundary_cycle_index:
+            return base + 1
+        return base
 
     @property
     def timer_str(self) -> str:
         return format_timer(self._total_frames)
 
     def display(self, mode: str = "0_to_n-1") -> tuple[str, str]:
-        total = self.active_profile.total_frames
+        total = self.total_frames_in_cycle
         dt = total - 1 if mode == "0_to_n-1" else total
         lf = self.previous_frame
         if lf < 0:

tests/minus.png

@@ -0,0 +1,48 @@
+# 回放用例素材
+
+每个子目录是一个回放用例，结构：
+
+```plaintext
+<case_name>/
+  frames/           逐帧 PNG，命名 000001.png、000002.png …（字典序 = 时间序）
+  calibration.json  对应校准 profile（直接复制 config/calibration/ 下的文件）
+  expected.json     {"frames": [全局帧, ...]}  每帧预期 total_elapsed_frames
+```
+
+## 录制素材
+
+1. 游戏内录一段视频（含费用条可见、正常 1x 回费）。
+2. 用系统 ffmpeg 抽帧为 PNG（60fps 示例）：
+
+    ```powershell
+    ffmpeg -i input.mp4 -vf fps=60 frames/%06d.png
+    ```
+
+    抽帧 fps 要与测量 worker 的 `interval_s`（默认 1/60）一致，否则帧序号对不上。
+
+3. 把对应关卡的校准文件复制为 `calibration.json`。
+
+## 生成 expected.json
+
+先跑一次回放，把实际读数作为初稿：
+
+```python
+from pathlib import Path
+from replay import load_case, run_replay
+import json
+
+frames, calib, _ = load_case(Path("cases/边界周期"))
+actual = run_replay(frames, calib)
+Path("cases/边界周期/expected.json").write_text(
+    json.dumps({"frames": actual}), encoding="utf-8"
+)
+```
+
+然后**人工核对关键帧**（边界周期第 11 周期、负费切换点），确认无误后再固化。
+expected 必须是「正确答案」，不是「当前实现输出」——否则回归无意义。
+
+## 推荐用例
+
+- `边界周期`：战斗 > 315 帧，验证第 11 周期多 1 帧、边界后周期不偏移。
+- `负费`：可露希尔关卡，验证负费期间周期帧数 ×2、相位重投射。
+- `正常回费`：基线，验证未引入回归。

tests/plus.png

@@ -0,0 +1,42 @@
+{
+    "detection_mode": "single",
+    "profiles": [
+        {
+            "total_frames": 30,
+            "pixel_map": {
+                "0": 0,
+                "3": 2,
+                "7": 3,
+                "11": 4,
+                "14": 5,
+                "18": 6,
+                "22": 7,
+                "26": 8,
+                "29": 9,
+                "33": 10,
+                "37": 11,
+                "41": 12,
+                "44": 13,
+                "48": 14,
+                "52": 15,
+                "56": 16,
+                "59": 17,
+                "63": 18,
+                "67": 19,
+                "71": 20,
+                "74": 21,
+                "78": 22,
+                "82": 23,
+                "86": 24,
+                "89": 25,
+                "93": 26,
+                "97": 27,
+                "101": 28,
+                "104": 29
+            }
+        }
+    ],
+    "screen_width": 1280,
+    "screen_height": 720,
+    "calibration_time": 1781787159.352668
+}