"""Durable orchestration; combat statistics belong exclusively to the runtime. Partner contract: BattleOrchestrator accepts ProgressionIntent objects (or dicts). The runtime adapter implements inspect(request) and run(request, cancel_event=Event). Inspection must explicitly report supported=True. Original settlement requires settlement_eligible=True; experimental execution requires its separate experimental_settlement_eligible=True after completed model execution. Original execution must be faithful; explicitly selected experimental execution must identify itself as approximate and retain its limitations and trace. Both supply unmodified, computed battle_data. The request contains snapshot, team, battle_position, stage_id, difficulty, task_type_id, step_number and battle_kind. Engine adapts the concrete runtime's input builder. No estimation module is imported here. SweepRunner is the sole sweep executor. """ from __future__ import annotations from copy import deepcopy from dataclasses import asdict, is_dataclass, replace import hashlib import json import math import os from pathlib import Path import threading import time import uuid from types import SimpleNamespace from .drop_statistics import event_reward from .maps import stages from .resource_stages import resource_entry_reason, item_requirements, available_item_count from .quests import indexed, stage_has_level from .sweeping import SweepPolicy, hidden_stage_id from .team_availability import team_availability_reason from .battle_retry import loss_retry_reason def value(obj, name, default=None): return obj.get(name, default) if isinstance(obj, dict) else getattr(obj, name, default) class CancelledBeforeDispatch(Exception): """Raised only before Client.call is invoked; the request was not sent.""" def role_id(snapshot): owner = snapshot.raw.get("master", {}).get("id") if owner is None: raise ValueError("角色身份缺失,不能推进任务") return str(owner) def digest(obj): return hashlib.sha256(json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(",", ":"), default=str).encode("utf-8")).hexdigest() def public_data(obj): """Never persist transport credentials, even in an unexpected response.""" if is_dataclass(obj): obj = asdict(obj) if isinstance(obj, dict): return {str(k): public_data(v) for k, v in obj.items() if str(k).lower().replace("_", "") not in ("key", "sessionkey", "session", "sessionid", "aeskey", "encryptionkey", "sdkkey", "appkey", "reqid", "reqsid", "uid", "sdkuid", "deviceid") and not any(secret in str(k).lower() for secret in ("token", "password", "secret", "authorization", "cookie"))} if isinstance(obj, (list, tuple)): return [public_data(v) for v in obj] if obj is None or isinstance(obj, (str, int, float, bool)): return obj return str(obj) def gameplay_response(response): result = {k: v for k, v in response.items() if k in ( "resCode", "triggerEvent", "stageEvent", "reward", "stageReward", "costTi", "unlockStage", "lockStage", "monsterExpInfos", "taskStepValue", "task", "nextTasks", "unlockTasks", "unlockStages", "receiveTasks", "loopTask", "loopTaskNum", "loopTaskTime")} def task_fields(task): return {key: task[key] for key in ("id", "typeId", "curStep", "stepValue") if key in task} if isinstance(result.get("task"), dict): result["task"] = task_fields(result["task"]) for field in ("nextTasks", "receiveTasks"): if isinstance(result.get(field), list): result[field] = [task_fields(task) for task in result[field] if isinstance(task, dict)] return public_data(result) _locks_guard = threading.Lock() _locks = {} SWEEP_KINDS = ("map_sweep", "sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep") COMBAT_KINDS = ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle") + SWEEP_KINDS def account_lock(path): if path is None: return threading.RLock() key = os.path.normcase(str(Path(path).resolve())) with _locks_guard: return _locks.setdefault(key, threading.RLock()) class BattleJournal: """Atomic per-role write-ahead records, including local story checkpoints.""" def __init__(self, path=None): self.path = Path(path) if path else None self.lock = account_lock(path) self.state = {"version": 1, "roles": {}} self.reload() def reload(self): if self.path and self.path.exists(): try: state = json.loads(self.path.read_text(encoding="utf-8")) if state.get("version") != 1 or not isinstance(state.get("roles"), dict): raise ValueError("unsupported journal") self.state = state except (OSError, ValueError, AttributeError) as error: raise ValueError("任务 / 战斗日志无法读取;请保留日志并核对,不能自动重试") from error def save(self): for state in self.state["roles"].values(): completed = [r for r in state["records"] if r["attempt_id"] != state["pending"]] keep = {r["attempt_id"] for r in completed[-500:]} state["records"] = [r for r in state["records"] if r["attempt_id"] == state["pending"] or r["attempt_id"] in keep] if self.path: self.path.parent.mkdir(parents=True, exist_ok=True) temporary = self.path.with_name(self.path.name + "." + uuid.uuid4().hex + ".tmp") try: with temporary.open("w", encoding="utf-8") as stream: json.dump(self.state, stream, ensure_ascii=False, allow_nan=False) stream.flush() os.fsync(stream.fileno()) for attempt in range(5): try: temporary.replace(self.path) break except PermissionError: if attempt == 4: raise # Windows indexers can briefly hold a just-closed file. # Only local atomic replacement is retried, never an API. time.sleep(0.01 * (attempt + 1)) finally: temporary.unlink(missing_ok=True) def role(self, snapshot): return self.state["roles"].setdefault(role_id(snapshot), {"pending": None, "records": [], "cursors": {}, "losses": 0}) def pending(self, snapshot): state = self.role(snapshot) return next((r for r in state["records"] if r["attempt_id"] == state["pending"]), None) def loss_reason(self, snapshot, policy): state = self.role(snapshot) before = (state.get("losses"), state.get("last_loss_at")) reason = loss_retry_reason(state, snapshot.now, policy) if before != (state.get("losses"), state.get("last_loss_at")): self.save() return reason def records(self, snapshot): with self.lock: self.reload() return deepcopy(list(reversed(self.role(snapshot)["records"]))) def begin(self, snapshot, intent, *, kind=None, sweep_entry=None, sweep_phase=None): if self.pending(snapshot): raise ValueError("有待核对的任务 / 战斗,禁止重复开始") record = {name: public_data(value(intent, name)) for name in ( "kind", "description", "path", "payload", "task_id", "task_type_id", "step_number", "position", "stage_id", "difficulty", "battle_kind", "stage_category", "source_task_id", "source_task_type_id", "source_step_number", "farming_target")} record.update(attempt_id=uuid.uuid4().hex, role_id=role_id(snapshot), phase="prepared", outcome="", timestamp=time.time(), started_at=time.time(), team=value(intent, "team", ""), message="", kind=kind or record["kind"], battle_mode=value(intent, "battle_mode", "original"), baseline={"tasks": [{k: t[k] for k in ("id", "typeId", "curStep", "stepValue") if k in t} for t in snapshot.raw.get("currentTasks", []) if str(t.get("id")) == str(value(intent, "task_id")) or str(t.get("typeId")) == str(value(intent, "task_type_id"))], "loop_time": snapshot.raw.get("history", {}).get("loopTaskTime"), "passed": stage_has_level(snapshot.raw.get("history", {}), "passStage", value(intent, "stage_id", ""), value(intent, "difficulty", "1"))}) if sweep_entry is not None: legacy_archive = sweep_phase == "legacy_hidden_archived" and sweep_entry.get("role_id") is None if (not legacy_archive and str(sweep_entry.get("role_id")) != role_id(snapshot)) or not sweep_entry.get("sampleId"): raise ValueError("扫荡交接角色或原始编号缺失") record.update(sweep_sample_id=sweep_entry["sampleId"], sweep_entry=public_data(sweep_entry), sweep_entry_digest=digest(public_data(sweep_entry)), phase=sweep_phase or record["phase"]) if value(intent, "token") and value(intent, "account_key"): record.update(intent_id=value(intent, "token"), account_key=value(intent, "account_key")) if record.get("source_task_type_id") and not record.get("source_task_id"): from .progression import ProgressionPlanner record["source_offer_day"] = ProgressionPlanner._loop_day(snapshot, snapshot.now - 10) state = self.role(snapshot) state["records"].append(record) state["pending"] = record["attempt_id"] self.save() # Must succeed BEFORE any non-retryable request. return record def update(self, record, phase, **fields): record.update(public_data(fields), phase=phase, updated_at=time.time()) self.save() def finish(self, snapshot, record, outcome, message=""): state = self.role(snapshot) record.update(phase="done", outcome=outcome, message=message, finished_at=time.time()) if state["pending"] == record["attempt_id"]: state["pending"] = None shared_loss_budget = record.get("kind") != "map_battle" and not record.get("sweep_sample_id") if outcome == "loss" and shared_loss_budget: state["losses"] += 1 state["last_loss_at"] = snapshot.now elif outcome == "win" and shared_loss_budget: state["losses"] = 0 state["last_loss_at"] = None self.save() def cursors(self, snapshot): return deepcopy(self.role(snapshot)["cursors"]) def checkpoint(self, snapshot, intent, response=None): """Local acknowledgements never rewrite the authoritative snapshot.""" key = f"{value(intent, 'task_id', 0)}:{value(intent, 'task_type_id', '')}" step = int(value(intent, "step_number", 0) or 0) current = next((t for t in snapshot.raw.get("currentTasks", []) if str(t.get("id")) == str(value(intent, "task_id"))), {}) entry = self.role(snapshot)["cursors"].setdefault(key, {"task_id": value(intent, "task_id"), "task_type_id": value(intent, "task_type_id"), "server_step": int(current.get("curStep", step) or step), "steps": {}}) checkpoint = entry["steps"].setdefault(str(step), {"operations": {}, "submitted": False, "local_complete": False}) kind, phase = value(intent, "kind"), value(intent, "phase", "") checkpoint["operations"][f"{kind}:{phase}"] = {"kind": kind, "phase": phase, "response": gameplay_response(response) if isinstance(response, dict) else None} if isinstance(response, dict) and ((value(intent, "path", "") or "").endswith("taskCompleteStep") or kind in ("battle", "task_battle", "progression_battle")): checkpoint["submitted"] = True if kind in ("progression_local_step", "local_step"): checkpoint["local_complete"] = True self.save() def reconcile(self, snapshot, *, trusted=False): """Only a new role-checked server snapshot can resolve uncertain writes. An unchanged step, stamina change or old three-star clear is insufficient. No endpoint is replayed by reconciliation. """ if not trusted: return False with self.lock: self.reload() record = self.pending(snapshot) tasks = snapshot.raw.get("currentTasks", []) history = snapshot.raw.get("history", {}) state = self.role(snapshot) changed = False # Keep checkpoints for steps that the server has not incorporated. for key, cursor in list(state["cursors"].items()): task = next((t for t in tasks if str(t.get("id")) == str(cursor.get("task_id")) and str(t.get("typeId")) == str(cursor.get("task_type_id"))), None) if task is None: del state["cursors"][key] changed = True elif int(task.get("curStep", 1)) > int(cursor.get("server_step", 0)): cursor["server_step"] = int(task["curStep"]) cursor["steps"] = {k: v for k, v in cursor["steps"].items() if int(k) >= int(task["curStep"])} changed = True resolved = False if record: task = next((t for t in tasks if str(t.get("id")) == str(record.get("task_id")) and str(t.get("typeId")) == str(record.get("task_type_id"))), None) path = record.get("path") or "" if record.get("task_id") and record.get("step_number"): resolved = bool(task and int(task.get("curStep", 1)) > int(record["step_number"])) response = record.get("response") or {} baseline = next((t for t in record["baseline"]["tasks"] if str(t.get("id")) == str(record["task_id"])), {}) if (not resolved and "planner_state" not in state and task and response.get("taskStepValue") is not None and task.get("stepValue") == response["taskStepValue"] and baseline.get("stepValue") != response["taskStepValue"]): self.checkpoint(snapshot, record, response) resolved = True if record.get("task_type_id") and path.endswith(("taskReceive", "taskLoopReceive")): old = {str(t.get("id")) for t in record["baseline"]["tasks"]} resolved = any(str(t.get("typeId")) == str(record["task_type_id"]) and str(t.get("id")) not in old for t in tasks) if path.endswith("taskComplete"): resolved = task is None and bool(indexed(history.get("passTask"), record["task_type_id"], False)) if path.endswith("taskLoopFlush"): resolved = history.get("loopTaskTime") != record["baseline"].get("loop_time") if path.endswith("taskUpdate"): payload = record.get("payload") or {} resolved = (all(any(str(t.get("typeId")) == str(row.get("taskTypeId")) for t in tasks) for row in payload.get("receiveTasks", [])) and all(indexed(history.get("unlockTask"), row.get("taskTypeId"), False) for row in payload.get("unlockTasks", [])) and all(not any(str(t.get("id")) == str(mid) for t in tasks) for mid in payload.get("removeTasks", []))) if record.get("stage_id") and not record.get("task_id"): # A first clear proves settlement, but NOT the optional record request. resolved = (not record["baseline"]["passed"] and stage_has_level(history, "passStage", record["stage_id"], record.get("difficulty", "1")) and record["phase"] not in ("record_pending", "record_unknown")) if resolved: self.finish(snapshot, record, "reconciled", "已由服务器任务 / 首次通关快照核对;未重发请求") if changed and not resolved: self.save() return resolved class BattleOrchestrator: def __init__(self, catalog, journal=None, runtime=None, sweeper=None, request_builder=None, observer=None, clock=None): self.catalog = catalog self.journal = journal or BattleJournal() self.runtime = runtime self.sweeper = sweeper self.request_builder = request_builder self.observer = observer self.clock = clock or time.monotonic def pending(self, snapshot): return self.journal.pending(snapshot) def task_at_position(self, snapshot, position): positions = self.catalog.data.get("stage_task_positions", {}) for task in snapshot.raw.get("currentTasks", []): steps = positions.get(str(task.get("typeId")), []) number = int(task.get("curStep", 1)) - 1 if 0 <= number < len(steps) and steps[number] == position: return task def request(self, snapshot, intent, policy): task = bool(value(intent, "task_id")) or bool(value(intent, "task_type_id")) and value(intent, "battle_kind") in ( "task", "battle", "passStage", "task_battle", "task_pass_stage") position = {"battleType": "task" if task else "stage", "stageId": None if task else str(value(intent, "stage_id", "")), "stageLevel": None if task else str(value(intent, "difficulty", "1")), "taskTypeId": str(value(intent, "task_type_id")) if task else None, "taskStep": max(0, int(value(intent, "step_number", 1) or 1) - 1) if task else 0} request = {"snapshot": snapshot.raw if self.request_builder else deepcopy(snapshot.raw), "team": policy.team, "battle_position": position, "battle_mode": value(policy, "battle_mode", "original"), **{name: value(intent, name) for name in ("stage_id", "difficulty", "task_type_id", "step_number", "battle_kind", "stage_category")}} return self.request_builder(snapshot, intent, policy, request) if self.request_builder else request def resource_reason(self, snapshot, intent, policy, ranch=None): if self.sweeper and self.sweeper.state.get("pending"): return "有未核对的扫荡,不能开始任务 / 战斗" if self.journal.pending(snapshot): return "有待核对的任务 / 战斗,禁止重复开始" if value(intent, "task_id"): planner_validated = self.observer("validate", intent, None) if self.observer else None task = next((t for t in snapshot.raw.get("currentTasks", []) if str(t.get("id")) == str(value(intent, "task_id")) and str(t.get("typeId")) == str(value(intent, "task_type_id"))), None) number = int(value(intent, "step_number", 1)) key = f"{value(intent, 'task_id')}:{value(intent, 'task_type_id')}" checkpoints = self.journal.cursors(snapshot).get(key, {}).get("steps", {}) server = int(task.get("curStep", 1)) if task else 0 locally_completed = task and server < number and all(checkpoints.get(str(i), {}).get("local_complete") for i in range(server, number)) if planner_validated is False or planner_validated is None and (task is None or server != number and not locally_completed): return "任务实例或服务器步骤已变化,请重新规划" if planner_validated is None and checkpoints.get(str(number), {}).get("submitted"): return "该任务步骤已有确认记录,等待剧情 / 服务器步骤核对" if reason := self.journal.loss_reason(snapshot, policy): return reason reason = team_availability_reason(snapshot, policy.team) if reason: return reason stage_id = str(value(intent, "stage_id", "") or "") difficulty = str(value(intent, "difficulty", "1") or "1") if not stage_id: return "" if value(intent, "task_id") else "缺少关卡定位" stage = self.catalog.data.get("stage_info", {}).get(stage_id) if not stage or difficulty not in stage.get("level", {}): return "关卡配置缺失" if not value(intent, "task_id"): if value(intent, "kind") == "map_battle" and value(intent, "stage_category") in ("mine", "ticket"): if value(intent, "battle_kind") != "resource_stage": return "资源关卡战斗类型不匹配,禁止入场" if self.sweeper: rule = value(policy, "rules", {}).get(stage_id, {}) key = self.sweeper.key(snapshot, SimpleNamespace(stage_id=stage_id, level=difficulty)) if (not rule.get("enabled") or str(rule.get("level")) != difficulty or int(self.sweeper.state.get("counts", {}).get(key, 0)) >= max(0, int(rule.get("limit") or 0))): return "资源关卡未显式勾选或已达本日次数上限" match = next((row for row in stages(self.catalog, snapshot) if row.stage_id == stage_id and row.level == difficulty), None) if match is None: return "资源关卡配置缺失" reason = resource_entry_reason(self.catalog, snapshot, match, policy) if reason: return reason policy = replace(policy, item_reserves={key: max(int(value(policy, "item_reserves", {}).get(key, 0)), int(value(policy, "keep_tickets", 0))) for key in item_requirements((stage.get("cost") or {}).get("items", []))}) \ if is_dataclass(policy) else SimpleNamespace(**(vars(policy) | {"item_reserves": {key: max( int(value(policy, "item_reserves", {}).get(key, 0)), int(value(policy, "keep_tickets", 0))) for key in item_requirements((stage.get("cost") or {}).get("items", []))}})) position = value(intent, "position") or f"city{stage.get('city')}_wild_stage{stage_id}_level{difficulty}" if self.task_at_position(snapshot, position): return "该位置由当前任务优先处理,不能执行普通挑战或扫荡" match = next((s for s in stages(self.catalog, snapshot) if s.stage_id == stage_id and s.level == difficulty), None) if match is None or not match.unlocked or not match.open: return "关卡尚未解锁或当前未开放" base = stage.get("cost") or {} master = snapshot.raw["master"] stamina = float(base.get("ti") or 0) + float(stage["level"][difficulty].get("cost") or 0) if float(master.get("ti") or 0) < stamina + max(0, policy.reserve_ti): return "体力不足或已达保留体力" if base.get("ke"): return "入场需要氪金,未启用" money = float(base.get("money") or 0) if money and (money > policy.max_money or float(master.get("money") or 0) - money < max(0, value(ranch, "keep_money", 0))): return "入场金币超过上限或保留金币不足" for key, count in item_requirements(base.get("items") or []).items(): if count and not policy.allow_items: return "入场需要消耗道具,未启用" reserve = max(int(policy.item_reserves.get(key, 0)), int(value(ranch, "reserved_eggs", {}).get(key, 0))) owned = available_item_count(snapshot, key) reserve = max(reserve, int(value(ranch, "gift_items", {}).get(key, {}).get("reserve", 0))) if owned - count < reserve: return "入场道具不足或已达保留数量" return "" def inspect(self, request): self._inspection_evidence = {} if self.runtime is None: return False, "所选战斗运行时尚未提供,未开始战斗" report = self.runtime.inspect(request.get("runtime_request", request)) self._inspection_evidence = self.runtime_evidence(report, request.get("battle_mode", "original")) supported = value(report, "supported") is True if request.get("battle_mode", "original") == "experimental": supported = (supported and value(report, "execution_mode") == "experimental" and value(report, "approximate") is True and value(report, "faithful") is False) else: supported = supported and value(report, "settlement_eligible") is True and value(report, "approximate") is not True blockers = list(value(report, "anomalies", []) or []) blockers += [row for row in value(report, "diagnostics", []) or [] if isinstance(row, dict) and row.get("blocking") is True] supported = supported and not blockers reasons = list(value(report, "reasons", []) or []) + blockers reason = value(report, "block_reason") or value(report, "reason") or "; ".join( str(row.get("detail") or row.get("code")) if isinstance(row, dict) else str(row) for row in reasons) or \ "运行时尚未验证支持此阵容 / 关卡,未开始战斗" return supported, "" if supported else str(reason) @staticmethod def runtime_evidence(result, mode): evidence = {"battle_mode": mode, **{field: public_data(value(result, field)) for field in ( "faithful", "approximate", "limitations", "reasons", "status", "elapsed_ms", "model_elapsed_ms", "requires_realtime_wait", "wall_time_ms", "trace_path", "resource_identity", "terminal_reason", "settlement_eligible", "experimental_settlement_eligible", "execution_mode", "execution_status", "terminal", "diagnostics", "ignored_mechanics", "anomalies", "assumptions", "experimental_eligibility_reasons", "omitted_events", "model", "simulation_method", "team_budgets", "generated_units", "spawn_bound_reached", "damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope", "supported", "timeout_kind")}} trace = value(result, "trace") if trace is None: trace = value(result, "events") evidence["trace_source"] = "events" if isinstance(trace, (list, tuple)): evidence.update(trace=public_data(list(trace[:128]) + list(trace[-128:]) if len(trace) > 256 else trace), trace_count=len(trace), trace_truncated=len(trace) > 256 or bool(value(result, "trace_truncated")), journal_trace_truncated=len(trace) > 256, trace_digest=digest(trace)) elif trace is not None: evidence["trace"] = public_data(trace) return evidence @staticmethod def combat_resource_digest(): # Bind retries to the same combat tables and quick-model mathematics. # Worker transport changes do not alter this contract. root = Path(__file__).parent return digest([hashlib.sha256(path.read_bytes()).hexdigest() for path in (root / "data" / "combat_manifest.json", root / "battle_quick.py")]) def save_combat_request(self, record, request): if request.get("battle_mode") != "experimental": if request.get("battle_kind") != "hidden": return {} combat = public_data(request) return {"combat_request": combat, "combat_request_digest": digest(combat), "combat_resource_digest": self.combat_resource_digest()} from .battle_simulator import _transport_request combat = public_data(_transport_request(request)) raw = combat.get("roster") if isinstance(raw, dict): teams = [{key: row[key] for key in ("teamName", "teamType", "monsters") if key in row} for row in raw.get("teams", []) if row.get("teamName") == combat["team"]] for row in teams: members = row.get("monsters") or [] if isinstance(members, str): members = members.split(",") # Preserve lineup order and empty slots; exploration helpers # discard those slots and therefore cannot normalize combat. row["monsters"] = [int(mid) if str(mid).strip() else 0 for mid in members] ids = {str(mid) for row in teams for mid in row["monsters"]} if not teams: ids = set(combat["team"].split(",")) fields = {"id", "typeId", "level", "mode", "tpLevel", "feel", "upStar", "potentialLevel", "skin", "controller", "skill_1", "skill_2", "skill_1_lv", "skill_2_lv", *["equip" + str(i) for i in range(1, 6)], *[prefix + stat for prefix in ("g", "p") for stat in ("Atk", "Def", "Hp", "Dex")]} raw["teams"] = teams raw["monsters"] = [{key: val for key, val in row.items() if key in fields} for row in raw.get("monsters", []) if str(row.get("id")) in ids] raw["monsterAttributes"] = [row for row in raw.get("monsterAttributes", []) or [] if str(row.get("monsterId")) in ids] combat["battle_mode"] = "experimental" return {"combat_request": combat, "combat_request_digest": digest(combat), "combat_resource_digest": self.combat_resource_digest()} def accept_runtime_result(self, record, request, result, started, cancel): mode = request.get("battle_mode", "original") evidence = self.runtime_evidence(result, mode) for key in ("damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope"): if evidence.get(key) is None: evidence.pop(key, None) self.journal.update(record, "runtime_returned", runtime_outcome=value(result, "outcome"), **evidence) outcome, data = value(result, "outcome"), value(result, "battle_data") eligible = outcome in ("win", "loss") if mode == "experimental": eligible = (eligible and value(result, "experimental_settlement_eligible") is True and value(result, "execution_mode") == "experimental" and value(result, "execution_status") == "completed" and value(result, "supported") is True and value(result, "terminal") is True and value(result, "approximate") is True and value(result, "faithful") is False and not value(result, "anomalies") and not any(row.get("blocking") is True for row in value(result, "diagnostics", []) or [] if isinstance(row, dict))) else: eligible = (eligible and value(result, "settlement_eligible") is True and value(result, "faithful") is True and value(result, "approximate") is not True) if not eligible or not isinstance(data, dict) or type(data.get("win")) is not bool: message = ("本地战斗运行超时,已入场但尚无战果,等待恢复核对" if value(result, "execution_status") == "timed_out" else "战斗已取消、超时或结果不确定,等待核对") self._unknown(record, message) return False if data["win"] != (outcome == "win"): self._unknown(record, "运行结果与战果胜负不一致,未提交结算") return False position = data.get("battlePosition") if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None} != {k: v for k, v in request["battle_position"].items() if v is not None}): self._unknown(record, "运行时战果定位不匹配,未提交结算") return False # A generation cancellation does not invalidate an already computed result. self.journal.update(record, "runtime_complete", battle_data=data) ready = self.wait_for_battle_clock(record, request, result, data, started, cancel) if cancel.is_set(): self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对") return False return ready def wait_for_battle_clock(self, record, request, result, data, started, cancel): if value(result, "requires_realtime_wait") is not True: self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=0, battle_ready_at=time.time(), resume_clock_ready=True) return True duration = None for field, scale in (("model_elapsed_ms", .001), ("battle_elapsed_ms", .001), ("elapsed_ms", .001), ("model_elapsed_seconds", 1), ("elapsed_seconds", 1), ("elapsed", 1)): elapsed = value(result, field) if type(elapsed) in (int, float) and math.isfinite(elapsed) and elapsed >= 0: duration = elapsed * scale break battle = (request.get("original_data") or {}).get("battle") or {} limit, left = battle.get("time"), data.get("leftTime") if type(limit) in (int, float) and math.isfinite(limit) and limit > 0 and type(left) in (int, float) and 0 <= left <= limit * 1000: duration = max(duration or 0, limit - left / 1000) if duration is None: self._unknown(record, "模型未提供有效战斗时钟,未提交结算") return False deadline = started + duration self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=duration, battle_ready_at=time.time() + max(0, deadline - self.clock()), resume_clock_ready=True, message="等待已计算的战斗时钟;停止后保留结果,重新开启策略后自动续交") while not cancel.is_set(): remaining = deadline - self.clock() if remaining <= 0: return True if cancel.wait(min(remaining, .25)): break self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对") return False @staticmethod def confirmed_start(record): response = record.get("start_response") task = bool(record.get("task_id")) path = "battleService/battleStart" if task else "stageService/stageStart" hidden = hidden_stage_id(response) confirmed_hidden = (not task and hidden is not None and record.get("battle_kind") == "hidden" and hidden == str(record.get("stage_id")) and str(record.get("difficulty")) == "1") return (record.get("start_path") == path and isinstance(response, dict) and response.get("resCode", 0) in (0, "0") and (task or response.get("triggerEvent") is False or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0 or confirmed_hidden)) @staticmethod def source_matches(record, snapshot): if not record.get("source_task_type_id"): return True if not record.get("source_task_id") and not record.get("source_step_number"): from .progression import ProgressionPlanner history = snapshot.raw.get("history", {}) offers = history.get("loopTask") or {} today = ProgressionPlanner._loop_day(snapshot, snapshot.now - 10) return (record.get("source_offer_day") == today and history.get("loopTaskTime") is not None and ProgressionPlanner._loop_day(snapshot, history["loopTaskTime"]) == today and isinstance(offers, dict) and any(str(key) == str(record["source_task_type_id"]) for rows in offers.values() if isinstance(rows, (list, tuple)) for key in rows) and not any(str(task.get("typeId")) == str(record["source_task_type_id"]) for task in snapshot.raw.get("currentTasks", []))) return any(str(task.get("id")) == str(record.get("source_task_id")) and str(task.get("typeId")) == str(record["source_task_type_id"]) and str(task.get("curStep")) == str(record.get("source_step_number")) for task in snapshot.raw.get("currentTasks", [])) @staticmethod def legacy_stage_failure(record): return (record.get("kind") == "stage_battle" and not record.get("task_id") and not record.get("task_type_id") and record.get("battle_kind") == "ordinary_stage" and record.get("stage_category") in (None, "", "ordinary") and record.get("source_task_type_id") and record.get("execution_mode") == "experimental" and record.get("terminal") is False and record.get("terminal_reason") in ("worker_wall_clock_limit", "worker_cancelled", "worker_interrupted") and record.get("execution_status") in ("cancelled", "timed_out") and not record.get("battle_data")) @staticmethod def resumable_task_clock(record): common = bool(record and record.get("kind") in COMBAT_KINDS and ((record.get("execution_mode") == "experimental" and record.get("execution_status") == "completed" and record.get("experimental_settlement_eligible") is True and record.get("terminal") is True and record.get("approximate") is True and record.get("faithful") is False) or (record.get("battle_mode") == "original" and record.get("settlement_eligible") is True and record.get("faithful") is True and record.get("approximate") is not True)) and not record.get("anomalies") and not any(row.get("blocking") is True for row in record.get("diagnostics") or [] if isinstance(row, dict)) and isinstance(record.get("battle_data"), dict) and type(record["battle_data"].get("win")) is bool) if not common: return False if record.get("phase") in ("record_pending", "record_unknown"): return False if not record.get("task_id") and record.get("settlement_confirmed") is True: return (record["battle_data"]["win"] is True and isinstance(record.get("response"), dict) and record["response"].get("resCode", 0) in (0, "0") and (not record.get("record_dispatched") or record.get("record_confirmed") is True)) return (record.get("phase") in ("unknown", "runtime_complete", "waiting_for_battle_clock", "record_acknowledged") and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart") and not record.get("settlement_confirmed") and not record.get("settlement_dispatched") and (not record.get("record_dispatched") or record.get("record_confirmed") is True) and (record.get("resume_clock_ready") is True or record.get("phase") == "runtime_complete" or record.get("message") == "等待战斗时钟期间已取消,开战记录保留待核对")) def recovery_status(self, record, *, snapshot=None): """Read-only classification. Resumable never grants permission to write.""" def status(state, message=""): return {"state": state, "resumable": state not in ("none", "blocked"), "message": message} if not record: return status("none") if isinstance(snapshot, dict): snapshot = SimpleNamespace(raw=snapshot, now=time.time()) if record.get("kind") not in COMBAT_KINDS: return status("blocked", record.get("message") or "任务请求待核对,不能按战斗恢复") if snapshot and str(record.get("role_id")) != role_id(snapshot): return status("blocked", "角色与原入场记录不匹配,保留待核对记录") preaccept = not record.get("source_task_id") and not record.get("source_step_number") source_matches = snapshot is None or self.source_matches(record, snapshot) if (not source_matches and not (preaccept and self.legacy_stage_failure(record))): return status("blocked", "角色或来源委托步骤已变化,保留原战斗记录等待核对") if record.get("abandon_requested") and record.get("record_confirmed") is True and record.get("record_result") is False: return status("finish_abandonment", "失败退出已确认,等待完成本地记录") if self.resumable_task_clock(record): return status("resume_result", "完整战果已保存,可续交尚未发送的结果") if record.get("phase") in ("record_pending", "record_unknown") or record.get("record_dispatched"): return status("blocked", "战果记录请求已发送但结果未确认,禁止重复发送") if record.get("settlement_dispatched") or record.get("settlement_confirmed") or record.get("path") not in ( "", None, "stageService/stageStart", "battleService/battleStart"): return status("blocked", "结算请求可能已发送,等待服务器证据,禁止重复结算") if record.get("phase") == "prepared" and record.get("start_dispatched") is False and not record.get("start_response"): return status("unsent", "开战请求尚未发送,可取消本地准备记录") if not self.confirmed_start(record): return status("blocked", "开战请求结果未确认,禁止重新入场或自动退出") if (record.get("sweep_sample_id") and record.get("runtime_not_started") is True and not record.get("combat_request") and self.hidden_sweep_inputs(record)): return status("prepare_hidden_sweep", "隐藏入场及原始队伍已保存,可继续本次战斗") interrupted = (record.get("runtime_not_started") is True or record.get("phase") in ("started", "running", "hidden_started") or record.get("execution_status") in ("cancelled", "timed_out", "error")) if not interrupted or record.get("battle_data"): return status("blocked", "没有可验证的完整战果或安全恢复证据,保留待核对记录") combat = record.get("combat_request") if not isinstance(combat, dict): # Original AIR: BattlePausePanel.yesEscapeHandler -> checkGameOver # (run=True, winnerTeam=2) -> BattlePanel.showLose -> battleResult(false). if self.legacy_stage_failure(record): return status("abandon_stage", "旧记录缺少原始战斗输入,本地计算已超时或取消;开启后按原客户端退出协议记录失败,不推进任务") return status("blocked", "旧记录缺少原始战斗输入,不能用当前属性重算;需要权威记录或原客户端退出核对") if self.legacy_stage_failure(record) and (not source_matches or record.get("runtime_recovery_attempts", 0) >= 1): return status("abandon_stage", "本地战斗未完成且来源委托已变化或恢复已用尽;开启后按原客户端退出协议记录失败") if record.get("runtime_recovery_attempts", 0) >= 1: return status("blocked", "本地战斗恢复已尝试一次仍未完成,保留入场记录等待核对") if (record.get("battle_mode") != "experimental" and record.get("battle_kind") != "hidden" or digest(combat) != record.get("combat_request_digest") or self.combat_resource_digest() != record.get("combat_resource_digest")): return status("blocked", "保存的原始战斗输入或资源校验不匹配,禁止改用当前属性重算") return status("retry_local_runtime", "入场已确认且结算未发送,可用保存的原始输入恢复一次本地战斗") def resume_task_clock(self, client, snapshot, intent, policy, *, cancel): """Recover this entry only; never replay start or an uncertain server write.""" with self.journal.lock: self.journal.reload() record = self.journal.pending(snapshot) recovery = self.recovery_status(record, snapshot=snapshot) if not policy.enabled or cancel.is_set() or not recovery["resumable"]: return "" if str(record.get("role_id")) != str(role_id(snapshot)): return "" if any(str(record.get(key)) != str(value(intent, key)) for key in ("kind", "task_id", "task_type_id", "step_number")): return "" if not record.get("task_id") and any(str(record.get(key)) != str(value(intent, key)) for key in ("stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number")): return "" if recovery["state"] == "unsent": if self.observer and (record.get("task_id") or record.get("map_roster_signature")): self.observer("cancelled_before_start", intent, None) self.journal.finish(snapshot, record, "cancelled", "已取消尚未发送的开战准备记录;未重新入场") return record["message"] if recovery["state"] in ("abandon_stage", "finish_abandonment"): try: if recovery["state"] == "abandon_stage": self.journal.update(record, "abandon_pending", abandon_requested=True) self._record(client, record, record["stage_id"], False, cancel=cancel) self.journal.finish(snapshot, record, "abandoned", "已按原客户端退出协议确认失败;未提交胜利战果或推进来源委托") return record["message"] except CancelledBeforeDispatch: return "策略已停止,失败退出请求尚未发送,保留原入场记录" except Exception as error: self._unknown(record, "失败退出请求结果未确认,禁止重复发送", error_type=type(error).__name__) raise task_battle = bool(record.get("task_id")) if task_battle: task = next((row for row in snapshot.raw.get("currentTasks", []) if str(row.get("id")) == str(record["task_id"]) and str(row.get("typeId")) == str(record["task_type_id"])), None) if not task or int(task.get("curStep", 1)) != int(record["step_number"]): return "" expected = {"battleType": "task" if task_battle else "stage", "stageId": None if task_battle else str(record.get("stage_id")), "stageLevel": None if task_battle else str(record.get("difficulty")), "taskTypeId": str(record["task_type_id"]) if task_battle else None, "taskStep": int(record["step_number"]) - 1 if task_battle else 0} if recovery["state"] == "retry_local_runtime": request = deepcopy(record["combat_request"]) position = request.get("battle_position") if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None} != {k: v for k, v in expected.items() if v is not None} or request.get("team") != record.get("team")): return "保存的原始战斗输入与入场定位不匹配,保留待核对记录" supported, reason = self.inspect(request) if not supported: return "保存的原始战斗输入当前无法执行:" + reason self.journal.update(record, "running", runtime_recovery_attempts=1, runtime_not_started=False) try: started = self.clock() result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel) if not self.accept_runtime_result(record, request, result, started, cancel): return record["message"] except Exception as error: self._unknown(record, "本地战斗恢复未完成,保留原入场记录", error_type=type(error).__name__) raise data = record["battle_data"] position = data.get("battlePosition") if not isinstance(position, dict) or {key: val for key, val in position.items() if val is not None} != { key: val for key, val in expected.items() if val is not None}: return "" ready = 0 if record.get("settlement_confirmed") else record.get("battle_ready_at") if ready is None: duration = record.get("battle_clock_seconds") if duration is None and record.get("requires_realtime_wait") is not True: duration = 0 if duration is None and type(record.get("elapsed_ms")) in (int, float): duration = record["elapsed_ms"] / 1000 stamp = record.get("updated_at") if any(type(number) not in (int, float) or not math.isfinite(number) or number < 0 for number in (duration, stamp)): return "" ready = stamp + duration # Older builds: conservatively wait a full duration after interruption. self.journal.update(record, record["phase"], battle_ready_at=ready) if type(ready) not in (int, float) or not math.isfinite(ready): return "" if time.time() < ready: return "已核对保存的战果;尚未到结算时间,2分钟内自动复查" try: if not data["win"]: if (not task_battle or record.get("battle_kind") == "passStage") and not record.get("record_confirmed"): self._record(client, record, record["stage_id"], False, cancel=cancel) if self.observer: self.observer("loss", intent, None) self.journal.finish(snapshot, record, "loss", "打不过(保存的模拟结果);未提交胜利结算") self._finish_hidden_sweep(snapshot, record) return record["message"] response = record.get("response") if record.get("settlement_confirmed") else None if response is None: path = "taskService/taskCompleteStep" if task_battle else "battleService/battleEnd" payload = {"battleData": deepcopy(data)} if task_battle: payload.update(taskId=int(record["task_id"]), taskTypeId=str(record["task_type_id"]), removeIds=None) self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True) response = self._call(client, path, payload, cancel=cancel, require_code=record.get("battle_kind") == "hidden") self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True, reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward")) self._remember_hidden_sweep(snapshot, record) if not task_battle and not record.get("record_confirmed"): self._record(client, record, record["stage_id"], True, cancel=cancel) if self.observer: self.observer("settled", intent, response) elif task_battle: self.journal.checkpoint(snapshot, intent, response) self.journal.finish(snapshot, record, "win", "已恢复此入场的战果并确认结算;未重新开战") self._finish_hidden_sweep(snapshot, record) return record["message"] except CancelledBeforeDispatch: if not record.get("settlement_confirmed"): self.journal.update(record, "waiting_for_battle_clock", path="battleService/battleStart" if task_battle else "stageService/stageStart", settlement_dispatched=False, resume_clock_ready=True) return "策略已停止,保存的战果将在重新开启后续交" except Exception as error: self._unknown(record, "续交请求结果未确认,将自动查询状态,不重复发送", error_type=type(error).__name__) raise def run(self, client, snapshot, intent, policy, *, cancel=None, ranch=None): if not self.journal.lock.acquire(blocking=False): return "同账号已有任务 / 战斗正在执行" try: return self._run(client, snapshot, intent, policy, cancel=cancel, ranch=ranch) finally: self.journal.lock.release() def _run(self, client, snapshot, intent, policy, *, cancel=None, ranch=None): cancel = cancel or threading.Event() with self.journal.lock: self.journal.reload() if not policy.enabled: return "自动主线策略未启用" reason = value(intent, "block_reason") or self.resource_reason(snapshot, intent, policy, ranch) if reason: return str(reason) if cancel.is_set(): return "任务 / 战斗已取消,未开始" if value(intent, "kind") in ("sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep") or value(intent, "battle_kind") == "sweep": return self._sweep(client, snapshot, intent, policy, cancel) request = self.request(snapshot, intent, policy) mode = request.get("battle_mode", "original") supported, reason = self.inspect(request) if not supported: record = self.journal.begin(snapshot, intent) record.update(self._inspection_evidence, team=policy.team, battle_mode=mode) self.journal.finish(snapshot, record, "unsupported", reason) return reason if cancel.is_set(): return "任务 / 战斗已取消,未开始" record = self.journal.begin(snapshot, intent) try: self.journal.update(record, "prepared", start_dispatched=False) if self.observer: self.observer("started", intent, None) if value(intent, "task_id"): path, payload = "battleService/battleStart", {"battleType": "task", "taskTypeId": str(value(intent, "task_type_id"))} else: path, payload = "stageService/stageStart", {"stageTypeId": str(value(intent, "stage_id")), "stageLevel": str(value(intent, "difficulty", "1"))} self.journal.update(record, "start_pending", **{key: val for key, val in self._inspection_evidence.items() if key not in ("battle_mode", "resource_identity")}, **self.save_combat_request(record, request), path=path, start_path=path, start_dispatched=True, settlement_dispatched=False, record_dispatched=False, input_digest=digest(public_data(request)), team=policy.team, battle_mode=mode, resource_identity=(request.get("original_data") or {}).get("manifest", {}).get("source")) try: started = self._call(client, path, payload, cancel=cancel) except CancelledBeforeDispatch: self.journal.update(record, "start_pending", start_dispatched=False) if self.observer: self.observer("cancelled_before_start", intent, None) self.journal.finish(snapshot, record, "cancelled", "开战请求尚未发送,已取消;未消耗入场资源") return record["message"] battle_started = self.clock() self.journal.update(record, "started", start_confirmed=True, start_confirmed_at=time.time(), runtime_not_started=True, start_response=gameplay_response(started)) if not value(intent, "task_id"): reward = event_reward(started) if reward is not None: self.journal.update(record, "event_reward", reward=reward) if self.observer: self.observer("event", intent, started) self.journal.finish(snapshot, record, "event", "探索事件奖励已由开始响应发放") return "探索事件奖励已结算;未执行战斗" 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: request = self._hidden_request(record, snapshot, intent, policy, started) if request is None: return self._unknown(record, "隐藏关卡编号或原入场证据无效,等待核对") supported, reason = self.inspect(request) if not supported: return self._unknown(record, "隐藏关卡待处理:" + reason) else: return self._unknown(record, "探索事件或开战状态未知,等待核对") return self._fight(client, snapshot, intent, request, record, battle_started, cancel) except CancelledBeforeDispatch: if not record.get("settlement_confirmed"): self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"], settlement_dispatched=False, resume_clock_ready=True) return "策略已停止,保存的战果将在重新开启后续交" except Exception as error: self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__) raise def _hidden_request(self, record, snapshot, intent, policy, started): hidden = hidden_stage_id(started) if hidden is None: return None fields = asdict(intent) if is_dataclass(intent) else dict(intent) if isinstance(intent, dict) else vars(intent).copy() fields.update(stage_id=hidden, difficulty="1", battle_kind="hidden") # Preserve the source intent for policies/observers, and the actual # hidden BattlePosition for every runtime/settlement/recovery path. self.journal.update(record, "hidden_started", parent_stage_id=record.get("parent_stage_id") or record["stage_id"], parent_difficulty=record.get("parent_difficulty") or record["difficulty"], stage_id=hidden, difficulty="1", battle_kind="hidden", runtime_not_started=True) request = self.request(snapshot, fields, policy) self.journal.update(record, "hidden_started", **self.save_combat_request(record, request), team=policy.team, battle_mode=request.get("battle_mode", "original")) return request def _remember_hidden_sweep(self, snapshot, record): if (self.sweeper is not None and record.get("sweep_sample_id") and record.get("settlement_confirmed") is True): self.sweeper.remember_map_reward(snapshot, record, record.get("response")) self.sweeper.last_outcome = "hidden_win" def _finish_hidden_sweep(self, snapshot, record): if not self.sweeper or not record.get("sweep_sample_id") or record.get("outcome") not in ("win", "loss"): return if str(record.get("role_id")) != role_id(snapshot): return self._remember_hidden_sweep(snapshot, record) self.sweeper.last_outcome = "hidden_" + record["outcome"] def handoff_sweep(self, snapshot): """Move a confirmed hidden entry into the journal without a game write.""" if self.sweeper is None: return None with self.journal.lock: self.journal.reload() pending = self.sweeper.state.get("pending") if not isinstance(pending, dict): return None hidden = hidden_stage_id(pending.get("start_response")) if (not hidden or pending.get("hidden_stage_id") not in (None, hidden) or str(pending.get("role_id")) != role_id(snapshot) or pending.get("start_confirmed") is not True or pending.get("start_path") != "stageService/stageStart" or pending.get("phase") not in ("hidden_started", "开始请求待确认") or not pending.get("sampleId")): return None if pending.get("phase") != "hidden_started" or pending.get("hidden_stage_id") is None: pending.update(phase="hidden_started", hidden_stage_id=hidden) self.sweeper.save() record = self.journal.pending(snapshot) completed = next((row for row in self.journal.role(snapshot)["records"] if row.get("sweep_sample_id") == pending["sampleId"] and row.get("phase") == "done"), None) if completed: if (record or completed.get("sweep_entry") != pending or completed.get("outcome") not in ("win", "loss") or completed.get("record_confirmed") is not True or completed.get("outcome") == "win" and completed.get("settlement_confirmed") is not True): return None self._finish_hidden_sweep(snapshot, completed) self.sweeper.state["pending"] = None self.sweeper.save() return completed install = not record or record.get("sweep_sample_id") != pending["sampleId"] origin = pending.get("origin") or ({name: record.get(name) for name in ("kind", "stage_id", "difficulty", "battle_kind", "task_id", "task_type_id", "step_number", "source_task_id", "source_task_type_id", "source_step_number", "battle_mode")} if record else {"kind": "map_sweep", "stage_id": pending["stage"], "difficulty": str(pending["level"]), "battle_kind": "sweep"}) if record and record.get("sweep_sample_id") == pending["sampleId"]: if record.get("sweep_entry") != pending: return None install = record.get("phase") == "prepared" and not record.get("start_dispatched") else: if record: if (record.get("kind") not in SWEEP_KINDS or record.get("sweep_sample_id") or str(record.get("stage_id")) != str(pending["stage"]) or str(record.get("difficulty")) != str(pending["level"]) or record.get("phase") not in ("prepared", "sweep_pending", "unknown") or record.get("start_dispatched") or record.get("settlement_dispatched") or record.get("record_dispatched")): return None else: record = self.journal.begin(snapshot, origin, sweep_entry=pending) if install: self.journal.update(record, "hidden_started", sweep_sample_id=pending["sampleId"], sweep_entry=deepcopy(pending), parent_stage_id=str(pending["stage"]), parent_difficulty=str(pending["level"]), stage_id=hidden, difficulty="1", battle_kind="hidden", team=pending.get("team") or "teamA", battle_mode=origin.get("battle_mode", "experimental"), start_path=pending["start_path"], path=pending["start_path"], start_response=pending["start_response"], start_confirmed=True, start_confirmed_at=pending.get("start_confirmed_at"), start_dispatched=True, runtime_not_started=True, settlement_dispatched=False, record_dispatched=False, sweep_entry_digest=digest(pending)) # The journal now owns both the response and original inputs. This # also lets the existing Web Start gate use battle recovery. self.sweeper.state["pending"] = None self.sweeper.save() return record def archive_cancelled_sweep(self, snapshot): """Release only an explicitly cancelled, never-settled sweep entry.""" pending = self.sweeper.state.get("pending") if self.sweeper else None if not isinstance(pending, dict) or pending.get("phase") != "cancelled_before_sweep_settlement": return "" response = pending.get("start_response") or {} flag = response.get("triggerEvent") if (pending.get("role_id") != role_id(snapshot) or pending.get("start_confirmed") is not True or pending.get("start_path") != "stageService/stageStart" or pending.get("settlement_dispatched") is not False or pending.get("record_dispatched") is not False or hidden_stage_id(response) is not None or not (flag is False or type(flag) is int and flag == 0) or response.get("resCode", 0) not in (0, "0") or not pending.get("sampleId")): return "" with self.journal.lock: self.journal.reload() record = self.journal.pending(snapshot) if record and (record.get("kind") not in SWEEP_KINDS or str(record.get("stage_id")) != str(pending["stage"]) or str(record.get("difficulty")) != str(pending["level"]) or record.get("settlement_dispatched") or record.get("record_dispatched") or record.get("phase") not in ("sweep_pending", "unknown", "cancelled_sweep_archived")): return "" done = next((row for row in self.journal.role(snapshot)["records"] if row.get("sweep_sample_id") == pending["sampleId"] and row.get("sweep_entry") == pending and row.get("outcome") == "abandoned_cancelled_sweep"), None) message = "扫荡入场已确认,结算尚未发送,停止后已本地放弃;未结算奖励" if done is None: record = record or self.journal.begin(snapshot, pending.get("origin") or { "kind": "map_sweep", "stage_id": pending["stage"], "difficulty": pending["level"]}, sweep_entry=pending, sweep_phase="cancelled_sweep_archived") self.journal.update(record, "cancelled_sweep_archived", sweep_sample_id=pending["sampleId"], sweep_entry=deepcopy(pending), archival_evidence={"role_id": role_id(snapshot), "snapshot_read_at": time.time(), "settlement_never_dispatched": True}) self.journal.finish(snapshot, record, "abandoned_cancelled_sweep", message) self.sweeper.state["pending"] = None self.sweeper.save() return message @staticmethod def hidden_sweep_inputs(record): entry = record.get("sweep_entry") or {} raw = entry.get("entry_snapshot") return (record.get("sweep_sample_id") and entry.get("sampleId") == record["sweep_sample_id"] and digest(entry) == record.get("sweep_entry_digest") and isinstance(raw, dict) and str((raw.get("master") or {}).get("id")) == str(record.get("role_id")) and entry.get("team") == record.get("team") and hidden_stage_id(entry.get("start_response")) == record.get("stage_id")) def continue_sweep(self, client, snapshot, policy, *, cancel=None): """Complete an already entered hidden sweep; never dispatch stageStart.""" cancel = cancel or threading.Event() with self.journal.lock: self.handoff_sweep(snapshot) record = self.journal.pending(snapshot) if not record or not record.get("sweep_sample_id") or not policy.enabled or cancel.is_set(): return "" status = self.recovery_status(record, snapshot=snapshot) if not status["resumable"]: return status["message"] intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number", "stage_category", "stage_id", "difficulty", "battle_kind", "team", "source_task_id", "source_task_type_id", "source_step_number")} if status["state"] != "prepare_hidden_sweep": return self.resume_task_clock(client, snapshot, intent, policy, cancel=cancel) entry = record["sweep_entry"] original = SimpleNamespace(raw=deepcopy(entry["entry_snapshot"]), now=entry.get("entry_snapshot_now", snapshot.now)) chosen = SimpleNamespace(**(vars(policy) | {"team": record["team"], "battle_mode": record["battle_mode"]})) try: request = self._hidden_request(record, original, intent, chosen, record["start_response"]) supported, reason = self.inspect(request) if not supported: return self._unknown(record, "隐藏关卡待处理:" + reason) return self._fight(client, snapshot, intent, request, record, self.clock(), cancel) except CancelledBeforeDispatch: if not record.get("settlement_confirmed"): self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"], settlement_dispatched=False, resume_clock_ready=True) return "策略已停止,隐藏战果已保存,等待重新开启来源策略" except Exception as error: self._unknown(record, "隐藏关卡结果未确认,保留原入场且禁止重发写请求", error_type=type(error).__name__) raise def _fight(self, client, snapshot, intent, request, record, battle_started, cancel): if cancel.is_set(): return self._unknown(record, "开战后已取消,等待服务器状态核对") self.journal.update(record, "running", runtime_not_started=False) result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel) if not self.accept_runtime_result(record, request, result, battle_started, cancel): return record["message"] data = record["battle_data"] mode = request.get("battle_mode", "original") if not data["win"]: if not value(intent, "task_id") or value(intent, "battle_kind") == "passStage": self._record(client, record, request["stage_id"], False, cancel=cancel) if self.observer: self.observer("loss", intent, None) label = "实验模型战败(近似)" if mode == "experimental" else "实际战败" self.journal.finish(snapshot, record, "loss", label + ";未提交胜利结算或推进任务") self._finish_hidden_sweep(snapshot, record) return label + ";已停止此轮任务推进" if value(intent, "task_id"): path, payload = "taskService/taskCompleteStep", {"taskId": int(value(intent, "task_id")), "taskTypeId": str(value(intent, "task_type_id")), "removeIds": None, "battleData": data} else: path, payload = "battleService/battleEnd", {"battleData": data} self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True) response = self._call(client, path, payload, cancel=cancel, require_code=record.get("battle_kind") == "hidden") self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True, reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward")) self._remember_hidden_sweep(snapshot, record) if value(intent, "task_id"): if self.observer: self.observer("settled", intent, response) else: self.journal.checkpoint(snapshot, intent, response) else: self._record(client, record, request["stage_id"], True, cancel=None if value(intent, "kind") == "map_battle" else cancel) if self.observer: self.observer("settled", intent, response) label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利" self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对") self._finish_hidden_sweep(snapshot, record) return label + ",已确认对应结算" def _sweep(self, client, snapshot, intent, policy, cancel): if not policy.allow_sweep or self.sweeper is None or value(intent, "task_id"): return "任务战斗或当前策略不允许普通扫荡" stage = next((s for s in stages(self.catalog, snapshot) if s.stage_id == str(value(intent, "stage_id")) and s.level == str(value(intent, "difficulty", "1"))), None) if stage is None or not stage.sweep: return "仅三个难度全通且客户端允许的普通关卡可扫荡" if cancel.is_set(): return "扫荡已取消,未开始" origin = {name: public_data(value(intent, name)) for name in ("kind", "task_id", "task_type_id", "step_number", "stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number")} origin["battle_mode"] = value(policy, "battle_mode", "experimental") battle_policy = policy policy = SweepPolicy(enabled=True, team=policy.team, keep_stamina=policy.reserve_ti, rules={stage.stage_id: {"enabled": True, "level": stage.level, "limit": self.sweeper.used(snapshot, stage) + 1}}) record = self.journal.begin(snapshot, intent) self.journal.update(record, "sweep_pending") try: if self.observer: self.observer("started", intent, None) response = self.sweeper.run(client, snapshot, stage, policy, cancel=cancel, origin=origin) if self.sweeper.last_outcome == "hidden": return self.continue_sweep(client, snapshot, battle_policy, cancel=cancel) if self.observer: self.observer("event" if self.sweeper.last_outcome == "event" else "settled", intent, response) self.journal.finish(snapshot, record, "event" if self.sweeper.last_outcome == "event" else "sweep", "复用客户端已有扫荡路径") return "探索奖励事件已结算" if self.sweeper.last_outcome == "event" else "扫荡已完成" except CancelledBeforeDispatch: if self.sweeper.state.get("pending") is None: self.journal.finish(snapshot, record, "cancelled", "扫荡入场尚未发送,已取消") return "扫荡已停止,已保留未确认记录" except Exception as error: record = self.journal.pending(snapshot) or record self._unknown(record, "扫荡结果未确认,禁止自动重试", error_type=type(error).__name__) raise @staticmethod def _call(client, path, payload, *, cancel=None, require_code=False): if cancel is not None and cancel.is_set(): raise CancelledBeforeDispatch() response = client.call(path, payload) if not isinstance(response, dict) or response.get("resCode", 0) not in (0, "0"): raise ValueError("游戏接口未返回可信的成功响应") if require_code and not (type(response.get("resCode")) is int and response["resCode"] == 0 or type(response.get("resCode")) is str and response["resCode"] == "0"): raise ValueError("隐藏关卡写请求缺少明确成功回包,保留待核对且禁止重发") return response def _record(self, client, record, stage, win, *, cancel=None): phase = record["phase"] self.journal.update(record, "record_pending", record_dispatched=True, record_result=win) try: response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel, require_code=record.get("battle_kind") == "hidden") except CancelledBeforeDispatch: self.journal.update(record, phase, record_dispatched=False) raise except Exception: self.journal.update(record, "record_unknown", message="战果记录未确认,不能重放战斗") raise self.journal.update(record, "record_acknowledged", record_confirmed=True, record_response=gameplay_response(response)) def _unknown(self, record, message, **fields): phase = "record_unknown" if record["phase"] == "record_unknown" else "unknown" self.journal.update(record, phase, message=message, **fields) return message