fix: continue hidden sweep battles safely in Web 2.0.12

This commit is contained in:
AttilaNet
2026-11-14 12:41:11 +08:00
parent 7ca2ee13e3
commit 69b59e18dd
21 changed files with 1691 additions and 102 deletions
+275 -57
View File
@@ -30,7 +30,7 @@ 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 .sweeping import SweepPolicy, hidden_stage_id
from .team_availability import team_availability_reason
@@ -87,6 +87,8 @@ def gameplay_response(response):
_locks_guard = threading.Lock()
_locks = {}
SWEEP_KINDS = ("map_sweep", "sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep")
COMBAT_KINDS = ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle") + SWEEP_KINDS
def account_lock(path):
@@ -155,7 +157,7 @@ class BattleJournal:
self.reload()
return deepcopy(list(reversed(self.role(snapshot)["records"])))
def begin(self, snapshot, intent, *, kind=None):
def begin(self, snapshot, intent, *, kind=None, sweep_entry=None, sweep_phase=None):
if self.pending(snapshot):
raise ValueError("有待核对的任务 / 战斗,禁止重复开始")
record = {name: public_data(value(intent, name)) for name in (
@@ -170,6 +172,12 @@ class BattleJournal:
"loop_time": snapshot.raw.get("history", {}).get("loopTaskTime"),
"passed": stage_has_level(snapshot.raw.get("history", {}), "passStage",
value(intent, "stage_id", ""), value(intent, "difficulty", "1"))})
if sweep_entry is not None:
legacy_archive = sweep_phase == "legacy_hidden_archived" and sweep_entry.get("role_id") is None
if (not legacy_archive and str(sweep_entry.get("role_id")) != role_id(snapshot)) or not sweep_entry.get("sampleId"):
raise ValueError("扫荡交接角色或原始编号缺失")
record.update(sweep_sample_id=sweep_entry["sampleId"], sweep_entry=public_data(sweep_entry),
sweep_entry_digest=digest(public_data(sweep_entry)), phase=sweep_phase or record["phase"])
if value(intent, "token") and value(intent, "account_key"):
record.update(intent_id=value(intent, "token"), account_key=value(intent, "account_key"))
if record.get("source_task_type_id") and not record.get("source_task_id"):
@@ -190,9 +198,10 @@ class BattleJournal:
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":
shared_loss_budget = record.get("kind") != "map_battle" and not record.get("sweep_sample_id")
if outcome == "loss" and shared_loss_budget:
state["losses"] += 1
elif outcome == "win" and record.get("kind") != "map_battle":
elif outcome == "win" and shared_loss_budget:
state["losses"] = 0
self.save()
@@ -455,7 +464,11 @@ class BattleOrchestrator:
def save_combat_request(self, record, request):
if request.get("battle_mode") != "experimental":
return {}
if request.get("battle_kind") != "hidden":
return {}
combat = public_data(request)
return {"combat_request": combat, "combat_request_digest": digest(combat),
"combat_resource_digest": self.combat_resource_digest()}
from .battle_simulator import _transport_request
combat = public_data(_transport_request(request))
raw = combat.get("roster")
@@ -560,9 +573,12 @@ class BattleOrchestrator:
response = record.get("start_response")
task = bool(record.get("task_id"))
path = "battleService/battleStart" if task else "stageService/stageStart"
hidden = hidden_stage_id(response)
confirmed_hidden = (not task and hidden is not None and record.get("battle_kind") == "hidden"
and hidden == str(record.get("stage_id")) and str(record.get("difficulty")) == "1")
return (record.get("start_path") == path and isinstance(response, dict)
and response.get("resCode", 0) in (0, "0") and (task or response.get("triggerEvent") is False
or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0))
or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0 or confirmed_hidden))
@staticmethod
def source_matches(record, snapshot):
@@ -595,7 +611,7 @@ class BattleOrchestrator:
@staticmethod
def resumable_task_clock(record):
common = bool(record and record.get("kind") in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle")
common = bool(record and record.get("kind") in COMBAT_KINDS
and ((record.get("execution_mode") == "experimental" and record.get("execution_status") == "completed"
and record.get("experimental_settlement_eligible") is True and record.get("terminal") is True
and record.get("approximate") is True and record.get("faithful") is False)
@@ -628,7 +644,7 @@ class BattleOrchestrator:
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"):
if record.get("kind") not in COMBAT_KINDS:
return status("blocked", record.get("message") or "任务请求待核对,不能按战斗恢复")
if snapshot and str(record.get("role_id")) != role_id(snapshot):
return status("blocked", "角色与原入场记录不匹配,保留待核对记录")
@@ -650,6 +666,9 @@ class BattleOrchestrator:
return status("unsent", "开战请求尚未发送,可取消本地准备记录")
if not self.confirmed_start(record):
return status("blocked", "开战请求结果未确认,禁止重新入场或自动退出")
if (record.get("sweep_sample_id") and record.get("runtime_not_started") is True
and not record.get("combat_request") and self.hidden_sweep_inputs(record)):
return status("prepare_hidden_sweep", "隐藏入场及原始队伍已保存,可继续本次战斗")
interrupted = (record.get("runtime_not_started") is True or record.get("phase") in ("started", "running", "hidden_started") or
record.get("execution_status") in ("cancelled", "timed_out", "error"))
if not interrupted or record.get("battle_data"):
@@ -665,7 +684,8 @@ class BattleOrchestrator:
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")
if (record.get("battle_mode") != "experimental" and record.get("battle_kind") != "hidden"
or digest(combat) != record.get("combat_request_digest")
or self.combat_resource_digest() != record.get("combat_resource_digest")):
return status("blocked", "保存的原始战斗输入或资源校验不匹配,禁止改用当前属性重算")
return status("retry_local_runtime", "入场已确认且结算未发送,可用保存的原始输入恢复一次本地战斗")
@@ -728,7 +748,7 @@ class BattleOrchestrator:
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)
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, started, cancel):
return record["message"]
except Exception as error:
@@ -763,6 +783,7 @@ class BattleOrchestrator:
if self.observer:
self.observer("loss", intent, None)
self.journal.finish(snapshot, record, "loss", "打不过(保存的模拟结果);未提交胜利结算")
self._finish_hidden_sweep(snapshot, record)
return record["message"]
response = record.get("response") if record.get("settlement_confirmed") else None
if response is None:
@@ -771,9 +792,10 @@ class BattleOrchestrator:
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)
response = self._call(client, path, payload, cancel=cancel, require_code=record.get("battle_kind") == "hidden")
self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response),
settlement_confirmed=True, reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward"))
self._remember_hidden_sweep(snapshot, record)
if not task_battle and not record.get("record_confirmed"):
self._record(client, record, record["stage_id"], True, cancel=cancel)
if self.observer:
@@ -781,6 +803,7 @@ class BattleOrchestrator:
elif task_battle:
self.journal.checkpoint(snapshot, intent, response)
self.journal.finish(snapshot, record, "win", "已恢复此入场的战果并确认结算;未重新开战")
self._finish_hidden_sweep(snapshot, record)
return record["message"]
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
@@ -861,54 +884,15 @@ class BattleOrchestrator:
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)
request = self._hidden_request(record, snapshot, intent, policy, started)
if request is None:
return self._unknown(record, "隐藏关卡编号或原入场证据无效,等待核对")
supported, reason = self.inspect(request)
if not supported:
return self._unknown(record, "隐藏关卡待处理:" + reason)
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", runtime_not_started=False)
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, battle_started, cancel):
return record["message"]
data = record["battle_data"]
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, 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 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 + ",已确认对应结算"
return self._fight(client, snapshot, intent, request, record, battle_started, cancel)
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"],
@@ -918,6 +902,225 @@ class BattleOrchestrator:
self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__)
raise
def _hidden_request(self, record, snapshot, intent, policy, started):
hidden = hidden_stage_id(started)
if hidden is None:
return None
fields = asdict(intent) if is_dataclass(intent) else dict(intent) if isinstance(intent, dict) else vars(intent).copy()
fields.update(stage_id=hidden, difficulty="1", battle_kind="hidden")
# Preserve the source intent for policies/observers, and the actual
# hidden BattlePosition for every runtime/settlement/recovery path.
self.journal.update(record, "hidden_started",
parent_stage_id=record.get("parent_stage_id") or record["stage_id"],
parent_difficulty=record.get("parent_difficulty") or record["difficulty"],
stage_id=hidden, difficulty="1", battle_kind="hidden", runtime_not_started=True)
request = self.request(snapshot, fields, policy)
self.journal.update(record, "hidden_started", **self.save_combat_request(record, request),
team=policy.team, battle_mode=request.get("battle_mode", "original"))
return request
def _remember_hidden_sweep(self, snapshot, record):
if (self.sweeper is not None and record.get("sweep_sample_id")
and record.get("settlement_confirmed") is True):
self.sweeper.remember_map_reward(snapshot, record, record.get("response"))
self.sweeper.last_outcome = "hidden_win"
def _finish_hidden_sweep(self, snapshot, record):
if not self.sweeper or not record.get("sweep_sample_id") or record.get("outcome") not in ("win", "loss"):
return
if str(record.get("role_id")) != role_id(snapshot):
return
self._remember_hidden_sweep(snapshot, record)
self.sweeper.last_outcome = "hidden_" + record["outcome"]
def handoff_sweep(self, snapshot):
"""Move a confirmed hidden entry into the journal without a game write."""
if self.sweeper is None:
return None
with self.journal.lock:
self.journal.reload()
pending = self.sweeper.state.get("pending")
if not isinstance(pending, dict):
return None
hidden = hidden_stage_id(pending.get("start_response"))
if (not hidden or pending.get("hidden_stage_id") not in (None, hidden)
or str(pending.get("role_id")) != role_id(snapshot)
or pending.get("start_confirmed") is not True
or pending.get("start_path") != "stageService/stageStart"
or pending.get("phase") not in ("hidden_started", "开始请求待确认") or not pending.get("sampleId")):
return None
if pending.get("phase") != "hidden_started" or pending.get("hidden_stage_id") is None:
pending.update(phase="hidden_started", hidden_stage_id=hidden)
self.sweeper.save()
record = self.journal.pending(snapshot)
completed = next((row for row in self.journal.role(snapshot)["records"]
if row.get("sweep_sample_id") == pending["sampleId"] and row.get("phase") == "done"), None)
if completed:
if (record or completed.get("sweep_entry") != pending or completed.get("outcome") not in ("win", "loss")
or completed.get("record_confirmed") is not True
or completed.get("outcome") == "win" and completed.get("settlement_confirmed") is not True):
return None
self._finish_hidden_sweep(snapshot, completed)
self.sweeper.state["pending"] = None
self.sweeper.save()
return completed
install = not record or record.get("sweep_sample_id") != pending["sampleId"]
origin = pending.get("origin") or ({name: record.get(name) for name in ("kind", "stage_id", "difficulty",
"battle_kind", "task_id", "task_type_id", "step_number", "source_task_id", "source_task_type_id", "source_step_number",
"battle_mode")} if record else {"kind": "map_sweep", "stage_id": pending["stage"],
"difficulty": str(pending["level"]), "battle_kind": "sweep"})
if record and record.get("sweep_sample_id") == pending["sampleId"]:
if record.get("sweep_entry") != pending:
return None
install = record.get("phase") == "prepared" and not record.get("start_dispatched")
else:
if record:
if (record.get("kind") not in SWEEP_KINDS or record.get("sweep_sample_id")
or str(record.get("stage_id")) != str(pending["stage"])
or str(record.get("difficulty")) != str(pending["level"])
or record.get("phase") not in ("prepared", "sweep_pending", "unknown")
or record.get("start_dispatched") or record.get("settlement_dispatched") or record.get("record_dispatched")):
return None
else:
record = self.journal.begin(snapshot, origin, sweep_entry=pending)
if install:
self.journal.update(record, "hidden_started", sweep_sample_id=pending["sampleId"],
sweep_entry=deepcopy(pending), parent_stage_id=str(pending["stage"]), parent_difficulty=str(pending["level"]),
stage_id=hidden, difficulty="1", battle_kind="hidden", team=pending.get("team") or "teamA",
battle_mode=origin.get("battle_mode", "experimental"), start_path=pending["start_path"],
path=pending["start_path"], start_response=pending["start_response"], start_confirmed=True,
start_confirmed_at=pending.get("start_confirmed_at"), start_dispatched=True,
runtime_not_started=True, settlement_dispatched=False, record_dispatched=False,
sweep_entry_digest=digest(pending))
# The journal now owns both the response and original inputs. This
# also lets the existing Web Start gate use battle recovery.
self.sweeper.state["pending"] = None
self.sweeper.save()
return record
def archive_cancelled_sweep(self, snapshot):
"""Release only an explicitly cancelled, never-settled sweep entry."""
pending = self.sweeper.state.get("pending") if self.sweeper else None
if not isinstance(pending, dict) or pending.get("phase") != "cancelled_before_sweep_settlement":
return ""
response = pending.get("start_response") or {}
flag = response.get("triggerEvent")
if (pending.get("role_id") != role_id(snapshot) or pending.get("start_confirmed") is not True
or pending.get("start_path") != "stageService/stageStart" or pending.get("settlement_dispatched") is not False
or pending.get("record_dispatched") is not False or hidden_stage_id(response) is not None
or not (flag is False or type(flag) is int and flag == 0)
or response.get("resCode", 0) not in (0, "0") or not pending.get("sampleId")):
return ""
with self.journal.lock:
self.journal.reload()
record = self.journal.pending(snapshot)
if record and (record.get("kind") not in SWEEP_KINDS
or str(record.get("stage_id")) != str(pending["stage"])
or str(record.get("difficulty")) != str(pending["level"])
or record.get("settlement_dispatched") or record.get("record_dispatched")
or record.get("phase") not in ("sweep_pending", "unknown", "cancelled_sweep_archived")):
return ""
done = next((row for row in self.journal.role(snapshot)["records"]
if row.get("sweep_sample_id") == pending["sampleId"] and row.get("sweep_entry") == pending
and row.get("outcome") == "abandoned_cancelled_sweep"), None)
message = "扫荡入场已确认,结算尚未发送,停止后已本地放弃;未结算奖励"
if done is None:
record = record or self.journal.begin(snapshot, pending.get("origin") or {
"kind": "map_sweep", "stage_id": pending["stage"], "difficulty": pending["level"]},
sweep_entry=pending, sweep_phase="cancelled_sweep_archived")
self.journal.update(record, "cancelled_sweep_archived", sweep_sample_id=pending["sampleId"],
sweep_entry=deepcopy(pending), archival_evidence={"role_id": role_id(snapshot), "snapshot_read_at": time.time(),
"settlement_never_dispatched": True})
self.journal.finish(snapshot, record, "abandoned_cancelled_sweep", message)
self.sweeper.state["pending"] = None
self.sweeper.save()
return message
@staticmethod
def hidden_sweep_inputs(record):
entry = record.get("sweep_entry") or {}
raw = entry.get("entry_snapshot")
return (record.get("sweep_sample_id") and entry.get("sampleId") == record["sweep_sample_id"]
and digest(entry) == record.get("sweep_entry_digest") and isinstance(raw, dict)
and str((raw.get("master") or {}).get("id")) == str(record.get("role_id"))
and entry.get("team") == record.get("team") and hidden_stage_id(entry.get("start_response")) == record.get("stage_id"))
def continue_sweep(self, client, snapshot, policy, *, cancel=None):
"""Complete an already entered hidden sweep; never dispatch stageStart."""
cancel = cancel or threading.Event()
with self.journal.lock:
self.handoff_sweep(snapshot)
record = self.journal.pending(snapshot)
if not record or not record.get("sweep_sample_id") or not policy.enabled or cancel.is_set():
return ""
status = self.recovery_status(record, snapshot=snapshot)
if not status["resumable"]:
return status["message"]
intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number", "stage_category",
"stage_id", "difficulty", "battle_kind", "team", "source_task_id", "source_task_type_id", "source_step_number")}
if status["state"] != "prepare_hidden_sweep":
return self.resume_task_clock(client, snapshot, intent, policy, cancel=cancel)
entry = record["sweep_entry"]
original = SimpleNamespace(raw=deepcopy(entry["entry_snapshot"]), now=entry.get("entry_snapshot_now", snapshot.now))
chosen = SimpleNamespace(**(vars(policy) | {"team": record["team"], "battle_mode": record["battle_mode"]}))
try:
request = self._hidden_request(record, original, intent, chosen, record["start_response"])
supported, reason = self.inspect(request)
if not supported:
return self._unknown(record, "隐藏关卡待处理:" + reason)
return self._fight(client, snapshot, intent, request, record, self.clock(), cancel)
except CancelledBeforeDispatch:
if not record.get("settlement_confirmed"):
self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"],
settlement_dispatched=False, resume_clock_ready=True)
return "策略已停止,隐藏战果已保存,等待重新开启来源策略"
except Exception as error:
self._unknown(record, "隐藏关卡结果未确认,保留原入场且禁止重发写请求", error_type=type(error).__name__)
raise
def _fight(self, client, snapshot, intent, request, record, battle_started, cancel):
if cancel.is_set():
return self._unknown(record, "开战后已取消,等待服务器状态核对")
self.journal.update(record, "running", runtime_not_started=False)
result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel)
if not self.accept_runtime_result(record, request, result, battle_started, cancel):
return record["message"]
data = record["battle_data"]
mode = request.get("battle_mode", "original")
if not data["win"]:
if not value(intent, "task_id") or value(intent, "battle_kind") == "passStage":
self._record(client, record, request["stage_id"], False, cancel=cancel)
if self.observer:
self.observer("loss", intent, None)
label = "实验模型战败(近似)" if mode == "experimental" else "实际战败"
self.journal.finish(snapshot, record, "loss", label + ";未提交胜利结算或推进任务")
self._finish_hidden_sweep(snapshot, record)
return label + ";已停止此轮任务推进"
if value(intent, "task_id"):
path, payload = "taskService/taskCompleteStep", {"taskId": int(value(intent, "task_id")),
"taskTypeId": str(value(intent, "task_type_id")), "removeIds": None, "battleData": data}
else:
path, payload = "battleService/battleEnd", {"battleData": data}
self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True)
response = self._call(client, path, payload, cancel=cancel, require_code=record.get("battle_kind") == "hidden")
self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True,
reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward"))
self._remember_hidden_sweep(snapshot, record)
if value(intent, "task_id"):
if self.observer:
self.observer("settled", intent, response)
else:
self.journal.checkpoint(snapshot, intent, response)
else:
self._record(client, record, request["stage_id"], True,
cancel=None if value(intent, "kind") == "map_battle" else cancel)
if self.observer:
self.observer("settled", intent, response)
label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利"
self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对")
self._finish_hidden_sweep(snapshot, record)
return label + ",已确认对应结算"
def _sweep(self, client, snapshot, intent, policy, cancel):
if not policy.allow_sweep or self.sweeper is None or value(intent, "task_id"):
return "任务战斗或当前策略不允许普通扫荡"
@@ -927,6 +1130,10 @@ class BattleOrchestrator:
return "仅三个难度全通且客户端允许的普通关卡可扫荡"
if cancel.is_set():
return "扫荡已取消,未开始"
origin = {name: public_data(value(intent, name)) for name in ("kind", "task_id", "task_type_id", "step_number",
"stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number")}
origin["battle_mode"] = value(policy, "battle_mode", "experimental")
battle_policy = policy
policy = SweepPolicy(enabled=True, team=policy.team, keep_stamina=policy.reserve_ti,
rules={stage.stage_id: {"enabled": True, "level": stage.level, "limit": self.sweeper.used(snapshot, stage) + 1}})
record = self.journal.begin(snapshot, intent)
@@ -934,29 +1141,40 @@ class BattleOrchestrator:
try:
if self.observer:
self.observer("started", intent, None)
response = self.sweeper.run(client, snapshot, stage, policy)
response = self.sweeper.run(client, snapshot, stage, policy, cancel=cancel, origin=origin)
if self.sweeper.last_outcome == "hidden":
return self.continue_sweep(client, snapshot, battle_policy, cancel=cancel)
if self.observer:
self.observer("event" if self.sweeper.last_outcome == "event" else "settled", intent, response)
self.journal.finish(snapshot, record, "event" if self.sweeper.last_outcome == "event" else "sweep", "复用客户端已有扫荡路径")
return "探索奖励事件已结算" if self.sweeper.last_outcome == "event" else "扫荡已完成"
except CancelledBeforeDispatch:
if self.sweeper.state.get("pending") is None:
self.journal.finish(snapshot, record, "cancelled", "扫荡入场尚未发送,已取消")
return "扫荡已停止,已保留未确认记录"
except Exception as error:
record = self.journal.pending(snapshot) or record
self._unknown(record, "扫荡结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
@staticmethod
def _call(client, path, payload, *, cancel=None):
def _call(client, path, payload, *, cancel=None, require_code=False):
if cancel is not None and cancel.is_set():
raise CancelledBeforeDispatch()
response = client.call(path, payload)
if not isinstance(response, dict) or response.get("resCode", 0) not in (0, "0"):
raise ValueError("游戏接口未返回可信的成功响应")
if require_code and not (type(response.get("resCode")) is int and response["resCode"] == 0
or type(response.get("resCode")) is str and response["resCode"] == "0"):
raise ValueError("隐藏关卡写请求缺少明确成功回包,保留待核对且禁止重发")
return response
def _record(self, client, record, stage, win, *, cancel=None):
phase = record["phase"]
self.journal.update(record, "record_pending", record_dispatched=True, record_result=win)
try:
response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel)
response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)},
cancel=cancel, require_code=record.get("battle_kind") == "hidden")
except CancelledBeforeDispatch:
self.journal.update(record, phase, record_dispatched=False)
raise