Isolate hatch, gift, exploration and breakthrough timers; cancel queued automation after settings change. Check battle readiness before local quest navigation and reject exploring teams or disabled sweeps before entry.
730 lines
44 KiB
Python
730 lines
44 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
|
|
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
|