Automatically reconcile and resume interrupted task battle clock waits

This commit is contained in:
AttilaNet
2026-11-08 20:21:35 +08:00
parent 001ed9d36d
commit 0ec95bbe65
6 changed files with 206 additions and 6 deletions
+1 -1
View File
@@ -45,7 +45,7 @@
- **内置战斗模拟**:无需选择运行时,程序使用原始数值资料,在独立进程中计算 AP、出场、移动、攻击和部分技能,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和原版胜负不同,未支持的战斗会显示原因。 - **内置战斗模拟**:无需选择运行时,程序使用原始数值资料,在独立进程中计算 AP、出场、移动、攻击和部分技能,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和原版胜负不同,未支持的战斗会显示原因。
- **委托优先**:按奖励氪金数量20→15→10接取可处理的委托,优先执行委托步骤和材料补缺,再处理主线及普通牧场策略。缺少材料时使用现有扫荡/挑战来源;按委托缺口自动购买并孵化魔物蛋的联动留待后续实现。 - **委托优先**:按奖励氪金数量20→15→10接取可处理的委托,优先执行委托步骤和材料补缺,再处理主线及普通牧场策略。缺少材料时使用现有扫荡/挑战来源;按委托缺口自动购买并孵化魔物蛋的联动留待后续实现。
- **地图与扫荡**:普通地图可能直接发放探索奖励,此时记录为奖励事件;进入战斗的分支才调用所选运行时。扫荡仍要求普通关卡三个难度全部通关。任务专属战斗和任务通关目标按任务路线处理,击杀缺口不靠扫荡计数。 - **地图与扫荡**:普通地图可能直接发放探索奖励,此时记录为奖励事件;进入战斗的分支才调用所选运行时。扫荡仍要求普通关卡三个难度全部通关。任务专属战斗和任务通关目标按任务路线处理,击杀缺口不靠扫荡计数。
- **中断恢复**:请求结果不明、开战后停止或运行超时时,保留本账号的待核对记录,暂停冲突操作。恢复后先刷新角色与任务;仅在新状态足以确认结果时继续,不重放未知写请求。 - **中断恢复**:后台最长每2分钟自动核对角色与任务。模型已完成、等待时长被中断且结算从未发出的记录,在策略开启后自动续交保存的胜利结果;不重新开战或模拟。已经发出但结果不明的写请求不重发,继续核对服务器状态。
详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);阶段证据及待验收事项见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。 详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);阶段证据及待验收事项见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。
+2
View File
@@ -96,6 +96,8 @@
5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略与战斗模式。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。 5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略与战斗模式。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。
6. 在“战斗记录”查看上下文、队伍、胜负和原因;“刷新本地记录”只读取本机记录。点击顶部红色“停止”可取消后续推进和可取消的运行/时钟等待;已经发出的请求仍须等待确认,开战后的未知状态会保留待核对记录。 6. 在“战斗记录”查看上下文、队伍、胜负和原因;“刷新本地记录”只读取本机记录。点击顶部红色“停止”可取消后续推进和可取消的运行/时钟等待;已经发出的请求仍须等待确认,开战后的未知状态会保留待核对记录。
有待核对记录时,后台最长每2分钟刷新服务器状态,无需手动核对。若是模型已完成、仅等待战斗时长时被中断,开启对应策略后会自动续交原先保存的胜利结果,保持同一任务实例与步骤,不重新发起入场请求或模拟;旧版记录也可恢复。关闭策略时只查询状态,不续交。结算请求已发出但结果未知时只自动查询,不重复发送;没有足够服务器证据时仍会显示等待原因。
| 能力 | 当前开发版行为与边界 | | 能力 | 当前开发版行为与边界 |
| --- | --- | | --- | --- |
| 任务与对话 | 已实现接取、已支持线性对话、满足条件后的交付、领奖、后继接取与任务补链。服务器确认步骤后,才完成后续剧情和本地步骤收尾;本地检查点按账号/角色保存。 | | 任务与对话 | 已实现接取、已支持线性对话、满足条件后的交付、领奖、后继接取与任务补链。服务器确认步骤后,才完成后续剧情和本地步骤收尾;本地检查点按账号/角色保存。 |
+76 -2
View File
@@ -436,9 +436,10 @@ class BattleOrchestrator:
if duration is None: if duration is None:
self._unknown(record, "模型未提供有效战斗时钟,未提交结算") self._unknown(record, "模型未提供有效战斗时钟,未提交结算")
return False return False
self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=duration,
message="等待已计算的战斗时钟;可以停止,停止后保留待核对记录")
deadline = started + duration 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(): while not cancel.is_set():
remaining = deadline - self.clock() remaining = deadline - self.clock()
if remaining <= 0: if remaining <= 0:
@@ -448,6 +449,79 @@ class BattleOrchestrator:
self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对") self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对")
return False return False
@staticmethod
def resumable_task_clock(record):
return bool(record and record.get("kind") == "progression_battle" and record.get("task_id")
and record.get("phase") in ("unknown", "waiting_for_battle_clock")
and record.get("path") in ("", "battleService/battleStart")
and not record.get("settlement_confirmed") and not record.get("settlement_dispatched")
and (record.get("resume_clock_ready") is True or
record.get("message") == "等待战斗时钟期间已取消,开战记录保留待核对")
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 record["battle_data"].get("win") is True)
def resume_task_clock(self, client, snapshot, intent, policy, *, cancel):
"""Continue a saved result only when no settlement was ever dispatched."""
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 = 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", "stageId": None, "stageLevel": None,
"taskTypeId": str(record["task_type_id"]), "taskStep": int(record["step_number"]) - 1}
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 = 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分钟内自动复查"
path = "taskService/taskCompleteStep"
payload = {"taskId": int(record["task_id"]), "taskTypeId": str(record["task_type_id"]),
"removeIds": None, "battleData": deepcopy(data)}
self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True)
try:
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 self.observer:
self.observer("settled", intent, response)
else:
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",
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): def run(self, client, snapshot, intent, policy, *, cancel=None, ranch=None):
if not self.journal.lock.acquire(blocking=False): if not self.journal.lock.acquire(blocking=False):
return "同账号已有任务 / 战斗正在执行" return "同账号已有任务 / 战斗正在执行"
+36 -3
View File
@@ -62,6 +62,7 @@ class Engine:
self.demo = client is None self.demo = client is None
self.auto = False self.auto = False
self.last_heartbeat = 0 self.last_heartbeat = 0
self.last_pending_check = 0
self.heartbeat_enabled = True self.heartbeat_enabled = True
self.purchase_budget = PurchaseBudget(budget_path) self.purchase_budget = PurchaseBudget(budget_path)
self.last_draw = "" self.last_draw = ""
@@ -123,7 +124,7 @@ class Engine:
def _require_no_battle(self): def _require_no_battle(self):
if self._progression_pending(): if self._progression_pending():
raise ValueError("有待核对的任务 / 战斗,已暂停牧场、赠礼和任务写操作;请先刷新核对") raise ValueError("有待核对的任务 / 战斗,已暂停冲突写操作;后台每2分钟自动核对")
def _ensure_progression(self): def _ensure_progression(self):
if self.game_data is None: if self.game_data is None:
@@ -284,6 +285,27 @@ class Engine:
self.battle_journal.finish(self.snapshot, record, "win" if battle else "task", self.battle_journal.finish(self.snapshot, record, "win" if battle else "task",
"已从持久化成功回包恢复本地任务检查点;未重发请求") "已从持久化成功回包恢复本地任务检查点;未重发请求")
def pending_recovery_due(self):
return not self.demo and bool(self._progression_pending()) and time.monotonic() - self.last_pending_check >= 120
def _resume_pending_task_clock(self):
record = self.battle_journal.pending(self.snapshot)
if not self.auto or self._progression_cancel.is_set() or not self.battles.resumable_task_clock(record):
return ""
pending = self.progression_planner.pending(self.snapshot) if self.progression_planner else None
if not pending or not isinstance(pending.get("intent"), dict):
return ""
intent = ProgressionIntent(**pending["intent"])
if (pending.get("token") != intent.token or intent.token != record.get("intent_id")
or intent.account_key != record.get("account_key")):
return ""
issued = self.progression_planner._issued
if intent.token in issued and issued[intent.token] != intent.to_dict():
return ""
issued[intent.token] = intent.to_dict()
return self.battles.resume_task_clock(self.client, self.snapshot, intent, self._intent_policy(intent),
cancel=self._progression_cancel)
def _battle_capability(self, intent): def _battle_capability(self, intent):
try: try:
if self._is_commission(intent) and not self.quest_policy.battle_tasks: if self._is_commission(intent) and not self.quest_policy.battle_tasks:
@@ -510,7 +532,10 @@ class Engine:
else: else:
message = self._execute_task_intent(intent) message = self._execute_task_intent(intent)
if self.battle_journal.pending(self.snapshot) and kind == "progression_battle": if self.battle_journal.pending(self.snapshot) and kind == "progression_battle":
self.progression_planner.mark_uncertain(self.snapshot, intent, "战斗待核对,禁止重放") record = self.battle_journal.pending(self.snapshot)
reason = ("战果已保存;后台每2分钟核对,开启策略后自动续交" if self.battles.resumable_task_clock(record)
else "战斗待核对;后台每2分钟查询服务器状态,禁止重复提交")
self.progression_planner.mark_uncertain(self.snapshot, intent, reason)
self._persist_progression() self._persist_progression()
if not self._progression_cancel.is_set(): if not self._progression_cancel.is_set():
self.read_snapshot(sync_master=False) self.read_snapshot(sync_master=False)
@@ -568,6 +593,8 @@ class Engine:
@account_serial @account_serial
def read_snapshot(self, *, sync_master=True): def read_snapshot(self, *, sync_master=True):
if self._progression_pending():
self.last_pending_check = time.monotonic()
self.snapshot = self.client.snapshot() self.snapshot = self.client.snapshot()
self.battle_journal.reconcile(self.snapshot, trusted=True) self.battle_journal.reconcile(self.snapshot, trusted=True)
self.master_sync.apply(self.snapshot) self.master_sync.apply(self.snapshot)
@@ -713,8 +740,14 @@ class Engine:
self._refresh_progression_cache() self._refresh_progression_cache()
if self._progression_pending(): if self._progression_pending():
self.pending_hatches = [] self.pending_hatches = []
recovered = self._resume_pending_task_clock() if not self.demo else ""
if recovered:
self.last_executed = True
if not self.battle_journal.pending(self.snapshot):
self.read_snapshot(sync_master=False)
return self.snapshot, self.plans(), recovered
pending = self.battle_journal.pending(self.snapshot) or {} pending = self.battle_journal.pending(self.snapshot) or {}
return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作") return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作") + ";后台每2分钟自动核对"
try: try:
plans = self.plans() plans = self.plans()
except (ValueError, TypeError, KeyError, AttributeError) as error: except (ValueError, TypeError, KeyError, AttributeError) as error:
+2
View File
@@ -1581,6 +1581,8 @@ class Window(ProgressionPages, ActivityPages, W.QMainWindow):
now = time.monotonic() now = time.monotonic()
if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240: if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240:
self.submit("heartbeat", self.engine.keep_alive) self.submit("heartbeat", self.engine.keep_alive)
elif not self.engine.demo and self.monitoring and self.engine.pending_recovery_due():
self.refresh(automated=True)
elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.master_sync_due(): elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.master_sync_due():
self.submit("master_sync", self.engine.sync_master) self.submit("master_sync", self.engine.sync_master)
elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.growth_sync_due(): elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.growth_sync_due():
@@ -804,6 +804,95 @@ class EngineProgressionTests(unittest.TestCase):
mid = int(self.raw["monsters"][0]["id"]) mid = int(self.raw["monsters"][0]["id"])
self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [mid]}] self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [mid]}]
def interrupted_model_wait(self):
self.battle_task()
runtime = ExperimentalRuntime()
original = runtime._run
runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | {
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
self.engine = self.make_engine(experimental_runtime=runtime)
self.engine.progression_policy.battle_mode = "experimental"
self.engine.battles.clock = lambda: 0
cancel = self.engine._progression_cancel
cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True)
self.engine.run_progression_once()
self.assertEqual([call.args[0] for call in self.client.call.call_args_list], ["battleService/battleStart"])
record = self.engine.battle_journal.pending(self.engine.snapshot)
self.assertIsNotNone(record)
cancel.clear()
return runtime, record
def test_poll_resumes_interrupted_clock_without_restarting_or_simulating_again(self):
runtime, record = self.interrupted_model_wait()
record["battle_ready_at"] = 1
self.engine.battle_journal.save()
self.engine.auto = True
self.engine.poll()
self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot))
self.assertIsNone(self.engine.progression_planner.pending(self.engine.snapshot))
self.assertEqual([call.args[0] for call in self.client.call.call_args_list],
["battleService/battleStart", "taskService/taskCompleteStep"])
self.assertEqual(runtime.run.call_count, 1)
def test_interrupted_clock_never_submits_while_stopped_or_before_deadline(self):
_, record = self.interrupted_model_wait()
record["battle_ready_at"] = 1
self.engine.battle_journal.save()
self.engine.poll()
self.assertEqual(self.client.call.call_count, 1)
self.engine.auto = True
record = self.engine.battle_journal.pending(self.engine.snapshot)
record["battle_ready_at"] = 10**12
self.engine.battle_journal.save()
self.engine.poll()
self.assertEqual(self.client.call.call_count, 1)
def test_uncertain_settlement_is_never_replayed_by_recovery(self):
_, record = self.interrupted_model_wait()
self.engine.battle_journal.update(record, "unknown", path="taskService/taskCompleteStep", battle_ready_at=1)
self.engine.auto = True
self.engine.poll()
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
self.assertEqual(self.client.call.call_count, 1)
def test_legacy_interrupted_clock_resumes_after_restart_without_new_battle(self):
runtime, record = self.interrupted_model_wait()
record.pop("resume_clock_ready", None)
record.pop("battle_ready_at", None)
record["battle_data"]["battlePosition"] = {
key: val for key, val in record["battle_data"]["battlePosition"].items() if val is not None}
record["updated_at"] = 1
self.engine.battle_journal.save()
restored = self.make_engine(experimental_runtime=runtime)
restored.progression_policy.battle_mode = "experimental"
restored.auto = True
restored.poll()
self.assertIsNone(restored.battle_journal.pending(restored.snapshot))
self.assertIsNone(restored.progression_planner.pending(restored.snapshot))
self.assertEqual(runtime.run.call_count, 1)
self.assertEqual([call.args[0] for call in self.client.call.call_args_list],
["battleService/battleStart", "taskService/taskCompleteStep"])
def test_pending_background_check_becomes_due_after_two_minutes(self):
self.interrupted_model_wait()
self.engine.last_pending_check = 100
with patch("ranch_assistant.engine.time.monotonic", return_value=219):
self.assertFalse(self.engine.pending_recovery_due())
with patch("ranch_assistant.engine.time.monotonic", return_value=220):
self.assertTrue(self.engine.pending_recovery_due())
def test_resumed_settlement_timeout_remains_query_only_on_later_polls(self):
_, record = self.interrupted_model_wait()
record["battle_ready_at"] = 1
self.engine.battle_journal.save()
self.engine.auto = True
self.client.call.side_effect = TimeoutError("synthetic lost reply")
with self.assertRaises(TimeoutError):
self.engine.poll()
self.engine.poll()
self.assertEqual(self.client.call.call_count, 2)
self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot))
def test_task_battle_capability_overlay_cannot_claim_config_is_runtime_support(self): def test_task_battle_capability_overlay_cannot_claim_config_is_runtime_support(self):
self.battle_task() self.battle_task()
runtime = Runtime(supported=False) runtime = Runtime(supported=False)