fix: recover interrupted Web battles in 2.0.10

This commit is contained in:
AttilaNet
2026-11-14 10:56:43 +08:00
parent bbdf578c87
commit 9f3945a717
24 changed files with 1912 additions and 127 deletions
+268 -49
View File
@@ -172,6 +172,9 @@ class BattleJournal:
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"))
if record.get("source_task_type_id") and not record.get("source_task_id"):
from .progression import ProgressionPlanner
record["source_offer_day"] = ProgressionPlanner._loop_day(snapshot, snapshot.now - 10)
state = self.role(snapshot)
state["records"].append(record)
state["pending"] = record["attempt_id"]
@@ -428,7 +431,8 @@ class BattleOrchestrator:
"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")}}
"damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope",
"supported", "timeout_kind")}}
trace = value(result, "trace")
if trace is None:
trace = value(result, "events")
@@ -441,8 +445,88 @@ class BattleOrchestrator:
evidence["trace"] = public_data(trace)
return evidence
@staticmethod
def combat_resource_digest():
# Bind retries to the same combat tables and quick-model mathematics.
# Worker transport changes do not alter this contract.
root = Path(__file__).parent
return digest([hashlib.sha256(path.read_bytes()).hexdigest() for path in
(root / "data" / "combat_manifest.json", root / "battle_quick.py")])
def save_combat_request(self, record, request):
if request.get("battle_mode") != "experimental":
return {}
from .battle_simulator import _transport_request
combat = public_data(_transport_request(request))
raw = combat.get("roster")
if isinstance(raw, dict):
teams = [{key: row[key] for key in ("teamName", "teamType", "monsters") if key in row}
for row in raw.get("teams", []) if row.get("teamName") == combat["team"]]
for row in teams:
members = row.get("monsters") or []
if isinstance(members, str):
members = members.split(",")
# Preserve lineup order and empty slots; exploration helpers
# discard those slots and therefore cannot normalize combat.
row["monsters"] = [int(mid) if str(mid).strip() else 0 for mid in members]
ids = {str(mid) for row in teams for mid in row["monsters"]}
if not teams:
ids = set(combat["team"].split(","))
fields = {"id", "typeId", "level", "mode", "tpLevel", "feel", "upStar", "potentialLevel", "skin", "controller",
"skill_1", "skill_2", "skill_1_lv", "skill_2_lv", *["equip" + str(i) for i in range(1, 6)],
*[prefix + stat for prefix in ("g", "p") for stat in ("Atk", "Def", "Hp", "Dex")]}
raw["teams"] = teams
raw["monsters"] = [{key: val for key, val in row.items() if key in fields}
for row in raw.get("monsters", []) if str(row.get("id")) in ids]
raw["monsterAttributes"] = [row for row in raw.get("monsterAttributes", []) or [] if str(row.get("monsterId")) in ids]
combat["battle_mode"] = "experimental"
return {"combat_request": combat, "combat_request_digest": digest(combat),
"combat_resource_digest": self.combat_resource_digest()}
def accept_runtime_result(self, record, request, result, started, cancel):
mode = request.get("battle_mode", "original")
evidence = self.runtime_evidence(result, mode)
for key in ("damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope"):
if evidence.get(key) is None:
evidence.pop(key, None)
self.journal.update(record, "runtime_returned", runtime_outcome=value(result, "outcome"), **evidence)
outcome, data = value(result, "outcome"), value(result, "battle_data")
eligible = outcome in ("win", "loss")
if mode == "experimental":
eligible = (eligible and value(result, "experimental_settlement_eligible") is True
and value(result, "execution_mode") == "experimental" and value(result, "execution_status") == "completed"
and value(result, "supported") is True and value(result, "terminal") is True
and value(result, "approximate") is True and value(result, "faithful") is False
and not value(result, "anomalies") and not any(row.get("blocking") is True
for row in value(result, "diagnostics", []) or [] if isinstance(row, dict)))
else:
eligible = (eligible and value(result, "settlement_eligible") is True
and value(result, "faithful") is True and value(result, "approximate") is not True)
if not eligible or not isinstance(data, dict) or type(data.get("win")) is not bool:
message = ("本地战斗运行超时,已入场但尚无战果,等待恢复核对" if value(result, "execution_status") == "timed_out"
else "战斗已取消、超时或结果不确定,等待核对")
self._unknown(record, message)
return False
if data["win"] != (outcome == "win"):
self._unknown(record, "运行结果与战果胜负不一致,未提交结算")
return False
position = data.get("battlePosition")
if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None}
!= {k: v for k, v in request["battle_position"].items() if v is not None}):
self._unknown(record, "运行时战果定位不匹配,未提交结算")
return False
# A generation cancellation does not invalidate an already computed result.
self.journal.update(record, "runtime_complete", battle_data=data)
ready = self.wait_for_battle_clock(record, request, result, data, started, cancel)
if cancel.is_set():
self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对")
return False
return ready
def wait_for_battle_clock(self, record, request, result, data, started, cancel):
if value(result, "requires_realtime_wait") is not True:
self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=0,
battle_ready_at=time.time(), resume_clock_ready=True)
return True
duration = None
for field, scale in (("model_elapsed_ms", .001), ("battle_elapsed_ms", .001), ("elapsed_ms", .001),
@@ -471,39 +555,154 @@ class BattleOrchestrator:
self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对")
return False
@staticmethod
def confirmed_start(record):
response = record.get("start_response")
task = bool(record.get("task_id"))
path = "battleService/battleStart" if task else "stageService/stageStart"
return (record.get("start_path") == path and isinstance(response, dict)
and response.get("resCode", 0) in (0, "0") and (task or response.get("triggerEvent") is False
or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0))
@staticmethod
def source_matches(record, snapshot):
if not record.get("source_task_type_id"):
return True
if not record.get("source_task_id") and not record.get("source_step_number"):
from .progression import ProgressionPlanner
history = snapshot.raw.get("history", {})
offers = history.get("loopTask") or {}
today = ProgressionPlanner._loop_day(snapshot, snapshot.now - 10)
return (record.get("source_offer_day") == today and history.get("loopTaskTime") is not None
and ProgressionPlanner._loop_day(snapshot, history["loopTaskTime"]) == today
and isinstance(offers, dict) and any(str(key) == str(record["source_task_type_id"])
for rows in offers.values() if isinstance(rows, (list, tuple)) for key in rows)
and not any(str(task.get("typeId")) == str(record["source_task_type_id"])
for task in snapshot.raw.get("currentTasks", [])))
return any(str(task.get("id")) == str(record.get("source_task_id"))
and str(task.get("typeId")) == str(record["source_task_type_id"])
and str(task.get("curStep")) == str(record.get("source_step_number"))
for task in snapshot.raw.get("currentTasks", []))
@staticmethod
def legacy_stage_failure(record):
return (record.get("kind") == "stage_battle" and not record.get("task_id")
and not record.get("task_type_id") and record.get("battle_kind") == "ordinary_stage"
and record.get("stage_category") in (None, "", "ordinary") and record.get("source_task_type_id")
and record.get("execution_mode") == "experimental" and record.get("terminal") is False
and record.get("terminal_reason") in ("worker_wall_clock_limit", "worker_cancelled", "worker_interrupted")
and record.get("execution_status") in ("cancelled", "timed_out") and not record.get("battle_data"))
@staticmethod
def resumable_task_clock(record):
common = bool(record and ((record.get("kind") == "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
common = bool(record and record.get("kind") in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle")
and ((record.get("execution_mode") == "experimental" and record.get("execution_status") == "completed"
and record.get("experimental_settlement_eligible") is True and record.get("terminal") is True
and record.get("approximate") is True and record.get("faithful") is False)
or (record.get("battle_mode") == "original" and record.get("settlement_eligible") is True
and record.get("faithful") is True and record.get("approximate") is not True))
and not record.get("anomalies") and not any(row.get("blocking") is True
for row in record.get("diagnostics") or [] if isinstance(row, dict))
and isinstance(record.get("battle_data"), dict) and type(record["battle_data"].get("win")) is bool)
if not common:
return False
if (record.get("kind") == "map_battle" and record.get("phase") == "settlement_acknowledged"
and record.get("settlement_confirmed") is True):
if record.get("phase") in ("record_pending", "record_unknown"):
return False
if not record.get("task_id") and record.get("settlement_confirmed") is True:
return (record["battle_data"]["win"] is True and isinstance(record.get("response"), dict)
and record["response"].get("resCode", 0) in (0, "0"))
return (record.get("phase") in ("unknown", "waiting_for_battle_clock")
and record["response"].get("resCode", 0) in (0, "0")
and (not record.get("record_dispatched") or record.get("record_confirmed") is True))
return (record.get("phase") in ("unknown", "runtime_complete", "waiting_for_battle_clock", "record_acknowledged")
and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart")
and not record.get("settlement_confirmed") and not record.get("settlement_dispatched")
and (not record.get("record_dispatched") or record.get("record_confirmed") is True)
and (record.get("resume_clock_ready") is True or
record.get("phase") == "runtime_complete" or
record.get("message") == "等待战斗时钟期间已取消,开战记录保留待核对"))
def recovery_status(self, record, *, snapshot=None):
"""Read-only classification. Resumable never grants permission to write."""
def status(state, message=""):
return {"state": state, "resumable": state not in ("none", "blocked"), "message": message}
if not record:
return status("none")
if isinstance(snapshot, dict):
snapshot = SimpleNamespace(raw=snapshot, now=time.time())
if record.get("kind") not in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle"):
return status("blocked", record.get("message") or "任务请求待核对,不能按战斗恢复")
if snapshot and str(record.get("role_id")) != role_id(snapshot):
return status("blocked", "角色与原入场记录不匹配,保留待核对记录")
preaccept = not record.get("source_task_id") and not record.get("source_step_number")
source_matches = snapshot is None or self.source_matches(record, snapshot)
if (not source_matches
and not (preaccept and self.legacy_stage_failure(record))):
return status("blocked", "角色或来源委托步骤已变化,保留原战斗记录等待核对")
if record.get("abandon_requested") and record.get("record_confirmed") is True and record.get("record_result") is False:
return status("finish_abandonment", "失败退出已确认,等待完成本地记录")
if self.resumable_task_clock(record):
return status("resume_result", "完整战果已保存,可续交尚未发送的结果")
if record.get("phase") in ("record_pending", "record_unknown") or record.get("record_dispatched"):
return status("blocked", "战果记录请求已发送但结果未确认,禁止重复发送")
if record.get("settlement_dispatched") or record.get("settlement_confirmed") or record.get("path") not in (
"", None, "stageService/stageStart", "battleService/battleStart"):
return status("blocked", "结算请求可能已发送,等待服务器证据,禁止重复结算")
if record.get("phase") == "prepared" and record.get("start_dispatched") is False and not record.get("start_response"):
return status("unsent", "开战请求尚未发送,可取消本地准备记录")
if not self.confirmed_start(record):
return status("blocked", "开战请求结果未确认,禁止重新入场或自动退出")
interrupted = (record.get("runtime_not_started") is True or record.get("phase") in ("started", "running", "hidden_started") or
record.get("execution_status") in ("cancelled", "timed_out", "error"))
if not interrupted or record.get("battle_data"):
return status("blocked", "没有可验证的完整战果或安全恢复证据,保留待核对记录")
combat = record.get("combat_request")
if not isinstance(combat, dict):
# Original AIR: BattlePausePanel.yesEscapeHandler -> checkGameOver
# (run=True, winnerTeam=2) -> BattlePanel.showLose -> battleResult(false).
if self.legacy_stage_failure(record):
return status("abandon_stage", "旧记录缺少原始战斗输入,本地计算已超时或取消;开启后按原客户端退出协议记录失败,不推进任务")
return status("blocked", "旧记录缺少原始战斗输入,不能用当前属性重算;需要权威记录或原客户端退出核对")
if self.legacy_stage_failure(record) and (not source_matches or record.get("runtime_recovery_attempts", 0) >= 1):
return status("abandon_stage", "本地战斗未完成且来源委托已变化或恢复已用尽;开启后按原客户端退出协议记录失败")
if record.get("runtime_recovery_attempts", 0) >= 1:
return status("blocked", "本地战斗恢复已尝试一次仍未完成,保留入场记录等待核对")
if (record.get("battle_mode") != "experimental" or digest(combat) != record.get("combat_request_digest")
or self.combat_resource_digest() != record.get("combat_resource_digest")):
return status("blocked", "保存的原始战斗输入或资源校验不匹配,禁止改用当前属性重算")
return status("retry_local_runtime", "入场已确认且结算未发送,可用保存的原始输入恢复一次本地战斗")
def resume_task_clock(self, client, snapshot, intent, policy, *, cancel):
"""Resume an unsent result, or finish recording a confirmed map settlement."""
"""Recover this entry only; never replay start or an uncertain server write."""
with self.journal.lock:
self.journal.reload()
record = self.journal.pending(snapshot)
if not policy.enabled or cancel.is_set() or not self.resumable_task_clock(record):
recovery = self.recovery_status(record, snapshot=snapshot)
if not policy.enabled or cancel.is_set() or not recovery["resumable"]:
return ""
if str(record.get("role_id")) != str(role_id(snapshot)):
return ""
if any(str(record.get(key)) != str(value(intent, key)) for key in
("kind", "task_id", "task_type_id", "step_number")):
return ""
if not record.get("task_id") and any(str(record.get(key)) != str(value(intent, key)) for key in
("stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number")):
return ""
if recovery["state"] == "unsent":
if self.observer and (record.get("task_id") or record.get("map_roster_signature")):
self.observer("cancelled_before_start", intent, None)
self.journal.finish(snapshot, record, "cancelled", "已取消尚未发送的开战准备记录;未重新入场")
return record["message"]
if recovery["state"] in ("abandon_stage", "finish_abandonment"):
try:
if recovery["state"] == "abandon_stage":
self.journal.update(record, "abandon_pending", abandon_requested=True)
self._record(client, record, record["stage_id"], False, cancel=cancel)
self.journal.finish(snapshot, record, "abandoned", "已按原客户端退出协议确认失败;未提交胜利战果或推进来源委托")
return record["message"]
except CancelledBeforeDispatch:
return "策略已停止,失败退出请求尚未发送,保留原入场记录"
except Exception as error:
self._unknown(record, "失败退出请求结果未确认,禁止重复发送", error_type=type(error).__name__)
raise
task_battle = bool(record.get("task_id"))
if task_battle:
task = next((row for row in snapshot.raw.get("currentTasks", [])
@@ -516,6 +715,25 @@ class BattleOrchestrator:
"stageLevel": None if task_battle else str(record.get("difficulty")),
"taskTypeId": str(record["task_type_id"]) if task_battle else None,
"taskStep": int(record["step_number"]) - 1 if task_battle else 0}
if recovery["state"] == "retry_local_runtime":
request = deepcopy(record["combat_request"])
position = request.get("battle_position")
if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None}
!= {k: v for k, v in expected.items() if v is not None}
or request.get("team") != record.get("team")):
return "保存的原始战斗输入与入场定位不匹配,保留待核对记录"
supported, reason = self.inspect(request)
if not supported:
return "保存的原始战斗输入当前无法执行:" + reason
self.journal.update(record, "running", runtime_recovery_attempts=1, runtime_not_started=False)
try:
started = self.clock()
result = self.runtime.run(request, cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, started, cancel):
return record["message"]
except Exception as error:
self._unknown(record, "本地战斗恢复未完成,保留原入场记录", error_type=type(error).__name__)
raise
data = record["battle_data"]
position = data.get("battlePosition")
if not isinstance(position, dict) or {key: val for key, val in position.items() if val is not None} != {
@@ -524,6 +742,10 @@ class BattleOrchestrator:
ready = 0 if record.get("settlement_confirmed") else record.get("battle_ready_at")
if ready is None:
duration = record.get("battle_clock_seconds")
if duration is None and record.get("requires_realtime_wait") is not True:
duration = 0
if duration is None and type(record.get("elapsed_ms")) in (int, float):
duration = record["elapsed_ms"] / 1000
stamp = record.get("updated_at")
if any(type(number) not in (int, float) or not math.isfinite(number) or number < 0
for number in (duration, stamp)):
@@ -536,7 +758,7 @@ class BattleOrchestrator:
return "已核对保存的战果;尚未到结算时间,2分钟内自动复查"
try:
if not data["win"]:
if not task_battle or record.get("battle_kind") == "passStage":
if (not task_battle or record.get("battle_kind") == "passStage") and not record.get("record_confirmed"):
self._record(client, record, record["stage_id"], False, cancel=cancel)
if self.observer:
self.observer("loss", intent, None)
@@ -552,17 +774,18 @@ class BattleOrchestrator:
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 not task_battle and not record.get("record_confirmed"):
self._record(client, record, record["stage_id"], True, cancel=cancel)
if self.observer:
self.observer("settled", intent, response)
elif task_battle:
self.journal.checkpoint(snapshot, intent, response)
self.journal.finish(snapshot, record, "win", "已自动续交保存的战果;未重新开战或重新模拟")
self.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)
if not record.get("settlement_confirmed"):
self.journal.update(record, "waiting_for_battle_clock", path="battleService/battleStart" if task_battle else "stageService/stageStart",
settlement_dispatched=False, resume_clock_ready=True)
return "策略已停止,保存的战果将在重新开启后续交"
except Exception as error:
self._unknown(record, "续交请求结果未确认,将自动查询状态,不重复发送", error_type=type(error).__name__)
@@ -601,24 +824,31 @@ class BattleOrchestrator:
return "任务 / 战斗已取消,未开始"
record = self.journal.begin(snapshot, intent)
try:
self.journal.update(record, "prepared", start_dispatched=False)
if self.observer:
self.observer("started", intent, None)
if value(intent, "task_id"):
path, payload = "battleService/battleStart", {"battleType": "task", "taskTypeId": str(value(intent, "task_type_id"))}
else:
path, payload = "stageService/stageStart", {"stageTypeId": str(value(intent, "stage_id")), "stageLevel": str(value(intent, "difficulty", "1"))}
self.journal.update(record, "start_pending", start_path=path, input_digest=digest(public_data(request)),
self.journal.update(record, "start_pending",
**{key: val for key, val in self._inspection_evidence.items() if key not in ("battle_mode", "resource_identity")},
**self.save_combat_request(record, request),
path=path, start_path=path, start_dispatched=True, settlement_dispatched=False, record_dispatched=False,
input_digest=digest(public_data(request)),
team=policy.team, battle_mode=mode,
resource_identity=(request.get("original_data") or {}).get("manifest", {}).get("source"))
try:
started = self._call(client, path, payload, cancel=cancel)
except CancelledBeforeDispatch:
self.journal.update(record, "start_pending", start_dispatched=False)
if self.observer:
self.observer("cancelled_before_start", intent, None)
self.journal.finish(snapshot, record, "cancelled", "开战请求尚未发送,已取消;未消耗入场资源")
return record["message"]
battle_started = self.clock()
self.journal.update(record, "started", start_response=gameplay_response(started))
self.journal.update(record, "started", start_confirmed=True, start_confirmed_at=time.time(),
runtime_not_started=True, start_response=gameplay_response(started))
if not value(intent, "task_id"):
reward = event_reward(started)
if reward is not None:
@@ -638,38 +868,17 @@ class BattleOrchestrator:
supported, reason = self.inspect(request)
if not supported:
return self._unknown(record, "隐藏关卡待处理:" + reason)
self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1")
self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1",
**self.save_combat_request(record, request))
else:
return self._unknown(record, "探索事件或开战状态未知,等待核对")
if cancel.is_set():
return self._unknown(record, "开战后已取消,等待服务器状态核对")
self.journal.update(record, "running")
self.journal.update(record, "running", runtime_not_started=False)
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):
if not self.accept_runtime_result(record, request, result, battle_started, cancel):
return record["message"]
data = record["battle_data"]
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)
@@ -683,7 +892,7 @@ class BattleOrchestrator:
"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)
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"))
@@ -700,6 +909,11 @@ class BattleOrchestrator:
label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利"
self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对")
return label + ",已确认对应结算"
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"],
settlement_dispatched=False, resume_clock_ready=True)
return "策略已停止,保存的战果将在重新开启后续交"
except Exception as error:
self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__)
raise
@@ -739,12 +953,17 @@ class BattleOrchestrator:
return response
def _record(self, client, record, stage, win, *, cancel=None):
self.journal.update(record, "record_pending")
phase = record["phase"]
self.journal.update(record, "record_pending", record_dispatched=True, record_result=win)
try:
self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel)
response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel)
except CancelledBeforeDispatch:
self.journal.update(record, phase, record_dispatched=False)
raise
except Exception:
self.journal.update(record, "record_unknown", message="战果记录未确认,不能重放战斗")
raise
self.journal.update(record, "record_acknowledged", record_confirmed=True, record_response=gameplay_response(response))
def _unknown(self, record, message, **fields):
phase = "record_unknown" if record["phase"] == "record_unknown" else "unknown"