Add v1.2 development quest progression and experimental battle runtime

This commit is contained in:
AttilaNet
2026-11-08 19:29:28 +08:00
parent 79b7672471
commit 0d3e231cde
71 changed files with 14349 additions and 172 deletions
+579 -7
View File
@@ -1,7 +1,10 @@
from __future__ import annotations
from copy import copy, deepcopy
from dataclasses import replace
from functools import wraps
import json
from pathlib import Path
import threading
import time
from .model import Action, Catalog, Planner, Policy, Snapshot, seconds
from .daily import DailyLedger, DailyPolicy, selected_entries
@@ -14,10 +17,37 @@ from .master_sync import MasterSync
from .stage_cache import StageCache
from .drop_statistics import reward_text
from .cultivation import CultivationSelector
from .battles import BattleJournal, BattleOrchestrator, CancelledBeforeDispatch, digest, gameplay_response, public_data, value
from .progression import ProgressionIntent, ProgressionPlanner, ProgressionPolicy
def account_serial(method):
"""Serialize whole operations, not just individual Client.call requests."""
@wraps(method)
def invoke(self, *args, **kwargs):
with self.battle_journal.lock:
return method(self, *args, **kwargs)
return invoke
def single_flight(method):
@wraps(method)
def invoke(self, *args, **kwargs):
generation = self._progression_cancel_generation
if not self.battle_journal.lock.acquire(blocking=False):
return self.snapshot, [], "同账号已有任务 / 战斗正在执行"
try:
with self._progression_cancel_lock:
if self.auto and generation == self._progression_cancel_generation and self._progression_cancel.is_set():
self._progression_cancel = threading.Event()
return method(self, *args, **kwargs)
finally:
self.battle_journal.lock.release()
return invoke
class Engine:
def __init__(self, catalog, client=None, budget_path=None):
def __init__(self, catalog, client=None, budget_path=None, *, game_data=None, battle_runtime=None, experimental_runtime=None):
self.catalog, self.client = catalog, client
folder = Path(budget_path).parent if budget_path else None
self.cultivation = CultivationSelector(catalog, folder / "cultivation_choices.json" if folder else None)
@@ -44,11 +74,500 @@ class Engine:
self.daily_ledger = DailyLedger(folder / "daily_claims.json" if folder else None)
self.sweep_policy = SweepPolicy()
self.sweeper = SweepRunner(catalog, folder / "sweep_runs.json" if folder else None)
self.progression_policy = ProgressionPolicy()
self.progression_view_active = False
self.progression_planner = None
self.game_data = game_data
self._progression_namespace = str(folder.resolve()) if folder else ""
self._progression_state_loaded = False
self._battle_catalog_ready = False
self.battle_journal = BattleJournal(folder / "progression" / "journal.json" if folder else None)
self.battles = BattleOrchestrator(catalog, self.battle_journal, battle_runtime, self.sweeper,
request_builder=self._battle_request, observer=self._battle_observer)
self._progression_cancel = threading.Event()
self._progression_cancel_lock = threading.Lock()
self._progression_cancel_generation = 0
self._progression_cache_key = None
self._progression_rows = []
self._progression_intents = []
self._commission_planner_available = False
self._commission_offer_reason = ""
self._progression_records = []
self._progression_error = ""
self._planner_pending = False
self._capability_cache = {}
self._battle_snapshot_source = None
self._battle_snapshot_digest = ""
self._battle_roster_digest = None
self._battle_roster = None
self._battle_runtimes = {"original": battle_runtime, "experimental": experimental_runtime}
self._selected_battle_mode = "original"
def cancel_progression(self):
"""Safe on Qt's thread while a worker is running; never waits or calls APIs."""
with self._progression_cancel_lock:
self.auto = False
self._progression_cancel_generation += 1
self._progression_cancel.set()
def progression_rows(self):
"""A cached view only. Full-table planning always runs in an account worker."""
return deepcopy(self._progression_rows)
def progression_records(self):
return deepcopy(self._progression_records)
def _progression_pending(self):
return self.snapshot is not None and (self.battle_journal.pending(self.snapshot)
or self.sweeper.state.get("pending") or self._planner_pending)
def _require_no_battle(self):
if self._progression_pending():
raise ValueError("有待核对的任务 / 战斗,已暂停牧场、赠礼和任务写操作;请先刷新核对")
def _ensure_progression(self):
if self.game_data is None:
from .game_data import load_progression_data
self.game_data = load_progression_data()
if self.progression_planner is None:
self.progression_planner = ProgressionPlanner(self.catalog, self.game_data, account_key=self._progression_namespace)
if not self._progression_state_loaded and self.snapshot is not None:
stored = deepcopy(self.battle_journal.role(self.snapshot).get("planner_state"))
if stored:
for account in stored.get("accounts", {}).values():
pending = account.get("pending")
if pending:
pending["token"] = pending.pop("intent_id", "")
pending["intent"]["token"] = pending["intent"].pop("intent_id", "")
self.progression_planner.restore_state(stored)
self._progression_state_loaded = True
# A separate view preserves the commission-only legacy catalog.
if not self._battle_catalog_ready:
battle_catalog = copy(self.catalog)
positions = dict(self.catalog.data.get("stage_task_positions", {}))
for key, task in self.game_data.tasks.items():
positions[str(key)] = [step.get("position", "") for step in task.get("steps", [])]
battle_catalog.data = self.catalog.data | {"stage_info": self.game_data.stages,
"stage_sp": self.game_data.stage_sp, "stage_task_positions": positions,
"game_setting": self.game_data.game_setting}
self.battles.catalog = battle_catalog
self._battle_catalog_ready = True
self._select_battle_runtime(self.progression_policy.battle_mode)
def _select_battle_runtime(self, mode):
if mode not in ("original", "experimental"):
raise ValueError("未知战斗模式,未开始战斗")
if self.battles.runtime is not None:
self._battle_runtimes[self._selected_battle_mode] = self.battles.runtime
self._selected_battle_mode = mode
runtime = self._battle_runtimes.get(mode)
if runtime is None:
try:
if mode == "experimental":
from .battle_simulator import ExperimentalBattleRuntime as Runtime
else:
from .battle_runtime import BattleRuntime as Runtime
except ImportError:
pass
else:
runtime = self._battle_runtimes[mode] = Runtime()
self.battles.runtime = runtime
def _persist_progression(self, *, save=True):
state = self.progression_planner.export_state()
self._planner_pending = any(account.get("pending") for account in state.get("accounts", {}).values())
for account in state.get("accounts", {}).values():
account["applied"] = account["applied"][-1000:]
account["received"] = {key: {field: task[field] for field in ("id", "typeId", "curStep", "stepValue") if field in task}
for key, task in account["received"].items()}
pending = account.get("pending")
if pending:
# These are planner-issued hashes, not authentication tokens.
# Store them under an unambiguous local name on disk.
pending["intent_id"] = pending.pop("token")
pending["intent"]["intent_id"] = pending["intent"].pop("token")
for task in account["tasks"].values():
cutoff = min(task.get("cursor", 0), task.get("server_step", 0))
for field in ("before", "after", "acknowledged"):
task[field] = [number for number in task.get(field, []) if number >= cutoff]
state = public_data(state)
target = self.battle_journal.role(self.snapshot)
if target.get("planner_state") != state:
target["planner_state"] = state
if save:
self.battle_journal.save()
def _battle_observer(self, event, intent, response):
farming = self._is_farm(intent)
if value(intent, "kind") != "progression_battle" and not farming:
return None
planner = self.progression_planner
if event == "cancelled_before_start":
self._cancel_unsent_progression(intent)
return None
if farming:
if event == "started":
planner.mark_started(self.snapshot, intent) # validates the issued ordinary intent only
# Farming is a normal map action. Its journal and fresh server
# snapshot govern the result; it never acknowledges a task step.
return None
if event == "validate":
account = planner.export_state().get("accounts", {}).get(intent.account_key, {})
task = account.get("tasks", {}).get(f"{intent.task_id}:{intent.task_type_id}", {})
return task.get("cursor") == intent.step_number
if event == "started":
planner.mark_started(self.snapshot, intent)
elif event in ("settled", "event"):
if not planner.acknowledge(self.snapshot, intent, gameplay_response(response)):
raise ValueError("任务战斗结算已返回,但任务步骤确认未完成")
elif event == "loss":
planner.battle_lost(self.snapshot, intent)
self._persist_progression()
def _cancel_unsent_progression(self, intent):
"""Rollback only the matching planner send marker, before dispatch."""
state = self.progression_planner.export_state()
account = state.get("accounts", {}).get(value(intent, "account_key"), {})
pending = account.get("pending")
if pending:
if pending.get("token") != value(intent, "token") or pending.get("intent") != intent.to_dict():
raise ValueError("取消的未发送请求与任务检查点不匹配")
account["pending"] = None
self.progression_planner.restore_state(state)
self._persist_progression(save=False)
def _recover_confirmed_progression(self):
"""Replay only local acknowledgement of a durably received success."""
record = self.battle_journal.pending(self.snapshot)
if (not record or str(record.get("role_id")) != str(self.snapshot.raw["master"].get("id"))
or not str(record.get("kind", "")).startswith("progression_")):
return
battle = record["kind"] == "progression_battle"
confirmed = record.get("phase") == ("settlement_acknowledged" if battle else "acknowledged")
confirmed = confirmed or record.get("settlement_confirmed" if battle else "response_confirmed") is True
response = record.get("response")
if not confirmed or not isinstance(response, dict) or response.get("resCode", 0) not in (0, "0"):
return
path = record.get("path") or ""
if battle and path != "taskService/taskCompleteStep":
return
if not battle and path not in {"taskService/taskReceive", "taskService/taskLoopReceive", "taskService/taskLoopFlush",
"taskService/taskCompleteStep", "taskService/taskComplete", "taskService/taskUpdate"}:
return
state = self.progression_planner.export_state()
account = state.get("accounts", {}).get(record.get("account_key"), {})
intent_id = record.get("intent_id")
applied = bool(intent_id and intent_id in account.get("applied", []))
if not applied:
pending = self.progression_planner.pending(self.snapshot)
if not pending or not isinstance(pending.get("intent"), dict):
return
intent = ProgressionIntent(**pending["intent"])
if (pending.get("token") != intent.token or intent.blocked
or intent_id and intent.token != intent_id
or record.get("account_key") and intent.account_key != record["account_key"]):
return
if any(str(value(intent, field)) != str(record.get(field))
for field in ("kind", "task_id", "task_type_id", "step_number")):
return
# The current restore_state API restores durable accounts but not
# its transient issued-token registry. Rehydrate only this exact
# saved pending intent after validating the successful receipt.
# Cursor/story effects still belong exclusively to acknowledge.
issued = self.progression_planner._issued
if intent.token in issued and issued[intent.token] != intent.to_dict():
raise ValueError("持久化确认与已签发任务意图不匹配")
issued[intent.token] = intent.to_dict()
if not self.progression_planner.acknowledge(self.snapshot, intent, response):
return
self._persist_progression(save=False)
self.battle_journal.finish(self.snapshot, record, "win" if battle else "task",
"已从持久化成功回包恢复本地任务检查点;未重发请求")
def _battle_capability(self, intent):
try:
if self._is_commission(intent) and not self.quest_policy.battle_tasks:
return False, "战斗委托未启用;未开始战斗"
if self.battles.runtime is None:
return False, ("实验模型" if self.progression_policy.battle_mode == "experimental" else "原始战斗运行时") + "尚未提供,未开始战斗"
policy = self._intent_policy(intent)
preview = bool(value(intent, "task_type_id")) and not value(intent, "task_id") and not self._is_farm(intent)
if not preview:
reason = self.battles.resource_reason(self.snapshot, intent, policy, self.policy)
if reason:
return False, reason
key = digest({"snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime), "team": policy.team, "mode": policy.battle_mode,
**{name: value(intent, name) for name in ("task_type_id", "step_number", "stage_id", "difficulty", "battle_kind")}})
if key not in self._capability_cache:
request = self.battles.request(self.snapshot, intent, policy)
self._capability_cache[key] = self.battles.inspect(request)
while len(self._capability_cache) > 64:
self._capability_cache.pop(next(iter(self._capability_cache)))
return self._capability_cache[key]
except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error:
return False, "战斗输入或运行时未就绪:" + str(error)
def _overlay_battle_capabilities(self, rows, intents):
battle_kinds = {"task", "battle", "passStage", "task_battle", "task_pass_stage", "ordinary_stage", "stage", "map_battle", "hidden"}
reasons = {}
adjusted = []
for intent in intents:
if value(intent, "kind") == "progression_loop_accept" and not self._commission_offer_supported(value(intent, "task_type_id")):
intent = replace(intent, block_reason=self._commission_offer_reason)
if (value(intent, "kind") in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle")
or self._is_farm(intent) and not self._is_sweep_intent(intent)) and not value(intent, "block_reason"):
supported, reason = self._battle_capability(intent)
reasons[str(value(intent, "source_task_type_id") or value(intent, "task_type_id"))] = (supported, reason)
if not supported:
intent = replace(intent, block_reason=reason) if not isinstance(intent, dict) else intent | {"block_reason": reason}
adjusted.append(intent)
commissions = {str(value(intent, "task_type_id")): intent for intent in adjusted if self._is_commission(intent)}
farms = {str(value(intent, "source_task_type_id")): intent for intent in adjusted if self._is_farm(intent)}
for row in rows:
source_supported = row.get("supported") is not False
commission = commissions.get(str(row.get("task_type_id")))
if commission is not None:
row.update(next_action=value(commission, "description"), block_reason=value(commission, "block_reason", ""))
farm = farms.get(str(row.get("task_type_id")))
if farm is not None:
row.update(next_action=value(farm, "description"), block_reason=value(farm, "block_reason", ""),
battle_kind="sweep" if self._is_sweep_intent(farm) else "ordinary_stage",
stage_id=value(farm, "stage_id"), difficulty=value(farm, "difficulty"))
reason = row.get("block_reason") or row.get("blocked_reason") or ""
if row.get("battle_kind") in battle_kinds:
supported, runtime_reason = reasons.get(str(row.get("task_type_id")),
(False, "战斗运行时能力尚未核对;配置存在不代表已支持实战"))
row["supported"] = bool(source_supported and supported and not reason)
reason = reason or runtime_reason
else:
row["supported"] = bool(source_supported and not reason)
row["block_reason"] = row["blocked_reason"] = reason
return rows, adjusted
def _battle_request(self, snapshot, intent, policy, request):
self._ensure_progression()
if self._battle_snapshot_source is not snapshot:
self._battle_snapshot_source = snapshot
self._battle_snapshot_digest = digest(snapshot.raw)
if self._battle_roster_digest != self._battle_snapshot_digest:
self._battle_roster = deepcopy(snapshot.raw)
self._battle_roster_digest = self._battle_snapshot_digest
task = bool(value(intent, "task_type_id")) and value(intent, "battle_kind") in ("task", "battle", "passStage", "task_battle", "task_pass_stage")
kind = value(intent, "battle_kind")
battle = self.game_data.task_battle(value(intent, "task_type_id"), value(intent, "step_number")) if task else \
self.game_data.stage_battle(value(intent, "stage_id"), value(intent, "difficulty", "1"))
prepared = request | {"snapshot": self._battle_roster,
"battle_mode": policy.battle_mode,
"context": "task_pass_stage" if task and kind == "passStage" else "task_battle" if task else "ordinary_stage",
"original_data": {"battle": battle, "manifest": self.game_data.manifest},
"roster": self._battle_roster, "task_id": value(intent, "task_id"),
"step_index": int(value(intent, "step_number", 1) or 1) - 1 if task else None}
if policy.battle_mode == "original":
from .battle_runtime import BattleRuntime
if isinstance(self.battles.runtime, BattleRuntime):
source = self.game_data.manifest.get("source", {})
prepared["runtime_request"] = {name: prepared[name] for name in (
"context", "roster", "stage_id", "task_id", "step_index")}
prepared["runtime_request"].update(difficulty=int(value(intent, "difficulty", 1) or 1), purpose="settlement",
original_data={"source": "original_apk", "resource_identity": {
"apk_sha256": source.get("apk_sha256"), "main_swf_sha256": source.get("main_swf_sha256")}})
return prepared
def _is_commission(self, intent):
if value(intent, "kind") in ("progression_loop_accept", "progression_loop_reset"):
return True
info = self.game_data.task(value(intent, "source_task_type_id") or value(intent, "task_type_id")) if self.game_data else None
return bool(info and info.get("type") == 4)
@staticmethod
def _is_farm(intent):
return bool(value(intent, "source_task_type_id")) and not value(intent, "task_id") and bool(value(intent, "stage_id"))
@staticmethod
def _is_sweep_intent(intent):
return value(intent, "kind") in ("sweep", "progression_sweep", "progression_farm_sweep", "progression_map_sweep") or value(intent, "battle_kind") == "sweep"
def _intent_policy(self, intent):
if not self._is_commission(intent):
return self.progression_policy
quest = self.quest_policy
return replace(self.progression_policy, enabled=quest.enabled, mainline=False, sidequests=False,
commissions=True, accept=quest.accept, allow_items=quest.allow_items, allow_monsters=quest.allow_monsters,
max_money=quest.max_money, item_reserves=dict(quest.item_reserves))
def _commission_offer_supported(self, type_id):
self._commission_offer_reason = "委托后续条件、剧情或战斗未验证支持,未消耗接取次数"
info = self.game_data.task(type_id)
if not info or info.get("type") != 4:
return False
for number, step in enumerate(info.get("steps", []), 1):
for name in (step.get("story"), step.get("afterStory")):
if name and (self.game_data.script(name) or {}).get("supported") is not True:
return False
kind = step.get("statusType")
if kind in ("battle", "passStage"):
if not self.quest_policy.battle_tasks:
return False
intent = {"kind": "progression_battle", "task_type_id": str(type_id), "task_id": 0,
"step_number": number, "battle_kind": "passStage" if kind == "passStage" else "task",
"stage_id": (step.get("statusValue") or {}).get("stage"),
"difficulty": (step.get("statusValue") or {}).get("level", 1)}
supported, reason = self._battle_capability(intent)
if not supported:
self._commission_offer_reason = reason
return False
else:
ready, _, _ = self.progression_planner.requirement(self.snapshot, step, {},
self._intent_policy({"task_type_id": str(type_id)}), self.policy)
if not ready:
return False
return bool(info.get("steps"))
def _refresh_progression_cache(self, *, force=False):
if self.snapshot is None:
return
if not (force or self.progression_view_active or self.progression_policy.enabled or self.quest_policy.enabled):
return
try:
self._ensure_progression()
self._recover_confirmed_progression()
self._battle_snapshot_source = self.snapshot
self._battle_snapshot_digest = digest(self.snapshot.raw)
key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy),
"quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime), "day": int(self.snapshot.now // 86400)})
if force or key != self._progression_cache_key:
rows = self.progression_planner.rows(self.snapshot, self.progression_policy, self.policy, quest_policy=self.quest_policy)
intents = self.progression_planner.plan(self.snapshot, self.progression_policy, self.policy)
commission_plan = getattr(self.progression_planner, "commission_plan", None)
self._commission_planner_available = callable(commission_plan)
if self._commission_planner_available:
intents += commission_plan(self.snapshot, self.quest_policy, self.policy, battle_policy=self.progression_policy)
self._progression_rows, self._progression_intents = self._overlay_battle_capabilities(rows, intents)
self._persist_progression()
self._progression_cache_key = digest({"snapshot": self._battle_snapshot_digest, "policy": vars(self.progression_policy),
"quests": vars(self.quest_policy), "ranch": vars(self.policy), "local_state": self.progression_planner.state_signature(self.snapshot),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime), "day": int(self.snapshot.now // 86400)})
self._progression_error = ""
except (ImportError, OSError, ValueError, TypeError, KeyError, AttributeError) as error:
self._progression_error = "任务规划暂不可用:" + str(error)
self._progression_rows = [{"state": "unsupported", "supported": False, "blocked_reason": self._progression_error}]
self._progression_intents = []
self._progression_records = self.battle_journal.records(self.snapshot)
@account_serial
def refresh_progression(self):
if not self.demo:
self.read_snapshot(sync_master=False)
elif self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
self._refresh_progression_cache(force=True)
pending = self.battle_journal.pending(self.snapshot)
message = self._progression_error or (pending.get("message") or "存在待核对的任务 / 战斗") if pending else self._progression_error or "已刷新任务与战斗记录"
return self.snapshot, self.plans(), message
@single_flight
@account_serial
def run_progression_once(self):
self.last_executed = False
if not self.demo:
self.read_snapshot(sync_master=False)
elif self.snapshot is None:
self.snapshot = demo_snapshot(self.catalog)
self._refresh_progression_cache()
return self._run_progression_intent()
def _run_progression_intent(self, intent=None):
if not self.progression_policy.enabled and not self.quest_policy.enabled:
return self.snapshot, self.plans(), "自动主线策略未启用"
if self._progression_pending():
return self.snapshot, [], "有待核对的任务 / 战斗;未重复提交"
if self._progression_cancel.is_set():
return self.snapshot, self.plans(), "任务推进已取消"
intents = self._progression_intents
if intent is None:
intent = next((i for i in intents if not value(i, "block_reason")), None)
if intent is None:
reasons = [str(value(i, "block_reason")) for i in intents if value(i, "block_reason")]
return self.snapshot, self.plans(), self._progression_error or (";".join(dict.fromkeys(reasons)) if reasons else "当前没有可执行的任务步骤")
if self.demo:
return self.snapshot, self.plans(), "演示只展示任务;不会伪造战斗、任务进度或奖励"
if value(intent, "block_reason"):
return self.snapshot, self.plans(), str(value(intent, "block_reason"))
effective_policy = self._intent_policy(intent)
if not effective_policy.enabled:
return self.snapshot, self.plans(), "对应任务策略未启用"
try:
self.last_executed = True
kind = value(intent, "kind")
if kind in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle", "sweep") or self._is_farm(intent):
message = self.battles.run(self.client, self.snapshot, intent, effective_policy,
cancel=self._progression_cancel, ranch=self.policy)
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, "战斗待核对,禁止重放")
self._persist_progression()
if not self._progression_cancel.is_set():
self.read_snapshot(sync_master=False)
return self.snapshot, self.plans(), message
except Exception:
if self.battle_journal.pending(self.snapshot) and not self._is_farm(intent) and value(intent, "kind", "").startswith("progression_"):
self.progression_planner.mark_uncertain(self.snapshot, intent, "任务 / 战斗结果待核对,禁止重放")
self._persist_progression()
raise
finally:
self._refresh_progression_cache(force=True)
def _execute_task_intent(self, intent):
path, kind = value(intent, "path", "") or "", value(intent, "kind")
payload = deepcopy(value(intent, "payload", {}) or {})
allowed = {"taskService/taskReceive": {"taskTypeId"}, "taskService/taskLoopReceive": {"taskTypeId", "city"},
"taskService/taskCompleteStep": {"taskId", "taskTypeId", "removeIds"},
"taskService/taskComplete": {"taskId", "taskTypeId"}, "taskService/taskLoopFlush": set(),
"taskService/taskUpdate": {"unlockTasks", "receiveTasks", "removeTasks"}}
local = kind in ("progression_navigate", "progression_dialogue", "progression_local_step") and not path
if not local and (path not in allowed or set(payload) != allowed[path]):
return "任务请求字段或本地剧情类型未受支持,未执行"
if path.endswith("taskUpdate") and (not all(isinstance(payload[k], list) for k in allowed[path])
or not any(payload.values())):
return "任务补链必须提供计算后的三个数组;未发送查询或空补链"
if self._progression_cancel.is_set():
return "任务推进已取消"
record = self.battle_journal.begin(self.snapshot, intent)
if local:
self.progression_planner.acknowledge(self.snapshot, intent)
self._persist_progression(save=False)
self.battle_journal.finish(self.snapshot, record, "local", "已保存普通剧情的本地检查点")
return "已推进普通剧情并保存本地检查点"
try:
self.progression_planner.mark_started(self.snapshot, intent)
self._persist_progression(save=False)
self.battle_journal.update(record, "request_pending")
try:
response = self.battles._call(self.client, path, payload, cancel=self._progression_cancel)
except CancelledBeforeDispatch:
self._cancel_unsent_progression(intent)
self.battle_journal.finish(self.snapshot, record, "cancelled", "任务请求尚未发送,已取消")
return record["message"]
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response), response_confirmed=True)
acknowledged = self.progression_planner.acknowledge(self.snapshot, intent, gameplay_response(response))
self._persist_progression(save=False)
if acknowledged:
self.battle_journal.finish(self.snapshot, record, "task", "服务器已确认任务请求,已保存本地检查点")
else:
self.battle_journal.update(record, "unknown", message="任务成功回包缺少有效状态,等待核对")
return value(intent, "description", "任务请求已确认")
except Exception as error:
self.battle_journal.update(record, "unknown", message="任务请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
@account_serial
def read_snapshot(self, *, sync_master=True):
self.snapshot = self.client.snapshot()
self.battle_journal.reconcile(self.snapshot, trusted=True)
self.master_sync.apply(self.snapshot)
if sync_master:
if sync_master and not self._progression_pending():
self.master_sync.settle(self.client, self.snapshot)
present = self.snapshot.monsters
self.growth_cache = {mid: entry for mid, entry in self.growth_cache.items() if mid in present}
@@ -79,15 +598,18 @@ class Engine:
self.snapshot.raw["monsters"] = rows
self.gift_planner.apply_confirmed(self.snapshot)
self.sweeper.recover_reward_event(self.snapshot, getattr(getattr(self.client, "trace", None), "path", None))
self._refresh_progression_cache()
return self.snapshot
def master_sync_due(self):
return not self.demo and bool(self.master_sync.pending(self.snapshot))
return not self.demo and not self._progression_pending() and bool(self.master_sync.pending(self.snapshot))
@account_serial
def sync_master(self):
self.read_snapshot()
return self.snapshot, self.plans(), "已同步等级 / 体力"
@account_serial
def refresh_stages(self):
self.auto = False
if not self.demo:
@@ -118,6 +640,8 @@ class Engine:
entry.update({field: row[field] for field in ("gAtk", "gDef", "gHp", "gDex") if row.get(field) is not None})
def settle_pending_growth(self, force=False):
if self._progression_pending():
return False
pending = self.snapshot.growth_pending(self.catalog)
now = time.monotonic()
if not pending or not force and all(now - self.growth_attempts.get(key, -1e12) < 60 for key in pending):
@@ -130,11 +654,12 @@ class Engine:
return True
def growth_sync_due(self):
if self.snapshot is None:
if self.snapshot is None or self._progression_pending():
return False
now = time.monotonic()
return any(now - self.growth_attempts.get(key, -1e12) >= 60 for key in self.snapshot.growth_pending(self.catalog))
@account_serial
def sync_growth(self):
if self.demo:
if self.snapshot is None:
@@ -151,6 +676,7 @@ class Engine:
message += f";仍有 {len(pending)} 只等待服务器确认阶段或资质"
return self.snapshot, self.plans(), message
@account_serial
def keep_alive(self):
if self.demo:
return "离线演示无需心跳"
@@ -158,6 +684,8 @@ class Engine:
self.client.call("heartBeatService/keepAlive")
return "会话心跳已更新"
@single_flight
@account_serial
def poll(self, *, hatch_only=False, defer_hatch=False):
self.last_executed = False
settled = False
@@ -177,6 +705,12 @@ class Engine:
self.sweeper.recovered_event = False
if self.snapshot.growth_pending(self.catalog):
message += ";成长状态等待服务器确认,将自动检查"
if self.demo:
self._refresh_progression_cache()
if self._progression_pending():
self.pending_hatches = []
pending = self.battle_journal.pending(self.snapshot) or {}
return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作")
try:
plans = self.plans()
except (ValueError, TypeError, KeyError, AttributeError) as error:
@@ -188,6 +722,8 @@ class Engine:
action = None
if self.auto and action is not None:
self.last_executed = True
if action.kind == "progression":
return self._run_progression_intent(action.payload["intent"])
if action.kind == "daily":
entry = next(row for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger) if row.action == action)
self.claim_daily_entry(entry)
@@ -209,7 +745,7 @@ class Engine:
if self.demo:
self.apply_demo(action)
else:
response = self.client.call(action.path, action.payload)
response = self._execute_legacy_task(action) if action.kind.startswith("quest_") else self.client.call(action.path, action.payload)
if action.kind == "buy":
self.record_draw(response.get("eggs") or [])
if action.kind == "gift":
@@ -241,10 +777,32 @@ class Engine:
message += ";" + ";".join(dict.fromkeys(self.planner.notes))
return self.snapshot, plans, message
def _execute_legacy_task(self, action):
"""Keep the commission scheduler, with the same durable replay barrier."""
payload = action.payload
task = next((task for task in self.snapshot.raw.get("currentTasks", [])
if str(task.get("id")) == str(payload.get("taskId"))), {})
intent = {"kind": action.kind, "description": action.description, "path": action.path, "payload": payload,
"task_id": payload.get("taskId"), "task_type_id": payload.get("taskTypeId"), "step_number": task.get("curStep")}
record = self.battle_journal.begin(self.snapshot, intent)
try:
self.battle_journal.update(record, "request_pending")
response = self.battles._call(self.client, action.path, payload)
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response))
return response
except Exception as error:
self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__)
raise
def plans(self):
if self.snapshot is None or self._progression_pending():
self.pending_hatches = []
return []
if self.policy.keep_better_quality or self.policy.gift_auto_representative:
self.cultivation.select(self.snapshot)
quests = self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
# One owner for commission writes; never accept the same offer through
# both the legacy planner and the full progression planner.
quests = [] if self._commission_planner_available else self.tasks.plan(self.snapshot, self.quest_policy, self.policy)
types, eggs = self.tasks.reservations(self.snapshot)
reserved = dict(self.policy.reserved_eggs)
for key, count in eggs.items():
@@ -259,18 +817,26 @@ class Engine:
gifts = self.gift_planner.plan(self.snapshot, policy, self.quest_policy)
ranch = self.planner.plan(self.snapshot, policy, left)
self.planner.notes.extend(self.gift_planner.notes)
return daily + quests + gifts + ranch + sweep_actions
progression = [Action("progression", value(intent, "description", "推进任务"), "", {"intent": intent})
for intent in self._progression_intents if not value(intent, "block_reason") and self._intent_policy(intent).enabled]
if quests and quests[0].kind == "quest_reset":
return daily + quests + progression[:1] + gifts + ranch + sweep_actions
return daily + progression[:1] + quests + gifts + ranch + sweep_actions
@account_serial
def claim_daily_entry(self, entry):
self._require_no_battle()
self.daily_ledger.record(self.snapshot, entry.key)
if not self.demo:
self.client.call(entry.action.path, entry.action.payload)
self.read_snapshot()
@account_serial
def claim_daily(self):
self.auto = False
if not self.demo:
self.read_snapshot()
self._require_no_battle()
# Fresh status after every claim, bounded by the initially available IDs.
keys = [row.key for row in selected_entries(self.catalog, self.snapshot, self.daily_policy, self.daily_ledger)]
done = 0
@@ -290,6 +856,7 @@ class Engine:
parts = [f"{self.catalog.monster(key).get('name', key)} ×{count}" for key, count in totals.items()]
self.last_draw = f"抽蛋完成,共 {sum(totals.values())} 枚:" + "、".join(parts[:8]) + ("…" if len(parts) > 8 else "")
@account_serial
def set_monster_lock(self, monster_ids, locked):
self.auto = False
ids = list(dict.fromkeys(int(mid) for mid in monster_ids))
@@ -297,6 +864,7 @@ class Engine:
raise ValueError("请先选择需要锁定 / 解锁的魔物")
if not self.demo:
self.read_snapshot()
self._require_no_battle()
monsters = self.snapshot.monsters
if any(mid not in monsters for mid in ids):
raise ValueError("选中的魔物已不存在,请刷新后重新选择")
@@ -317,10 +885,12 @@ class Engine:
message = ("[演示] " if self.demo else "") + f"已{'锁定' if locked else '解锁'} {changed} 只魔物;自动执行已暂停"
return self.snapshot, self.plans(), message
@account_serial
def manage_monsters(self, kind, monster_ids, target_id=0):
self.auto = False
if not self.demo:
self.read_snapshot()
self._require_no_battle()
actions = manual_monster_actions(self.catalog, self.snapshot, kind, monster_ids, target_id)
for action in actions:
if self.demo:
@@ -335,10 +905,12 @@ class Engine:
raise ValueError("操作已返回,但魔物记录尚未更新;请刷新核对,不会重复提交")
return self.snapshot, self.plans(), ("[演示] " if self.demo else "") + ";".join(a.description for a in actions) + ";自动执行已暂停"
@account_serial
def expand(self, quote):
self.auto = False
if not self.demo:
self.read_snapshot()
self._require_no_battle()
fresh = expansion_quote(self.catalog, self.snapshot, quote.kind, quote.currency, quote.position)
if fresh != quote:
raise ValueError("扩建费用或次数已变化,请刷新后重新确认")