"""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 import hashlib import json import math import os from pathlib import Path import threading import time import uuid from .drop_statistics import event_reward from .maps import stages from .quests import indexed, stage_has_level from .sweeping import SweepPolicy from .team_availability import team_availability_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 = {} 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 records(self, snapshot): with self.lock: self.reload() return deepcopy(list(reversed(self.role(snapshot)["records"]))) def begin(self, snapshot, intent, *, kind=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", "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 value(intent, "token") and value(intent, "account_key"): record.update(intent_id=value(intent, "token"), account_key=value(intent, "account_key")) 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 if outcome == "loss" and record.get("kind") != "map_battle": state["losses"] += 1 elif outcome == "win" and record.get("kind") != "map_battle": state["losses"] = 0 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")}} 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 "该任务步骤已有确认记录,等待剧情 / 服务器步骤核对" limit = max(0, int(policy.stop_after_loss)) if limit and self.journal.role(snapshot)["losses"] >= limit: return "已达战败停止次数,请核对阵容后重置战败计数" 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"): 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 item in base.get("items") or []: key, count = str(item["typeId"]), int(item["num"]) 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 = sum(int(i.get("num") or 0) for i in snapshot.raw.get("items", []) if str(i.get("typeId")) == key and not i.get("lock") and not i.get("sysLock") and not i.get("feedLock")) 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")}} 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 def wait_for_battle_clock(self, record, request, result, data, started, cancel): if value(result, "requires_realtime_wait") is not 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 resumable_task_clock(record): common = bool(record and ((record.get("kind") == "progression_battle" and record.get("task_id")) or (record.get("kind") == "map_battle" and not record.get("task_id"))) 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 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("kind") == "map_battle" and record.get("phase") == "settlement_acknowledged" 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")) return (record.get("phase") in ("unknown", "waiting_for_battle_clock") and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart") and not record.get("settlement_confirmed") and not record.get("settlement_dispatched") and (record.get("resume_clock_ready") is True or record.get("message") == "等待战斗时钟期间已取消,开战记录保留待核对")) def resume_task_clock(self, client, snapshot, intent, policy, *, cancel): """Resume an unsent result, or finish recording a confirmed map settlement.""" with self.journal.lock: record = self.journal.pending(snapshot) if not policy.enabled or cancel.is_set() or not self.resumable_task_clock(record): 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 "" 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} 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") 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": self._record(client, record, record["stage_id"], False, cancel=cancel) if self.observer: self.observer("loss", intent, None) self.journal.finish(snapshot, record, "loss", "打不过(保存的模拟结果);未提交胜利结算") 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) 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")) if not task_battle: self._record(client, record, record["stage_id"], True) if self.observer: self.observer("settled", intent, response) elif task_battle: self.journal.checkpoint(snapshot, intent, response) self.journal.finish(snapshot, record, "win", "已自动续交保存的战果;未重新开战或重新模拟") return record["message"] except CancelledBeforeDispatch: 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: 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", start_path=path, 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: 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_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: hidden = str(event["hideStageId"]) 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") request = self.request(snapshot, fields, policy) supported, reason = self.inspect(request) if not supported: return self._unknown(record, "隐藏关卡待处理:" + reason) self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1") else: return self._unknown(record, "探索事件或开战状态未知,等待核对") if cancel.is_set(): return self._unknown(record, "开战后已取消,等待服务器状态核对") self.journal.update(record, "running") result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel) evidence = self.runtime_evidence(result, mode) self.journal.update(record, "runtime_returned", **evidence) if cancel.is_set() or value(result, "outcome") in ("cancelled", "cancel", "timeout", "unknown", "unsupported"): return self._unknown(record, "战斗已取消、超时或结果不确定,等待核对") data = value(result, "battle_data") eligible = value(result, "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")) 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: return self._unknown(record, "所选运行时未提供可结算的实际执行结果,未提交结算") if data["win"] != (value(result, "outcome") == "win"): return self._unknown(record, "运行结果与战果胜负不一致,未提交结算") 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}): return self._unknown(record, "运行时战果定位不匹配,未提交结算") # Keep all statistics and integrity records exactly as supplied. self.journal.update(record, "runtime_complete", battle_data=data) if not self.wait_for_battle_clock(record, request, result, data, battle_started, cancel): return record["message"] 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 + ";未提交胜利结算或推进任务") 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) response = self._call(client, path, payload, cancel=cancel) 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")) 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 + ",结算接口已确认;后续进度以服务器快照核对") return label + ",已确认对应结算" except Exception as error: self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__) raise 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 "扫荡已取消,未开始" 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) 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 Exception as error: self._unknown(record, "扫荡结果未确认,禁止自动重试", error_type=type(error).__name__) raise @staticmethod def _call(client, path, payload, *, cancel=None): 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("游戏接口未返回可信的成功响应") return response def _record(self, client, record, stage, win, *, cancel=None): self.journal.update(record, "record_pending") try: self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel) except Exception: self.journal.update(record, "record_unknown", message="战果记录未确认,不能重放战斗") raise 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