Add v1.2 development quest progression and experimental battle runtime
This commit is contained in:
@@ -0,0 +1,631 @@
|
||||
"""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
|
||||
|
||||
|
||||
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":
|
||||
state["losses"] += 1
|
||||
elif outcome == "win":
|
||||
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 "已达战败停止次数,请核对阵容后重置战败计数"
|
||||
teams = snapshot.raw.get("teams", [])
|
||||
team = next((t for t in teams if t.get("teamName") == policy.team and t.get("teamType") == "battleTeam"), {})
|
||||
ids = [int(mid) for mid in team.get("monsters", []) if mid and int(mid) > 0]
|
||||
if not ids or any(mid not in snapshot.monsters for mid in ids):
|
||||
return "所选战队无有效魔物或实例缺失"
|
||||
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 > 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
|
||||
self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=duration,
|
||||
message="等待已计算的战斗时钟;可以停止,停止后保留待核对记录")
|
||||
deadline = started + duration
|
||||
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
|
||||
|
||||
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=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
|
||||
Reference in New Issue
Block a user