From 0ec95bbe65e9074769bb5e3569f6afb832202f07 Mon Sep 17 00:00:00 2001 From: AttilaNet Date: Sun, 8 Nov 2026 20:21:35 +0800 Subject: [PATCH] Automatically reconcile and resume interrupted task battle clock waits --- README.md | 2 +- ranch_assistant/README.md | 2 + ranch_assistant/battles.py | 78 +++++++++++++++- ranch_assistant/engine.py | 39 +++++++- ranch_assistant/gui.py | 2 + .../tests/test_battle_orchestration.py | 89 +++++++++++++++++++ 6 files changed, 206 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index fca3db1..03c2826 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ - **内置战斗模拟**:无需选择运行时,程序使用原始数值资料,在独立进程中计算 AP、出场、移动、攻击和部分技能,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和原版胜负不同,未支持的战斗会显示原因。 - **委托优先**:按奖励氪金数量20→15→10接取可处理的委托,优先执行委托步骤和材料补缺,再处理主线及普通牧场策略。缺少材料时使用现有扫荡/挑战来源;按委托缺口自动购买并孵化魔物蛋的联动留待后续实现。 - **地图与扫荡**:普通地图可能直接发放探索奖励,此时记录为奖励事件;进入战斗的分支才调用所选运行时。扫荡仍要求普通关卡三个难度全部通关。任务专属战斗和任务通关目标按任务路线处理,击杀缺口不靠扫荡计数。 -- **中断恢复**:请求结果不明、开战后停止或运行超时时,保留本账号的待核对记录,暂停冲突操作。恢复后先刷新角色与任务;仅在新状态足以确认结果时继续,不重放未知写请求。 +- **中断恢复**:后台最长每2分钟自动核对角色与任务。模型已完成、等待时长被中断且结算从未发出的记录,在策略开启后自动续交保存的胜利结果;不重新开战或模拟。已经发出但结果不明的写请求不重发,继续核对服务器状态。 详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);阶段证据及待验收事项见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。 diff --git a/ranch_assistant/README.md b/ranch_assistant/README.md index 82ae13b..0f83977 100644 --- a/ranch_assistant/README.md +++ b/ranch_assistant/README.md @@ -96,6 +96,8 @@ 5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略与战斗模式。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。 6. 在“战斗记录”查看上下文、队伍、胜负和原因;“刷新本地记录”只读取本机记录。点击顶部红色“停止”可取消后续推进和可取消的运行/时钟等待;已经发出的请求仍须等待确认,开战后的未知状态会保留待核对记录。 +有待核对记录时,后台最长每2分钟刷新服务器状态,无需手动核对。若是模型已完成、仅等待战斗时长时被中断,开启对应策略后会自动续交原先保存的胜利结果,保持同一任务实例与步骤,不重新发起入场请求或模拟;旧版记录也可恢复。关闭策略时只查询状态,不续交。结算请求已发出但结果未知时只自动查询,不重复发送;没有足够服务器证据时仍会显示等待原因。 + | 能力 | 当前开发版行为与边界 | | --- | --- | | 任务与对话 | 已实现接取、已支持线性对话、满足条件后的交付、领奖、后继接取与任务补链。服务器确认步骤后,才完成后续剧情和本地步骤收尾;本地检查点按账号/角色保存。 | diff --git a/ranch_assistant/battles.py b/ranch_assistant/battles.py index 559503c..9a47e53 100644 --- a/ranch_assistant/battles.py +++ b/ranch_assistant/battles.py @@ -436,9 +436,10 @@ class BattleOrchestrator: if duration is None: self._unknown(record, "模型未提供有效战斗时钟,未提交结算") return False - self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=duration, - message="等待已计算的战斗时钟;可以停止,停止后保留待核对记录") deadline = started + duration + 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: @@ -448,6 +449,79 @@ class BattleOrchestrator: self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对") 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): if not self.journal.lock.acquire(blocking=False): return "同账号已有任务 / 战斗正在执行" diff --git a/ranch_assistant/engine.py b/ranch_assistant/engine.py index 46b55fe..f93e25b 100644 --- a/ranch_assistant/engine.py +++ b/ranch_assistant/engine.py @@ -62,6 +62,7 @@ class Engine: self.demo = client is None self.auto = False self.last_heartbeat = 0 + self.last_pending_check = 0 self.heartbeat_enabled = True self.purchase_budget = PurchaseBudget(budget_path) self.last_draw = "" @@ -123,7 +124,7 @@ class Engine: def _require_no_battle(self): if self._progression_pending(): - raise ValueError("有待核对的任务 / 战斗,已暂停牧场、赠礼和任务写操作;请先刷新核对") + raise ValueError("有待核对的任务 / 战斗,已暂停冲突写操作;后台每2分钟自动核对") def _ensure_progression(self): if self.game_data is None: @@ -284,6 +285,27 @@ class Engine: 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): try: if self._is_commission(intent) and not self.quest_policy.battle_tasks: @@ -510,7 +532,10 @@ class Engine: else: message = self._execute_task_intent(intent) 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() if not self._progression_cancel.is_set(): self.read_snapshot(sync_master=False) @@ -568,6 +593,8 @@ class Engine: @account_serial def read_snapshot(self, *, sync_master=True): + if self._progression_pending(): + self.last_pending_check = time.monotonic() self.snapshot = self.client.snapshot() self.battle_journal.reconcile(self.snapshot, trusted=True) self.master_sync.apply(self.snapshot) @@ -713,8 +740,14 @@ class Engine: self._refresh_progression_cache() if self._progression_pending(): 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 {} - return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作") + return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作") + ";后台每2分钟自动核对" try: plans = self.plans() except (ValueError, TypeError, KeyError, AttributeError) as error: diff --git a/ranch_assistant/gui.py b/ranch_assistant/gui.py index 6ca6bb5..44e42b4 100644 --- a/ranch_assistant/gui.py +++ b/ranch_assistant/gui.py @@ -1581,6 +1581,8 @@ class Window(ProgressionPages, ActivityPages, W.QMainWindow): now = time.monotonic() if not self.engine.demo and self.engine.heartbeat_enabled and now - self.engine.last_heartbeat >= 240: 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(): self.submit("master_sync", self.engine.sync_master) elif not self.engine.demo and self.engine.heartbeat_enabled and self.engine.growth_sync_due(): diff --git a/ranch_assistant/tests/test_battle_orchestration.py b/ranch_assistant/tests/test_battle_orchestration.py index afad980..d29c218 100644 --- a/ranch_assistant/tests/test_battle_orchestration.py +++ b/ranch_assistant/tests/test_battle_orchestration.py @@ -804,6 +804,95 @@ class EngineProgressionTests(unittest.TestCase): mid = int(self.raw["monsters"][0]["id"]) 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): self.battle_task() runtime = Runtime(supported=False)