Files
myrzx_bot/ranch_assistant/battles.py
T

753 lines
46 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
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", "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 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", "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")}}
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