1190 lines
76 KiB
Python
1190 lines
76 KiB
Python
"""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
|
|
|
|
|
|
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 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
|
|
elif outcome == "win" and shared_loss_budget:
|
|
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", "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 "该任务步骤已有确认记录,等待剧情 / 服务器步骤核对"
|
|
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"):
|
|
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
|