"""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 from .maps import stages from .resource_stages import resource_entry_reason from .drop_statistics import SweepStatistics, event_reward, normalize_reward from .team_availability import team_availability_reason 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 rules: dict = field(default_factory=dict) keep_stamina: int = 0 team: str = "teamA" allow_challenge: bool = True allow_special: bool = False keep_tickets: int = 0 def __post_init__(self): if type(self.allow_special) is not bool: raise ValueError("资源关卡开关必须为布尔值") if type(self.keep_tickets) is not int or self.keep_tickets < 0: raise ValueError("保留工具数量必须为非负整数") class SweepRunner: def __init__(self, catalog, path=None): self.catalog = catalog self.path = Path(path) if path else None self.state = json.loads(self.path.read_text(encoding="utf-8")) if self.path and self.path.exists() else {"counts": {}, "pending": None} self.last_outcome = "" self.recovery_checked = False self.recovered_event = False self.statistics = SweepStatistics(catalog, self.path.with_name("sweep_rewards.sqlite3") if self.path else None) self.last_reward = None self.statistics_error = "" def remember_reward(self, client, snapshot, stage, kind, reward, response): self.last_outcome = kind self.last_reward = None self.statistics_error = "" try: self.last_reward = normalize_reward(self.catalog, reward) source = "run:" + self.state["pending"]["sampleId"] operation = "stageService/stageStart" if kind == "event" else "battleService/battleEnd" for event in reversed(getattr(getattr(client, "trace", None), "events", [])): if event.get("operation") == operation and event.get("kind") == "response" and event.get("request_id"): source = "request:" + event["request_id"] break cost = (response.get("stageEvent") or {}).get("costTi") if kind == "event" else response.get("costTi") self.statistics.record(snapshot.raw["master"]["id"], stage.stage_id, stage.level, kind, source, snapshot.now, reward, cost) except (OSError, sqlite3.Error, ValueError, TypeError, KeyError) as error: # A local statistics failure must never repeat an awarded request. self.statistics_error = "奖励统计未写入:" + str(error) def remember_map_reward(self, snapshot, record, response, *, event=False): """Attach an already journaled resource result to existing drop statistics.""" self.last_outcome = "resource_event" if event else "resource" reward = record.get("reward") if reward is None: self.statistics_error = "资源关卡结算缺少奖励,未写入掉落统计" return self.statistics_error = "" try: self.last_reward = normalize_reward(self.catalog, reward) source_response = record.get("response") or record.get("start_response") or response or {} self.statistics.record(snapshot.raw["master"]["id"], record["stage_id"], str(record["difficulty"]), "event" if event else "sweep", "battle:" + record["attempt_id"], snapshot.now, reward, (source_response.get("stageEvent") or {}).get("costTi") if event else source_response.get("costTi")) except (OSError, sqlite3.Error, ValueError, TypeError, KeyError) as error: self.statistics_error = "奖励统计未写入:" + str(error) def recover_reward_event(self, snapshot, trace_path): """Repair only old reward-event blocks with a role-matched log reply. This never replays a start or settlement request. Missing/ambiguous evidence leaves the pending record intact. """ pending = self.state.get("pending") if (self.recovery_checked or not trace_path or not pending or pending.get("phase") != "遇到事件或响应缺少事件状态,请在游戏内处理"): return False self.recovery_checked = True role, requests, last_reply = None, {}, None owner = snapshot.raw["master"]["id"] path = Path(trace_path) try: for file in (path.with_name("network_debug.previous.jsonl"), path): if not file.exists(): continue with file.open(encoding="utf-8") as stream: for line in stream: try: event = json.loads(line) except ValueError: continue body = event.get("body") if not isinstance(body, dict): continue if event.get("operation") == "读取角色" and event.get("kind") == "response": role = (body.get("master") or {}).get("id") if event.get("operation") != "stageService/stageStart": continue identifier = event.get("request_id") if not isinstance(identifier, str) or not identifier: continue if event.get("kind") == "request": matched = (str(role) == str(owner) and str(body.get("stageTypeId")) == pending["stage"] and str(body.get("stageLevel")) == str(pending["level"])) requests[identifier] = matched if matched: last_reply = None elif event.get("kind") == "response" and requests.get(identifier): last_reply = body if event.get("http_status") == 200 and body.get("resCode") in (0, "0") else None except (OSError, ValueError, TypeError, AttributeError): return False if last_reply and settled_reward_event(last_reply): self.state["pending"] = None self.save() self.recovered_event = True 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) temp = self.path.with_suffix(".tmp") temp.write_text(json.dumps(self.state, ensure_ascii=False), encoding="utf-8") temp.replace(self.path) def key(self, snapshot, stage): return f"{snapshot.raw['master']['id']}:{day(snapshot.now)}:{stage.stage_id}:{stage.level}" def used(self, snapshot, stage): return int(self.state["counts"].get(self.key(snapshot, stage), 0)) def team_ids(self, snapshot, policy): team = next((t for t in snapshot.raw.get("teams", []) if t.get("teamName") == policy.team and t.get("teamType") == "battleTeam"), {}) ids = [int(mid) for mid in team.get("monsters", []) if mid and int(mid) > 0] monsters = snapshot.monsters return [mid for mid in ids if mid in monsters] def reason(self, snapshot, stage, policy, *, team_ids=None, challenge=False): if not policy.enabled: return "扫荡 / 自动挑战已关闭,禁止新的入场" if self.state.get("pending"): return "有未完成的扫荡,请先在游戏内检查" if stage.category in ("mine", "ticket"): return resource_entry_reason(self.catalog, snapshot, stage, policy) or team_availability_reason(snapshot, policy.team) if challenge: config = self.catalog.data.get("stage_info", {}).get(stage.stage_id, {}) if not stage.unlocked or not stage.open: return "关卡尚未解锁或当前未开放" if config.get("special") or config.get("posmode"): return "特殊关卡当前不支持自动挑战" elif not stage.sweep: return stage.reason reason = team_availability_reason(snapshot, policy.team) if reason: return reason positions = self.catalog.data.get("stage_task_positions", {}) for task in snapshot.raw.get("currentTasks", []): steps = positions.get(str(task.get("typeId")), []) index = int(task.get("curStep") or 1) - 1 position = steps[index] if 0 <= index < len(steps) else "" if position == f"city{stage.city}_wild_stage{stage.stage_id}_level{stage.level}": return "该难度有当前剧情任务,请先在游戏内完成" base = self.catalog.data["stage_info"][stage.stage_id].get("cost") or {} master = snapshot.raw["master"] if float(master.get("ti") or 0) < stage.stamina + policy.keep_stamina: return "体力不足或已达保留体力" if base.get("ke"): return "需要氪金,未启用" if float(master.get("money") or 0) < float(base.get("money") or 0): return "金币不足" for item in base.get("items") or []: owned = sum(int(i.get("num") or 0) for i in snapshot.raw.get("items", []) if str(i.get("typeId")) == str(item["typeId"])) if owned < int(item["num"]): return "入场券不足" return "" def next(self, snapshot, policy): if not policy.enabled: return None for stage in sorted(stages(self.catalog, snapshot), key=lambda s: (s.city, s.number, s.stage_id, s.level)): rule = policy.rules.get(stage.stage_id) or {} if not rule.get("enabled") or str(rule.get("level", "3")) != stage.level: continue if self.used(snapshot, stage) < max(0, int(rule.get("limit") or 0)) and not self.reason(snapshot, stage, policy): return stage return None 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 {} if not rule.get("enabled") or str(rule.get("level")) != stage.level or self.used(snapshot, stage) >= int(rule.get("limit") or 0): raise ValueError("此关卡未勾选或已达本日次数上限") reason = self.reason(snapshot, stage, policy) 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, "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. self.remember_reward(client, snapshot, stage, "event", started["stageEvent"]["result"], started) self.state["pending"] = None self.save() self.last_outcome = "event" return started flag = started.get("triggerEvent") if flag is not False and not (type(flag) is int and flag == 0): event = started.get("stageEvent") if isinstance(event, dict) and event.get("hideStageId") is not None: phase = "遭遇隐藏关卡,请在游戏内手动战斗" else: phase = "事件结果或开始状态尚未确认,请在游戏内检查" self.state["pending"]["phase"] = phase self.save() raise ValueError(self.state["pending"]["phase"]) # Exactly the official doSaodangBattle data; only for its eligible stages. battle = {"battlePosition": {"battleType": "stage", "stageId": stage.stage_id, "stageLevel": stage.level, "taskTypeId": None, "taskStep": 0}, "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() client.call("battleService/recordBattleResult", {"stageId": stage.stage_id, "cityId": stage.stage_id[1:2], "result": 1}) self.last_outcome = "sweep" return result