fix: continue hidden sweep battles safely in Web 2.0.12

This commit is contained in:
AttilaNet
2026-11-14 12:41:11 +08:00
parent 7ca2ee13e3
commit 69b59e18dd
21 changed files with 1691 additions and 102 deletions
+209 -2
View File
@@ -1,9 +1,13 @@
"""The built-in three-difficulty-cleared sweep path from StageStartPanel."""
from dataclasses import dataclass, field
from contextlib import nullcontext
from datetime import datetime
from types import SimpleNamespace
import json
import math
from pathlib import Path
import sqlite3
import time
import uuid
from .daily import day
@@ -17,6 +21,34 @@ def settled_reward_event(response):
return event_reward(response) is not None
def successful_response(response):
if not isinstance(response, dict):
return False
if "resCode" not in response:
# Existing in-process adapters may already have checked resCode.
return (type(response.get("triggerEvent")) is bool
or type(response.get("triggerEvent")) is int and response["triggerEvent"] in (0, 1)
or isinstance(response.get("reward"), dict))
return (type(response["resCode"]) is int and response["resCode"] == 0
or type(response["resCode"]) is str and response["resCode"] == "0")
def hidden_stage_id(response):
"""Return the original hidden ID only for an explicit hidden event."""
if not isinstance(response, dict):
return None
flag = response.get("triggerEvent")
event = response.get("stageEvent")
if not (flag is True or type(flag) is int and flag == 1) or not isinstance(event, dict):
return None
identifier = event.get("hideStageId")
if isinstance(identifier, str) and identifier.strip():
return identifier
if type(identifier) is int and identifier > 0:
return str(identifier)
return None
@dataclass
class SweepPolicy:
enabled: bool = False
@@ -133,6 +165,140 @@ class SweepRunner:
return True
return False
def recover_hidden_start(self, snapshot, trace_path, *, events=None):
"""Recover entry evidence only; never replay entry or infer settlement.
Old journals lack entry snapshots. Trace proof deliberately does not
manufacture runtime inputs from the current, post-entry snapshot.
"""
from .battles import gameplay_response
pending = self.state.get("pending")
old_phases = {"遭遇隐藏关卡,请在游戏内手动战斗", "遇到事件或响应缺少事件状态,请在游戏内处理"}
if not isinstance(pending, dict) or not trace_path:
return False
if (pending.get("phase") not in old_phases
and not (pending.get("phase") == "开始请求待确认" and "start_response" not in pending)):
return False
owner = snapshot.raw.get("master", {}).get("id")
if owner is None or (pending.get("role_id") is not None and str(pending["role_id"]) != str(owner)):
return False
owner = str(owner)
parent, level = pending.get("stage"), pending.get("level")
if parent is None or level is None:
return False
reservation = pending.get("counts_key")
if pending.get("role_id") is None:
# Multiple dates or roles cannot identify which entry this block owns.
reservations = [(key, count) for key, count in self.state.get("counts", {}).items()
if isinstance(key, str) and len(key.split(":")) == 4
and key.split(":")[2:] == [str(parent), str(level)] and count != 0]
if (len(reservations) != 1 or reservations[0][0].split(":")[0] != owner
or type(reservations[0][1]) is not int or reservations[0][1] <= 0):
return False
reservation = reservations[0][0]
if reservation is not None:
parts = reservation.split(":") if isinstance(reservation, str) else []
if len(parts) != 4 or parts[0] != owner or parts[2:] != [str(parent), str(level)]:
return False
try:
datetime.strptime(parts[1], "%Y-%m-%d")
except ValueError:
return False
role, latest, candidate = None, None, None
requests, responses = {}, set()
# Everything outside these explicit reads is an uncertain write.
reads = {"读取角色", "masterService/masterQueryDetail"}
def unambiguous_object(pairs):
result = {}
for key, value in pairs:
if key in result:
raise ValueError("Duplicate trace field")
result[key] = value
return result
path = Path(trace_path)
try:
for file in ((None,) if events is not None else (path.with_name("network_debug.previous.jsonl"), path)):
if file is not None and not file.exists():
continue
with (nullcontext(events) if file is None else file.open(encoding="utf-8")) as stream:
for line in stream:
if isinstance(line, str) and not line.strip():
continue
event = line if isinstance(line, dict) else json.loads(line, object_pairs_hook=unambiguous_object)
if not isinstance(event, dict):
return False
operation, kind = event.get("operation"), event.get("kind")
body, identifier = event.get("body"), event.get("request_id")
if not isinstance(operation, str) or kind not in ("request", "response", "error"):
return False
if operation in reads:
if kind == "response":
master = body.get("master") if isinstance(body, dict) else None
observed = master.get("id") if isinstance(master, dict) else None
if (type(observed) not in (int, str) or not str(observed).strip()
or event.get("http_status", 200) != 200
or "resCode" in body and not successful_response(body)):
observed = None
observed = str(observed) if observed is not None else None
if role != observed:
latest, candidate = None, None
role = observed
elif kind == "error":
role, latest, candidate = None, None, None
continue
if not isinstance(identifier, str) or not identifier or not isinstance(body, dict):
return False
if kind == "request":
if identifier in requests:
return False
requests[identifier] = (operation, role)
if role is None or role == owner:
latest, candidate = None, None
if (role == owner and operation == "stageService/stageStart"
and str(body.get("stageTypeId")) == str(parent)
and str(body.get("stageLevel")) == str(level)):
latest = identifier
elif kind == "response":
if identifier in responses:
return False
responses.add(identifier)
if (identifier == latest and requests.get(identifier) == (operation, owner)
and role == owner and operation == "stageService/stageStart"
and event.get("http_status") == 200 and body.get("resCode") in (0, "0") and successful_response(body)
and hidden_stage_id(body) is not None and not settled_reward_event(body)):
candidate = event
elif role is None or role == owner:
latest, candidate = None, None
elif role is None or role == owner:
latest, candidate = None, None
except (OSError, ValueError, TypeError, AttributeError):
return False
if candidate is None or role != owner:
return False
confirmed_at = None
try:
stamp = candidate.get("time")
parsed = datetime.fromisoformat(stamp) if isinstance(stamp, str) else None
if parsed is not None and parsed.tzinfo is not None:
confirmed_at = parsed.timestamp()
if confirmed_at is not None and (not math.isfinite(confirmed_at) or confirmed_at <= 0):
confirmed_at = None
except (ValueError, OverflowError, OSError):
pass
update = {"role_id": owner, "phase": "hidden_started", "start_path": "stageService/stageStart",
"start_dispatched": True, "start_confirmed": True,
"start_response": gameplay_response(candidate["body"]),
"hidden_stage_id": hidden_stage_id(candidate["body"]),
"start_request_id": candidate["request_id"], "evidence_status": "trace_confirmed_hidden_start"}
if reservation is not None:
update["counts_key"] = reservation
if confirmed_at is not None:
update["start_confirmed_at"] = confirmed_at
pending.update(update)
self.save()
return True
def save(self):
if self.path:
self.path.parent.mkdir(parents=True, exist_ok=True)
@@ -202,7 +368,9 @@ class SweepRunner:
return stage
return None
def run(self, client, snapshot, stage, policy):
def run(self, client, snapshot, stage, policy, *, cancel=None, origin=None):
from .battles import CancelledBeforeDispatch, gameplay_response, public_data
self.last_outcome = ""
self.last_reward = None
rule = policy.rules.get(stage.stage_id) or {}
@@ -212,10 +380,42 @@ class SweepRunner:
if reason:
raise ValueError(reason)
key = self.key(snapshot, stage)
previous_count = self.state["counts"].get(key)
self.state["counts"][key] = self.used(snapshot, stage) + 1
self.state["pending"] = {"stage": stage.stage_id, "level": stage.level, "phase": "开始请求待确认", "sampleId": uuid.uuid4().hex}
self.state["pending"] = {"stage": stage.stage_id, "level": stage.level,
"phase": "开始请求待确认", "sampleId": uuid.uuid4().hex,
"role_id": str(snapshot.raw["master"]["id"]), "team": policy.team, "counts_key": key,
"entry_snapshot": public_data(snapshot.raw), "entry_snapshot_now": snapshot.now,
"origin": public_data(origin) if isinstance(origin, dict) else {},
"start_path": "stageService/stageStart", "start_dispatched": False, "start_confirmed": False,
"settlement_dispatched": False, "record_dispatched": False}
self.save() # Reserve before the first non-retryable write, including timeouts.
self.state["pending"]["start_dispatched"] = True
self.save()
if cancel is not None and cancel.is_set():
if previous_count is None:
self.state["counts"].pop(key, None)
else:
self.state["counts"][key] = previous_count
self.state["pending"] = None
self.save()
raise CancelledBeforeDispatch()
started = client.call("stageService/stageStart", {"stageTypeId": stage.stage_id, "stageLevel": stage.level})
if not successful_response(started):
raise ValueError("扫荡开始未返回可信的成功响应,禁止自动重试")
self.state["pending"].update(start_response=gameplay_response(started),
start_confirmed=True, start_confirmed_at=time.time())
self.save()
hidden = hidden_stage_id(started)
if hidden is not None and not settled_reward_event(started):
self.state["pending"].update(phase="hidden_started", hidden_stage_id=hidden)
self.save()
self.last_outcome = "hidden"
if origin is None:
# Callers without the orchestrator handoff must retain the
# historical stop signal, while preserving the new evidence.
raise ValueError("隐藏关卡已入场,等待战斗接续")
return started
if settled_reward_event(started):
# StageCenter.startStageHandler applies stageEvent.result directly;
# StageStartPanel shows it and returns, without battleEnd.
@@ -239,8 +439,15 @@ class SweepRunner:
"win": True, "cheatNum": 0, "cheatRecords": "", "killMonster": {}, "battleMonIds": self.team_ids(snapshot, policy),
**{name: 0 for name in ("leftTime", "killNum", "totalDamage", "bossDamage", "deadNum", "aliveNum", "apLeft")}}
self.state["pending"]["phase"] = "扫荡结算待确认"
self.state["pending"].update(settlement_dispatched=True, sweep_battle_data=battle)
self.save()
if cancel is not None and cancel.is_set():
self.state["pending"].update(phase="cancelled_before_sweep_settlement", settlement_dispatched=False)
self.save()
raise CancelledBeforeDispatch()
result = client.call("battleService/battleEnd", {"battleData": battle})
if not successful_response(result):
raise ValueError("扫荡结算未返回可信的成功响应,禁止自动重试")
self.remember_reward(client, snapshot, stage, "sweep", result.get("reward"), result)
self.state["pending"] = None
self.save()