Automatically reconcile and resume interrupted task battle clock waits
This commit is contained in:
@@ -45,7 +45,7 @@
|
||||
- **内置战斗模拟**:无需选择运行时,程序使用原始数值资料,在独立进程中计算 AP、出场、移动、攻击和部分技能,等待计算出的战斗时长后提交结果。模型仍有机制近似与遗漏,可能和原版胜负不同,未支持的战斗会显示原因。
|
||||
- **委托优先**:按奖励氪金数量20→15→10接取可处理的委托,优先执行委托步骤和材料补缺,再处理主线及普通牧场策略。缺少材料时使用现有扫荡/挑战来源;按委托缺口自动购买并孵化魔物蛋的联动留待后续实现。
|
||||
- **地图与扫荡**:普通地图可能直接发放探索奖励,此时记录为奖励事件;进入战斗的分支才调用所选运行时。扫荡仍要求普通关卡三个难度全部通关。任务专属战斗和任务通关目标按任务路线处理,击杀缺口不靠扫荡计数。
|
||||
- **中断恢复**:请求结果不明、开战后停止或运行超时时,保留本账号的待核对记录,暂停冲突操作。恢复后先刷新角色与任务;仅在新状态足以确认结果时继续,不重放未知写请求。
|
||||
- **中断恢复**:后台最长每2分钟自动核对角色与任务。模型已完成、等待时长被中断且结算从未发出的记录,在策略开启后自动续交保存的胜利结果;不重新开战或模拟。已经发出但结果不明的写请求不重发,继续核对服务器状态。
|
||||
|
||||
详细设置、能力限制与恢复方法见[辅助使用说明](ranch_assistant/README.md#v12-自动主线与战斗设置);阶段证据及待验收事项见[v1.2 实施与交接](analysis/V1_2_IMPLEMENTATION.md)。当前仍为开发版,尚未发布 v1.2 正式标签。
|
||||
|
||||
|
||||
@@ -96,6 +96,8 @@
|
||||
5. 勾选“启用自动主线策略”,再点击顶部绿色“开启”。修改规则会自动保存并应用;菜单“策略配置”可立即保存、导入或导出当前账号规则,包含任务策略与战斗模式。重启、恢复会话和导入后,顶部策略开关保持关闭,核对后再开启。
|
||||
6. 在“战斗记录”查看上下文、队伍、胜负和原因;“刷新本地记录”只读取本机记录。点击顶部红色“停止”可取消后续推进和可取消的运行/时钟等待;已经发出的请求仍须等待确认,开战后的未知状态会保留待核对记录。
|
||||
|
||||
有待核对记录时,后台最长每2分钟刷新服务器状态,无需手动核对。若是模型已完成、仅等待战斗时长时被中断,开启对应策略后会自动续交原先保存的胜利结果,保持同一任务实例与步骤,不重新发起入场请求或模拟;旧版记录也可恢复。关闭策略时只查询状态,不续交。结算请求已发出但结果未知时只自动查询,不重复发送;没有足够服务器证据时仍会显示等待原因。
|
||||
|
||||
| 能力 | 当前开发版行为与边界 |
|
||||
| --- | --- |
|
||||
| 任务与对话 | 已实现接取、已支持线性对话、满足条件后的交付、领奖、后继接取与任务补链。服务器确认步骤后,才完成后续剧情和本地步骤收尾;本地检查点按账号/角色保存。 |
|
||||
|
||||
@@ -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 "同账号已有任务 / 战斗正在执行"
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user