feat: add daily commission history for Web 2.0.8
This commit is contained in:
@@ -0,0 +1,305 @@
|
||||
"""Bounded, per-role commission receipts, independent of rolling activity logs.
|
||||
|
||||
Only journaled operations enter this ledger. A current task or passTask flag
|
||||
alone proves neither its acceptance date nor that its reward was collected.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from copy import deepcopy
|
||||
from datetime import date, datetime, timedelta
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
from pathlib import Path
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from .quests import CN, commission_priority
|
||||
|
||||
|
||||
def beijing_day(timestamp=None):
|
||||
return datetime.fromtimestamp(time.time() if timestamp is None else timestamp, CN).date().isoformat()
|
||||
|
||||
|
||||
def confirmed_reward(response):
|
||||
"""NetTask.finishTaskHandler -> RewardCenter -> MasterCenter.addKe: delta."""
|
||||
reward = response.get("reward") if isinstance(response, dict) else None
|
||||
value = reward.get("ke") if isinstance(reward, dict) else None
|
||||
if type(value) not in (int, float) or not math.isfinite(value) or value < 0 or int(value) != value:
|
||||
return None
|
||||
return int(value)
|
||||
|
||||
|
||||
def positive_id(value):
|
||||
if isinstance(value, bool):
|
||||
return None
|
||||
try:
|
||||
number = float(value)
|
||||
return int(number) if math.isfinite(number) and number.is_integer() and number > 0 else None
|
||||
except (ValueError, TypeError, OverflowError):
|
||||
return None
|
||||
|
||||
|
||||
def valid_stored_event(event):
|
||||
required = {"id", "journal_id", "time", "date", "kind", "status", "description", "task_id", "task_type_id",
|
||||
"name", "city", "expected_ke", "confirmed_ke", "selection_code", "selection_reason", "higher_reward_blockers"}
|
||||
if not isinstance(event, dict) or not required <= event.keys():
|
||||
return False
|
||||
if any(not isinstance(event[key], str) for key in
|
||||
("id", "journal_id", "date", "kind", "status", "description", "task_type_id", "name", "selection_code", "selection_reason")):
|
||||
return False
|
||||
if (type(event["time"]) not in (int, float) or not math.isfinite(event["time"])
|
||||
or event["date"] != beijing_day(event["time"])):
|
||||
return False
|
||||
if event["task_id"] is not None and (type(event["task_id"]) is not int or event["task_id"] <= 0):
|
||||
return False
|
||||
if type(event["expected_ke"]) is not int or event["expected_ke"] < 0:
|
||||
return False
|
||||
if event["confirmed_ke"] is not None and (type(event["confirmed_ke"]) is not int or event["confirmed_ke"] < 0):
|
||||
return False
|
||||
return (bool(event["id"]) and bool(event["journal_id"]) and isinstance(event["higher_reward_blockers"], list)
|
||||
and event["kind"] in ("accept", "complete", "reset", "step", "navigate", "dialogue", "battle", "farm", "local_step")
|
||||
and event["status"] in ("confirmed", "pending", "unknown", "cancelled", "failed"))
|
||||
|
||||
|
||||
def reconciled_accept_task(record, snapshot, today):
|
||||
"""Recheck only a journal-proven acceptance from the current Beijing day."""
|
||||
if (snapshot is None or record.get("outcome") != "reconciled"
|
||||
or not (record.get("path") or "").endswith("taskLoopReceive")
|
||||
or str(snapshot.raw.get("master", {}).get("id")) != str(record.get("role_id"))):
|
||||
return None
|
||||
timestamp = record.get("finished_at") or record.get("updated_at") or record.get("timestamp")
|
||||
if type(timestamp) not in (int, float) or not math.isfinite(timestamp) or beijing_day(timestamp) != today:
|
||||
return None
|
||||
old = {str(task.get("id")) for task in (record.get("baseline") or {}).get("tasks", [])}
|
||||
expected_id = positive_id(record.get("task_id"))
|
||||
matches = [task for task in snapshot.raw.get("currentTasks", [])
|
||||
if str(task.get("typeId")) == str(record.get("task_type_id")) and str(task.get("id")) not in old
|
||||
and positive_id(task.get("id")) and positive_id(task.get("curStep"))
|
||||
and (expected_id is None or positive_id(task["id"]) == expected_id)]
|
||||
return {key: matches[0][key] for key in ("id", "typeId", "curStep")} if len(matches) == 1 else None
|
||||
|
||||
|
||||
def journal_event(record, info, snapshot=None):
|
||||
meta = record.get("commission") or {}
|
||||
path, original = record.get("path") or "", record.get("kind") or ""
|
||||
farming = bool(record.get("source_task_type_id"))
|
||||
type_id = str(record.get("source_task_type_id") or record.get("task_type_id") or "")
|
||||
if not (meta or (info or {}).get("type") == 4 or original.startswith("quest_")
|
||||
or original in ("progression_loop_accept", "progression_loop_reset")):
|
||||
return None
|
||||
kind = ("farm" if farming else "accept" if path.endswith("taskLoopReceive") else
|
||||
"complete" if path.endswith("taskComplete") else "reset" if path.endswith("taskLoopFlush") else
|
||||
"navigate" if original == "progression_navigate" else "dialogue" if original == "progression_dialogue" else
|
||||
"battle" if original == "progression_battle" else "local_step" if original == "progression_local_step" else "step")
|
||||
response = record.get("response")
|
||||
response_ok = isinstance(response, dict) and response.get("resCode", 0) in (0, "0")
|
||||
action_response = record.get("commission_action_response")
|
||||
action_receipt = record.get("commission_action_confirmed") is True and isinstance(action_response, dict) and action_response.get("resCode", 0) in (0, "0")
|
||||
receipt = response_ok and (record.get("response_confirmed") is True or record.get("settlement_confirmed") is True
|
||||
or record.get("phase") in ("acknowledged", "settlement_acknowledged")
|
||||
or record.get("phase") == "done" and record.get("outcome") in ("task", "win"))
|
||||
task_id = record.get("source_task_id") if farming else record.get("task_id")
|
||||
phase, outcome = record.get("phase"), record.get("outcome")
|
||||
status = "unknown" if "unknown" in str(phase) or outcome == "reconciled" else "pending"
|
||||
if kind == "accept":
|
||||
task = response.get("task") if receipt else None
|
||||
if not isinstance(task, dict) and outcome == "reconciled":
|
||||
# Bind only the snapshot that resolved this pending attempt. A
|
||||
# later currentTasks entry may be another day's same-type task.
|
||||
task = record.get("commission_task")
|
||||
if (isinstance(task, dict) and str(task.get("typeId")) == type_id
|
||||
and positive_id(task.get("id")) and positive_id(task.get("curStep"))):
|
||||
task_id, status = positive_id(task["id"]), "confirmed"
|
||||
elif receipt:
|
||||
status = "unknown"
|
||||
elif kind == "complete":
|
||||
# passTask is type-level history: it cannot prove this instance's claim.
|
||||
if receipt:
|
||||
status = "confirmed"
|
||||
elif receipt or action_receipt or phase == "done" and outcome in ("local", "win", "sweep", "event"):
|
||||
status = "confirmed"
|
||||
elif outcome == "reconciled" and kind in ("step", "battle", "reset"):
|
||||
status = "confirmed"
|
||||
if outcome in ("cancelled", "unsupported"):
|
||||
status = "cancelled"
|
||||
elif outcome == "loss":
|
||||
status = "failed"
|
||||
timestamp = (record.get("finished_at") or record.get("updated_at") or record.get("timestamp")) if status == "confirmed" else record.get("timestamp")
|
||||
if type(timestamp) not in (int, float) or not math.isfinite(timestamp):
|
||||
return None
|
||||
name = str(meta.get("name") or (info or {}).get("name") or type_id or "每日委托")
|
||||
expected = meta.get("expected_ke", -commission_priority(info or {}))
|
||||
actual = confirmed_reward(response) if kind == "complete" and receipt else None
|
||||
labels = {"accept": "接取委托", "complete": "领取委托奖励", "reset": "刷新每日委托",
|
||||
"step": "提交委托步骤", "navigate": "委托导航", "dialogue": "委托对话", "battle": "委托战斗",
|
||||
"farm": "收集委托材料", "local_step": "完成委托步骤本地收尾"}
|
||||
detail = record.get("description") or ""
|
||||
description = f"{labels[kind]}:{name}(预计{expected}氪金)"
|
||||
if kind in ("step", "battle", "local_step") and record.get("step_number"):
|
||||
description += f",第{record['step_number']}步"
|
||||
if kind in ("navigate", "dialogue", "farm") and detail:
|
||||
description += ";" + detail
|
||||
if status == "confirmed":
|
||||
if kind in ("step", "battle") and meta.get("operation_detail"):
|
||||
description += ";" + meta["operation_detail"]
|
||||
description += ";本地操作已完成" if outcome == "local" else ";快照已核对" if outcome == "reconciled" and not receipt else ";已确认"
|
||||
if kind == "complete":
|
||||
description += f",实际获得{actual}氪金" if actual is not None else ",实际氪金奖励未记录"
|
||||
if kind == "accept" and meta.get("selection_reason"):
|
||||
description += ";" + meta["selection_reason"]
|
||||
else:
|
||||
description += {"pending": ";请求待确认", "unknown": ";结果未知,等待核对,禁止重发",
|
||||
"cancelled": ";未执行", "failed": ";战斗失败,未推进委托"}[status]
|
||||
return {"id": str(record["attempt_id"]), "journal_id": str(record["attempt_id"]),
|
||||
"time": timestamp, "date": beijing_day(timestamp), "kind": kind, "status": status,
|
||||
"description": description, "task_id": positive_id(task_id), "task_type_id": type_id,
|
||||
"name": name, "city": meta.get("city", (record.get("payload") or {}).get("city")),
|
||||
"expected_ke": expected, "confirmed_ke": actual,
|
||||
"operation_detail": meta.get("operation_detail", ""),
|
||||
"confirmation": "receipt" if receipt or action_receipt else "local" if outcome == "local" else "snapshot" if outcome == "reconciled" and status == "confirmed" else "",
|
||||
"selection_code": meta.get("selection_code", "unknown" if kind == "accept" else "already_accepted"),
|
||||
"selection_reason": meta.get("selection_reason") or (("历史接取已确认,当时选择原因未记录" if status == "confirmed"
|
||||
else "接取已取消,当时选择原因未记录" if status == "cancelled" else "接取结果待核对,当时选择原因未记录") if kind == "accept"
|
||||
else "已有委托继续处理,接取时间及当时选择原因未记录"),
|
||||
"higher_reward_blockers": deepcopy(meta.get("higher_reward_blockers") or [])}
|
||||
|
||||
|
||||
class CommissionHistory:
|
||||
def __init__(self, path=None, *, retention_days=90, max_events=5000, clock=None):
|
||||
self.path = Path(path) if path else None
|
||||
self.retention_days, self.max_events = retention_days, max_events
|
||||
self.clock = clock or time.time
|
||||
self.lock = threading.RLock()
|
||||
self.state = {"version": 1, "roles": {}}
|
||||
self.error = ""
|
||||
self.warning = ""
|
||||
self._dirty = False
|
||||
self._seen = {}
|
||||
if self.path and self.path.exists():
|
||||
try:
|
||||
state = json.loads(self.path.read_text(encoding="utf-8"))
|
||||
if state.get("version") != 1 or not isinstance(state.get("roles"), dict):
|
||||
raise ValueError("unsupported history")
|
||||
for events in state["roles"].values():
|
||||
if not isinstance(events, dict) or any(not valid_stored_event(event) for event in events.values()):
|
||||
raise ValueError("invalid history")
|
||||
self.state = state
|
||||
except (OSError, ValueError, AttributeError, OverflowError) as error:
|
||||
self.error = "委托历史无法读取,原文件已保留:" + type(error).__name__
|
||||
|
||||
def _prune(self):
|
||||
cutoff = (datetime.fromtimestamp(self.clock(), CN).date() - timedelta(days=self.retention_days - 1)).isoformat()
|
||||
for role, events in self.state["roles"].items():
|
||||
keep = sorted((event for event in events.values() if event["date"] >= cutoff),
|
||||
key=lambda event: (event["time"], event["id"]))[-self.max_events:]
|
||||
self.state["roles"][role] = {event["id"]: event for event in keep}
|
||||
|
||||
def _save(self):
|
||||
self._prune()
|
||||
if self.path:
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
temporary = self.path.with_name(self.path.name + "." + uuid.uuid4().hex + ".tmp")
|
||||
try:
|
||||
with temporary.open("w", encoding="utf-8") as stream:
|
||||
json.dump(self.state, stream, ensure_ascii=False, allow_nan=False)
|
||||
stream.flush()
|
||||
os.fsync(stream.fileno())
|
||||
temporary.replace(self.path)
|
||||
finally:
|
||||
temporary.unlink(missing_ok=True)
|
||||
|
||||
def ingest(self, role_id, records, info_for, snapshot=None):
|
||||
"""Upsert by existing attempt ID; never read traces or dispatch requests."""
|
||||
if self.error:
|
||||
return
|
||||
with self.lock:
|
||||
role_id = str(role_id)
|
||||
events = self.state["roles"].setdefault(role_id, {})
|
||||
seen = self._seen.setdefault(role_id, {})
|
||||
changed = False
|
||||
for record in records:
|
||||
if str(record.get("role_id")) != role_id or not record.get("attempt_id"):
|
||||
continue
|
||||
key = str(record["attempt_id"])
|
||||
acceptance = reconciled_accept_task(record, snapshot, beijing_day(self.clock()))
|
||||
revision = (record.get("phase"), record.get("outcome"), record.get("updated_at"), record.get("finished_at"),
|
||||
json.dumps([record.get("commission") or {}, record.get("commission_task"), acceptance], sort_keys=True, ensure_ascii=False))
|
||||
if seen.get(key) == revision:
|
||||
continue
|
||||
info = info_for(str(record.get("source_task_type_id") or record.get("task_type_id") or ""))
|
||||
evidence = record | {"commission_task": acceptance} if acceptance and not record.get("commission_task") else record
|
||||
event = journal_event(evidence, info, snapshot)
|
||||
if event:
|
||||
previous = events.get(key)
|
||||
# A previously captured receipt stays known after restart,
|
||||
# even if a reconciled acceptance has left the snapshot.
|
||||
if previous and previous["status"] == "confirmed" and event["status"] != "confirmed":
|
||||
event = previous
|
||||
if previous != event:
|
||||
events[key] = event
|
||||
changed = True
|
||||
seen[key] = revision
|
||||
current_ids = {str(record.get("attempt_id")) for record in records}
|
||||
self._seen[role_id] = {key: revision for key, revision in seen.items() if key in current_ids}
|
||||
self._dirty = self._dirty or changed
|
||||
if self._dirty:
|
||||
self._save()
|
||||
self._dirty = False
|
||||
self.warning = ""
|
||||
|
||||
def query(self, role_id, day=None):
|
||||
today = beijing_day(self.clock())
|
||||
if day is None:
|
||||
day = today
|
||||
if not isinstance(day, str):
|
||||
raise ValueError("委托历史日期须为 YYYY-MM-DD")
|
||||
try:
|
||||
if date.fromisoformat(day).isoformat() != day:
|
||||
raise ValueError(day)
|
||||
except ValueError as error:
|
||||
raise ValueError("委托历史日期须为 YYYY-MM-DD") from error
|
||||
with self.lock:
|
||||
events = sorted(self.state["roles"].get(str(role_id), {}).values(), key=lambda event: (event["time"], event["id"]))
|
||||
dates = sorted({today, day, *(event["date"] for event in events)}, reverse=True)
|
||||
daily = [event for event in events if event["date"] == day]
|
||||
groups = {}
|
||||
for event in events:
|
||||
if event["date"] > day or not event["task_type_id"]:
|
||||
continue
|
||||
identity = f"{role_id}:{event['task_type_id']}:{event['task_id']}" if event["task_id"] else f"{role_id}:attempt:{event['id']}"
|
||||
groups.setdefault(identity, []).append(event)
|
||||
rows = []
|
||||
for identity, timeline in groups.items():
|
||||
selected = [event for event in timeline if event["date"] == day]
|
||||
if not selected:
|
||||
continue
|
||||
accepted = next((event for event in timeline if event["kind"] == "accept" and event["status"] == "confirmed"), None)
|
||||
completed = next((event for event in timeline if event["kind"] == "complete" and event["status"] == "confirmed"), None)
|
||||
latest, first = timeline[-1], accepted or timeline[0]
|
||||
status = (latest["status"] if latest["status"] in ("pending", "unknown", "failed", "cancelled") else "completed" if completed else
|
||||
"accepted" if latest["kind"] == "accept" and accepted else "in_progress")
|
||||
rows.append({"id": identity, "task_id": first["task_id"], "task_type_id": first["task_type_id"],
|
||||
"name": first["name"], "city": first["city"], "status": status,
|
||||
"accepted_at": accepted["time"] if accepted else None, "completed_at": completed["time"] if completed else None,
|
||||
"expected_ke": first["expected_ke"], "confirmed_ke": completed["confirmed_ke"] if completed else None,
|
||||
"selection_reason": first["selection_reason"], "selection_code": first["selection_code"],
|
||||
"higher_reward_blockers": first["higher_reward_blockers"], "last_action": latest["description"], "events": selected})
|
||||
receipts = {"accept": {}, "complete": {}}
|
||||
for event in events:
|
||||
if event["kind"] not in receipts or event["status"] != "confirmed":
|
||||
continue
|
||||
identity = (event["task_type_id"], event["task_id"]) if event["task_id"] else ("attempt", event["id"])
|
||||
receipts[event["kind"]].setdefault(identity, event)
|
||||
accepts = [event for event in receipts["accept"].values() if event["date"] == day]
|
||||
completes = [event for event in receipts["complete"].values() if event["date"] == day]
|
||||
result = {"date": day, "dates": dates, "timezone": "Asia/Shanghai", "role_id": str(role_id),
|
||||
"summary": {"accepted_count": len(accepts), "completed_count": len(completes),
|
||||
"pending_count": sum(row["status"] in ("pending", "unknown") for row in rows),
|
||||
"expected_ke": sum(event["expected_ke"] for event in accepts),
|
||||
"confirmed_ke": sum(event["confirmed_ke"] for event in completes if event["confirmed_ke"] is not None),
|
||||
"unknown_reward_count": sum(event["confirmed_ke"] is None for event in completes)},
|
||||
"rows": list(reversed(rows)), "events": list(reversed(daily)), "retention_days": self.retention_days,
|
||||
"notice": "仅展示已记录的委托操作;缺失的旧历史未记录,不补推接取、完成或奖励。", "error": self.error or self.warning}
|
||||
return deepcopy(result)
|
||||
+177
-11
@@ -12,7 +12,8 @@ from types import SimpleNamespace
|
||||
from .model import Action, Catalog, Planner, Policy, Snapshot, seconds
|
||||
from .daily import DailyLedger, DailyPolicy, selected_entries
|
||||
from .sweeping import SweepPolicy, SweepRunner
|
||||
from .quests import QuestPolicy, TaskPlanner
|
||||
from .quests import QuestPolicy, TaskPlanner, commission_priority
|
||||
from .commission_history import CommissionHistory
|
||||
from .market import PurchaseBudget
|
||||
from .management import expansion_quote, manual_monster_actions
|
||||
from .gifts import GiftPlanner
|
||||
@@ -104,6 +105,10 @@ class Engine:
|
||||
self._progression_state_loaded = False
|
||||
self._battle_catalog_ready = False
|
||||
self.battle_journal = BattleJournal(folder / "progression" / "journal.json" if folder else None)
|
||||
self._commission_history = CommissionHistory(folder / "progression" / "commission_history.json" if folder else None)
|
||||
self._commission_history_roles = set()
|
||||
self._commission_offer_diagnostics = []
|
||||
self._commission_diagnostics_key = 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()
|
||||
@@ -454,6 +459,10 @@ class Engine:
|
||||
self.battle_journal.save()
|
||||
|
||||
def _battle_observer(self, event, intent, response):
|
||||
if event == "started" and self._is_commission(intent):
|
||||
record = self.battle_journal.pending(self.snapshot)
|
||||
if record is not None:
|
||||
self._journal_commission(record, intent)
|
||||
if value(intent, "kind") == "map_battle":
|
||||
stage = SimpleNamespace(stage_id=str(value(intent, "stage_id")), level=str(value(intent, "difficulty")))
|
||||
key = self.sweeper.key(self.snapshot, stage)
|
||||
@@ -487,6 +496,11 @@ class Engine:
|
||||
if farming:
|
||||
if event == "started":
|
||||
planner.mark_started(self.snapshot, intent) # validates the issued ordinary intent only
|
||||
elif event in ("settled", "event"):
|
||||
record = self.battle_journal.pending(self.snapshot)
|
||||
if record is not None:
|
||||
self.battle_journal.update(record, record["phase"],
|
||||
commission_action_response=gameplay_response(response), commission_action_confirmed=True)
|
||||
# Farming is a normal map action. Its journal and fresh server
|
||||
# snapshot govern the result; it never acknowledges a task step.
|
||||
return None
|
||||
@@ -701,6 +715,106 @@ class Engine:
|
||||
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)
|
||||
|
||||
def _commission_info(self, type_id):
|
||||
info = self.game_data.task(type_id) if self.game_data and type_id else None
|
||||
return info or self.catalog.data.get("task_info", {}).get(str(type_id)) or {}
|
||||
|
||||
def _sync_commission_history(self):
|
||||
"""Use the already loaded, bounded journal; ledger failures never retry a game write."""
|
||||
if self.snapshot is None or self.snapshot.raw.get("master", {}).get("id") is None:
|
||||
return
|
||||
role = str(self.snapshot.raw["master"]["id"])
|
||||
try:
|
||||
records = self.battle_journal.role(self.snapshot)["records"]
|
||||
self._commission_history.ingest(role, records, self._commission_info, self.snapshot)
|
||||
self._commission_history_roles.add(role)
|
||||
except (OSError, ValueError, TypeError, KeyError, AttributeError):
|
||||
self._commission_history.warning = "委托历史暂未写入磁盘;任务回包仍保存在原日志,稍后核对导入,请勿重发"
|
||||
|
||||
@account_serial
|
||||
def commission_history(self, day=None):
|
||||
"""Independent plain DTO; day is YYYY-MM-DD in Beijing, default wall-clock today.
|
||||
|
||||
summary: accepted_count/completed_count/pending_count/expected_ke/
|
||||
confirmed_ke/unknown_reward_count. Unknown row rewards are None.
|
||||
Only events on the selected day contribute to daily counts and rewards.
|
||||
"""
|
||||
role = str(self.snapshot.raw.get("master", {}).get("id", "")) if self.snapshot else ""
|
||||
if role and (role not in self._commission_history_roles or self._commission_history._dirty):
|
||||
self._sync_commission_history()
|
||||
return self._commission_history.query(role, day)
|
||||
|
||||
@account_serial
|
||||
def commission_offer_diagnostics(self):
|
||||
"""Cached offline eligibility; no journal reload, game calls or runtime inspection."""
|
||||
if self.snapshot is None:
|
||||
return []
|
||||
self._ensure_commission_diagnostics()
|
||||
return deepcopy(self._commission_offer_diagnostics)
|
||||
|
||||
def _ensure_commission_diagnostics(self):
|
||||
key = (id(self.snapshot), digest({"quest": vars(self.quest_policy), "ranch": vars(self.policy),
|
||||
"progression": vars(self.progression_policy), "checks": self._commission_offer_checks}))
|
||||
if key == self._commission_diagnostics_key:
|
||||
return
|
||||
if self.progression_planner is None:
|
||||
self._ensure_progression()
|
||||
# Reuse model checks from the worker's last planning pass. A missing
|
||||
# check remains explicitly unverified until that worker runs.
|
||||
self._commission_offer_diagnostics = self.progression_planner.commission_offers(
|
||||
self.snapshot, self.quest_policy, self.policy, battle_policy=self.progression_policy,
|
||||
accept_supported=lambda key: self._commission_offer_checks.get(str(key),
|
||||
(False, "后续步骤或战斗能力尚未验证,等待后台检查")))
|
||||
self._commission_diagnostics_key = key
|
||||
|
||||
def _journal_commission(self, record, intent, *, legacy=False):
|
||||
type_id = str(value(intent, "source_task_type_id") or value(intent, "task_type_id") or "")
|
||||
info = self._commission_info(type_id)
|
||||
if info.get("type", 4 if legacy else None) != 4 and value(intent, "kind") not in ("progression_loop_reset", "quest_reset"):
|
||||
return
|
||||
selected = getattr(self.tasks if legacy else self.progression_planner, "commission_selection", {}) or {}
|
||||
accepting = (record.get("path") or "").endswith("taskLoopReceive")
|
||||
meta = {"name": info.get("name", type_id or "每日委托"), "expected_ke": -commission_priority(info),
|
||||
"city": (record.get("payload") or {}).get("city")}
|
||||
number = value(intent, "source_step_number") or value(intent, "step_number") or 0
|
||||
steps = info.get("steps") or []
|
||||
if 1 <= number <= len(steps):
|
||||
step = steps[number - 1]
|
||||
kind, required = step.get("statusType"), step.get("statusValue") or {}
|
||||
remove = required.get("remove") is True
|
||||
prefix = "提交" if remove else "核对持有"
|
||||
type_key, count = str(required.get("type", "")), required.get("num", 0)
|
||||
if kind == "getMoney":
|
||||
detail = f"{prefix}金币×{required.get('money', 0)}"
|
||||
elif kind == "getItem" or kind == "getMonster" and required.get("mode") == 0:
|
||||
name = self.catalog.monster(type_key).get("name", type_key) + "蛋" if type_key in self.catalog.monsters else self.catalog.data.get("item_names", {}).get(type_key, f"道具#{type_key}")
|
||||
detail = f"{prefix}{name}×{count}"
|
||||
elif kind == "getMonster":
|
||||
detail = f"{prefix}{self.catalog.monster(type_key).get('name', '魔物#' + type_key)}×{count}"
|
||||
elif kind == "passStage":
|
||||
stage = self.game_data.stage(required.get("stage")) if self.game_data else None
|
||||
detail = f"通关{(stage or {}).get('name', required.get('stage', '指定关卡'))},难度{required.get('level', 1)}"
|
||||
elif kind == "battle":
|
||||
detail = "完成委托专用战斗"
|
||||
elif kind == "none":
|
||||
detail = "完成对话条件"
|
||||
elif kind == "killMonster":
|
||||
detail = f"核对{self.catalog.monster(type_key).get('name', '魔物#' + type_key)}累计击杀数量"
|
||||
elif kind == "passLevel":
|
||||
detail = f"核对角色等级达到{required.get('level', 0)}级"
|
||||
else:
|
||||
detail = str(value(intent, "description", ""))
|
||||
meta["operation_detail"] = detail
|
||||
if accepting and selected.get("task_type_id") == type_id:
|
||||
meta.update(deepcopy(selected))
|
||||
self.battle_journal.update(record, record["phase"], commission=meta)
|
||||
|
||||
def _commission_message(self, record, default):
|
||||
self._sync_commission_history()
|
||||
role = str(self.snapshot.raw["master"].get("id", ""))
|
||||
event = self._commission_history.state["roles"].get(role, {}).get(str(record.get("attempt_id")))
|
||||
return event["description"] if event else default
|
||||
|
||||
@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"))
|
||||
@@ -725,18 +839,26 @@ class Engine:
|
||||
"" if supported else self._commission_offer_reason or "委托后续步骤当前无法自动完成")
|
||||
return supported
|
||||
|
||||
def _commission_offer_eligibility(self, type_id):
|
||||
self._check_commission_offer(type_id)
|
||||
return self._commission_offer_checks[str(type_id)]
|
||||
|
||||
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:
|
||||
self._commission_offer_reason = "委托配置缺失或类型不符"
|
||||
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:
|
||||
script = self.game_data.script(name) or {}
|
||||
self._commission_offer_reason = f"第{number}步剧情 {name} 未验证支持" + (":" + ";".join(script.get("block_reasons") or []) if script.get("block_reasons") else "")
|
||||
return False
|
||||
kind = step.get("statusType")
|
||||
if kind in ("battle", "passStage"):
|
||||
if not self.quest_policy.battle_tasks:
|
||||
self._commission_offer_reason = "委托战斗开关未启用"
|
||||
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",
|
||||
@@ -748,12 +870,24 @@ class Engine:
|
||||
return False
|
||||
else:
|
||||
policy = self._intent_policy({"task_type_id": str(type_id)})
|
||||
ready, _, _ = self.progression_planner.requirement(self.snapshot, step, {}, policy, self.policy)
|
||||
ready, _, requirement_reason = self.progression_planner.requirement(self.snapshot, step, {}, policy, self.policy)
|
||||
if not ready:
|
||||
sources = self.progression_planner.farming_intents(self.snapshot, step,
|
||||
{"id": 0, "typeId": str(type_id), "curStep": number}, policy, self.policy)
|
||||
if not any(self._is_sweep_intent(source) or self._battle_capability(source)[0] for source in sources):
|
||||
source_reasons = []
|
||||
feasible = False
|
||||
for source in sources:
|
||||
supported, reason = (True, "") if self._is_sweep_intent(source) else self._battle_capability(source)
|
||||
if supported:
|
||||
feasible = True
|
||||
break
|
||||
if reason:
|
||||
source_reasons.append(reason)
|
||||
if not feasible:
|
||||
self._commission_offer_reason = f"第{number}步:{requirement_reason}" + (";材料来源:" + ";".join(source_reasons) if source_reasons else ";没有当前可用的自动收集来源")
|
||||
return False
|
||||
if not info.get("steps"):
|
||||
self._commission_offer_reason = "委托没有有效步骤"
|
||||
return bool(info.get("steps"))
|
||||
|
||||
def _refresh_progression_cache(self, *, force=False):
|
||||
@@ -770,28 +904,33 @@ class Engine:
|
||||
"snapshot": self._battle_snapshot_digest, "runtime": id(self.battles.runtime)})
|
||||
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)})
|
||||
"pending": self._progression_pending(), "runtime": id(self.battles.runtime),
|
||||
"day": ProgressionPlanner._loop_day(self.snapshot, self.snapshot.now - 10)})
|
||||
if force or key != self._progression_cache_key:
|
||||
self._commission_offer_checks = {}
|
||||
self._commission_diagnostics_key = None
|
||||
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, accept_supported=self._check_commission_offer)
|
||||
battle_policy=self.progression_policy, accept_supported=self._commission_offer_eligibility)
|
||||
self._commission_offer_diagnostics = deepcopy(self.progression_planner.commission_offer_rows)
|
||||
intents.sort(key=lambda intent: not self._is_commission(intent))
|
||||
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)})
|
||||
"pending": self._progression_pending(), "runtime": id(self.battles.runtime),
|
||||
"day": ProgressionPlanner._loop_day(self.snapshot, self.snapshot.now - 10)})
|
||||
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)
|
||||
self._sync_commission_history()
|
||||
|
||||
@account_serial
|
||||
def refresh_progression(self):
|
||||
@@ -838,9 +977,15 @@ class Engine:
|
||||
try:
|
||||
self.last_executed = True
|
||||
kind = value(intent, "kind")
|
||||
self._sync_commission_history()
|
||||
if kind in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle", "sweep") or self._is_farm(intent):
|
||||
previous_attempts = {record["attempt_id"] for record in self.battle_journal.role(self.snapshot)["records"]}
|
||||
message = self.battles.run(self.client, self.snapshot, intent, effective_policy,
|
||||
cancel=self._progression_cancel, ranch=self.policy)
|
||||
records = [record for record in self.battle_journal.role(self.snapshot)["records"]
|
||||
if record["attempt_id"] not in previous_attempts]
|
||||
if records:
|
||||
message = self._commission_message(records[-1], message)
|
||||
else:
|
||||
message = self._execute_task_intent(intent)
|
||||
if self.battle_journal.pending(self.snapshot) and kind == "progression_battle":
|
||||
@@ -858,6 +1003,7 @@ class Engine:
|
||||
self._persist_progression()
|
||||
raise
|
||||
finally:
|
||||
self._sync_commission_history()
|
||||
self._refresh_progression_cache(force=True)
|
||||
|
||||
def _execute_task_intent(self, intent):
|
||||
@@ -875,12 +1021,14 @@ class Engine:
|
||||
return "任务补链必须提供计算后的三个数组;未发送查询或空补链"
|
||||
if self._progression_cancel.is_set():
|
||||
return "任务推进已取消"
|
||||
self._sync_commission_history()
|
||||
record = self.battle_journal.begin(self.snapshot, intent)
|
||||
self._journal_commission(record, intent)
|
||||
if local:
|
||||
self.progression_planner.acknowledge(self.snapshot, intent)
|
||||
self._persist_progression(save=False)
|
||||
self.battle_journal.finish(self.snapshot, record, "local", "已保存普通剧情的本地检查点")
|
||||
return "已推进普通剧情并保存本地检查点"
|
||||
return self._commission_message(record, "已推进普通剧情并保存本地检查点")
|
||||
try:
|
||||
self.progression_planner.mark_started(self.snapshot, intent)
|
||||
self._persist_progression(save=False)
|
||||
@@ -890,7 +1038,7 @@ class Engine:
|
||||
except CancelledBeforeDispatch:
|
||||
self._cancel_unsent_progression(intent)
|
||||
self.battle_journal.finish(self.snapshot, record, "cancelled", "任务请求尚未发送,已取消")
|
||||
return record["message"]
|
||||
return self._commission_message(record, 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)
|
||||
@@ -898,17 +1046,30 @@ class Engine:
|
||||
self.battle_journal.finish(self.snapshot, record, "task", "服务器已确认任务请求,已保存本地检查点")
|
||||
else:
|
||||
self.battle_journal.update(record, "unknown", message="任务成功回包缺少有效状态,等待核对")
|
||||
return value(intent, "description", "任务请求已确认")
|
||||
return self._commission_message(record, value(intent, "description", "任务请求已确认") if acknowledged else "任务成功回包缺少有效状态,等待核对,禁止重发")
|
||||
except Exception as error:
|
||||
self.battle_journal.update(record, "unknown", message="任务请求结果未确认,禁止自动重试", error_type=type(error).__name__)
|
||||
raise
|
||||
finally:
|
||||
self._sync_commission_history()
|
||||
|
||||
@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)
|
||||
pending = self.battle_journal.pending(self.snapshot)
|
||||
pending_id = pending.get("attempt_id") if pending else None
|
||||
if self.battle_journal.reconcile(self.snapshot, trusted=True) and pending_id:
|
||||
record = next((row for row in self.battle_journal.role(self.snapshot)["records"]
|
||||
if row["attempt_id"] == pending_id), None)
|
||||
if record and (record.get("path") or "").endswith("taskLoopReceive"):
|
||||
old = {str(task.get("id")) for task in record.get("baseline", {}).get("tasks", [])}
|
||||
task = next((task for task in self.snapshot.raw.get("currentTasks", [])
|
||||
if str(task.get("typeId")) == str(record.get("task_type_id")) and str(task.get("id")) not in old), None)
|
||||
if task:
|
||||
record["commission_task"] = {key: task[key] for key in ("id", "typeId", "curStep") if key in task}
|
||||
self._sync_commission_history()
|
||||
self.master_sync.apply(self.snapshot)
|
||||
if sync_master and not self._progression_pending():
|
||||
self.master_sync.settle(self.client, self.snapshot)
|
||||
@@ -1223,15 +1384,20 @@ class Engine:
|
||||
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")}
|
||||
self._sync_commission_history()
|
||||
record = self.battle_journal.begin(self.snapshot, intent)
|
||||
self._journal_commission(record, intent, legacy=True)
|
||||
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))
|
||||
self.battle_journal.update(record, "acknowledged", response=gameplay_response(response), response_confirmed=True)
|
||||
action.description = self._commission_message(record, action.description)
|
||||
return response
|
||||
except Exception as error:
|
||||
self.battle_journal.update(record, "unknown", message="委托请求结果未确认,禁止自动重试", error_type=type(error).__name__)
|
||||
raise
|
||||
finally:
|
||||
self._sync_commission_history()
|
||||
|
||||
def _map_policy(self):
|
||||
return SimpleNamespace(enabled=self.sweep_policy.enabled and (self.sweep_policy.allow_challenge or self.sweep_policy.allow_special),
|
||||
|
||||
@@ -45,7 +45,7 @@ import uuid
|
||||
|
||||
from .game_data import ProgressionData, load_progression_data
|
||||
from .model import Planner, seconds
|
||||
from .quests import commission_priority, indexed, stage_has_level
|
||||
from .quests import commission_priority, commission_selection, indexed, stage_has_level
|
||||
|
||||
|
||||
CATEGORIES = {1: ("mainline", "主线"), 2: ("sidequest", "支线"),
|
||||
@@ -184,6 +184,8 @@ class ProgressionPlanner:
|
||||
self._anonymous = uuid.uuid4().hex
|
||||
self._accounts = {}
|
||||
self._issued = {}
|
||||
self.commission_selection = {}
|
||||
self.commission_offer_rows = []
|
||||
|
||||
def _scope(self, snapshot):
|
||||
raw, master = snapshot.raw, snapshot.raw.get("master") or {}
|
||||
@@ -896,11 +898,16 @@ class ProgressionPlanner:
|
||||
taskLoopReceive:{taskTypeId,city}; quotas decrement only on acceptance
|
||||
acknowledgement. Current battle/passStage never become sweep intents.
|
||||
"""
|
||||
self.commission_selection = {}
|
||||
self.commission_offer_rows = []
|
||||
if not quest_policy.enabled:
|
||||
return []
|
||||
policy = self._commission_policy(quest_policy, battle_policy)
|
||||
scope, account = self._account(snapshot)
|
||||
self.reconcile(snapshot)
|
||||
candidates = self.commission_offers(snapshot, quest_policy, ranch_policy,
|
||||
battle_policy=battle_policy, accept_supported=accept_supported)
|
||||
self.commission_offer_rows = candidates
|
||||
if account["pending"]:
|
||||
reason = "存在未确认请求,委托等待核对,禁止重发"
|
||||
return [self._intent(scope, {}, 0, {}, "progression_blocked", reason, policy, block_reason=reason)]
|
||||
@@ -925,30 +932,67 @@ class ProgressionPlanner:
|
||||
blocked.append(action)
|
||||
if blocked or not quest_policy.accept or remaining <= 0:
|
||||
return blocked
|
||||
ranked_offers = sorted(((city, key) for city, values in offers.items() for key in _values(values)),
|
||||
key=lambda pair: commission_priority(self.data.task(str(pair[1])) or {}))
|
||||
for city, offered_key in ranked_offers:
|
||||
city = _integer(city)
|
||||
if city <= 0 or quest_policy.city and city != quest_policy.city or not snapshot.city_unlocked(city):
|
||||
continue
|
||||
key, info = str(offered_key), self.data.task(offered_key)
|
||||
if key in active or key in finished or not info or info.get("type") != 4:
|
||||
continue
|
||||
if not self._commission_offer_ready(snapshot, quest_policy, policy, ranch_policy, info)[0]:
|
||||
continue
|
||||
if accept_supported is not None and not accept_supported(key):
|
||||
blocked.append(self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {},
|
||||
"progression_loop_accept", "暂不接取:" + info.get("name", key), policy,
|
||||
path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today),
|
||||
block_reason="委托后续战斗或条件当前无法自动完成"))
|
||||
rejected = []
|
||||
for candidate in candidates:
|
||||
city, key = candidate["city"], candidate["task_type_id"]
|
||||
info = self.data.task(key)
|
||||
if not candidate["eligible"]:
|
||||
rejected.append(candidate)
|
||||
if candidate["blocked_by_support"]:
|
||||
blocked.append(self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {},
|
||||
"progression_loop_accept", "暂不接取:" + info.get("name", key), policy,
|
||||
path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today),
|
||||
block_reason=candidate["reason"]))
|
||||
continue
|
||||
self.commission_selection = {"task_type_id": key, "city": city,
|
||||
**commission_selection(info, candidates, rejected)}
|
||||
action = self._intent(scope, {"id": 0, "typeId": key}, 0, info.get("startStep") or {},
|
||||
"progression_loop_accept", "接取城市委托:" + info.get("name", key), policy,
|
||||
"progression_loop_accept", f"接取城市委托:{info.get('name', key)}(预计{candidate['expected_ke']}氪金);" + self.commission_selection["selection_reason"], policy,
|
||||
path="taskService/taskLoopReceive", payload={"taskTypeId": key, "city": city}, phase=str(today))
|
||||
self._issued[action.token] = action.to_dict()
|
||||
return [action]
|
||||
return blocked
|
||||
|
||||
def commission_offers(self, snapshot, quest_policy, ranch_policy, *, battle_policy=None, accept_supported=None):
|
||||
"""Offline eligibility for every offer; raw presence never means receivable."""
|
||||
policy = self._commission_policy(quest_policy, battle_policy)
|
||||
_, account = self._account(snapshot)
|
||||
today, recorded, remaining, offers = self._loop_view(snapshot, account)
|
||||
active, _, finished = self._tasks(snapshot, account)
|
||||
has_active = any((self.data.task(key) or {}).get("type") == 4 and key not in finished for key in active)
|
||||
rows = []
|
||||
ranked = sorted(((city, key) for city, values in offers.items() for key in _values(values)),
|
||||
key=lambda pair: commission_priority(self.data.task(str(pair[1])) or {}))
|
||||
for offered_city, offered_key in ranked:
|
||||
city, key = _integer(offered_city), str(offered_key)
|
||||
info = self.data.task(key) or {}
|
||||
if info.get("type") != 4:
|
||||
continue
|
||||
support_blocked = False
|
||||
reason = ("城市编号无效" if city <= 0 else
|
||||
f"策略限定城市 {quest_policy.city}" if quest_policy.city and city != quest_policy.city else
|
||||
"城市尚未解锁" if not snapshot.city_unlocked(city) else
|
||||
"委托列表已跨日,等待刷新确认" if recorded is not None and recorded != today and account["commissions"]["day"] != today else
|
||||
"当日接取次数已用完" if remaining <= 0 else
|
||||
"自动委托未启用" if not quest_policy.enabled else "自动接取未启用" if not quest_policy.accept else
|
||||
"存在未确认请求,等待核对" if account["pending"] else
|
||||
"该委托已接取或已完成" if key in active or key in finished else
|
||||
"已有委托优先完成" if has_active else "")
|
||||
if not reason:
|
||||
ready, reason = self._commission_offer_ready(snapshot, quest_policy, policy, ranch_policy, info)
|
||||
if ready:
|
||||
reason = ""
|
||||
if accept_supported is not None:
|
||||
result = accept_supported(key)
|
||||
supported, detail = result if isinstance(result, tuple) else (result, "")
|
||||
if not supported:
|
||||
reason = detail or "委托后续战斗或条件当前无法自动完成"
|
||||
support_blocked = True
|
||||
rows.append({"task_type_id": key, "name": info.get("name", key), "city": city,
|
||||
"expected_ke": -commission_priority(info), "eligible": not reason, "reason": reason or "可接取",
|
||||
"blocked_by_support": support_blocked})
|
||||
return rows
|
||||
|
||||
def commission_rows(self, snapshot, quest_policy, ranch_policy, *, battle_policy=None):
|
||||
policy = self._commission_policy(quest_policy, battle_policy)
|
||||
return [row for row in self.rows(snapshot, policy, ranch_policy, quest_policy=quest_policy)
|
||||
|
||||
@@ -15,6 +15,24 @@ def commission_priority(info):
|
||||
return -reward
|
||||
|
||||
|
||||
def commission_selection(info, offers, rejected):
|
||||
"""Explain this selection using the offers actually examined, across cities."""
|
||||
reward = -commission_priority(info)
|
||||
higher = [row for row in rejected if row["expected_ke"] > reward]
|
||||
has_twenty = any(row["expected_ke"] == 20 for row in offers)
|
||||
if reward >= 20:
|
||||
code, reason = "highest_reward", f"按氪金奖励优先,选择当前可处理的 {reward} 氪金委托"
|
||||
elif not has_twenty:
|
||||
code, reason = "no_20_offered", f"本次候选未提供20氪金委托,按奖励优先选择 {reward} 氪金委托"
|
||||
if higher:
|
||||
reason += ";" + ";".join(f"{row['name']}({row['expected_ke']}氪金):{row['reason']}" for row in higher)
|
||||
else:
|
||||
code = "20_ineligible"
|
||||
details = ";".join(f"{row['name']}({row['expected_ke']}氪金):{row['reason']}" for row in higher)
|
||||
reason = f"较高奖励委托当前不可接取,选择 {reward} 氪金委托" + (";" + details if details else "")
|
||||
return {"selection_code": code, "selection_reason": reason, "higher_reward_blockers": higher}
|
||||
|
||||
|
||||
def indexed(value, key, default=None):
|
||||
if isinstance(value, dict):
|
||||
return value.get(str(key), value.get(key, default))
|
||||
@@ -84,6 +102,7 @@ class TaskPlanner:
|
||||
def __init__(self, catalog):
|
||||
self.catalog = catalog
|
||||
self.guard = Planner(catalog)
|
||||
self.commission_selection = {}
|
||||
|
||||
def current(self, snapshot):
|
||||
infos = self.catalog.data.get("task_info", {})
|
||||
@@ -161,6 +180,7 @@ class TaskPlanner:
|
||||
return rows
|
||||
|
||||
def plan(self, snapshot, policy, ranch, *, include_active=True, accept_supported=None):
|
||||
self.commission_selection = {}
|
||||
if not policy.enabled:
|
||||
return []
|
||||
history = snapshot.raw.get("history", {})
|
||||
@@ -176,31 +196,42 @@ class TaskPlanner:
|
||||
index, steps = int(task.get("curStep", 1)) - 1, info.get("steps", [])
|
||||
payload = {"taskId": int(task["id"]), "taskTypeId": str(task["typeId"])}
|
||||
if steps and index >= len(steps):
|
||||
return [Action("quest_complete", f"领取委托奖励:{info['name']}", "taskService/taskComplete", payload)]
|
||||
return [Action("quest_complete", f"领取委托奖励:{info['name']}(预计{-commission_priority(info)}氪金)", "taskService/taskComplete", payload)]
|
||||
if 0 <= index < len(steps):
|
||||
ready, ids, _ = self.requirement(snapshot, steps[index], task, policy, ranch)
|
||||
if ready:
|
||||
return [Action("quest_step", f"推进委托:{info['name']}", "taskService/taskCompleteStep", payload | {"removeIds": ids or None})]
|
||||
return [Action("quest_step", f"推进委托:{info['name']}(预计{-commission_priority(info)}氪金)", "taskService/taskCompleteStep", payload | {"removeIds": ids or None})]
|
||||
if current_tasks or not policy.accept or int(history.get("loopTaskNum", 0)) <= 0:
|
||||
return []
|
||||
current = {str(t["typeId"]) for t in self.current(snapshot)}
|
||||
offers = sorted(self.rows(snapshot, policy, ranch), key=lambda row: commission_priority(
|
||||
self.catalog.data["task_info"][row[0]]))
|
||||
candidates, rejected = [], []
|
||||
for type_id, name, state, _, meta in offers:
|
||||
if "city" not in meta or type_id in current:
|
||||
continue
|
||||
city = meta["city"]
|
||||
if policy.city and city != policy.city or not snapshot.city_unlocked(city):
|
||||
continue
|
||||
info = self.catalog.data["task_info"][type_id]
|
||||
if info.get("closed") or not condition_ok((info.get("startStep") or {}).get("condition"), snapshot):
|
||||
candidate = {"task_type_id": type_id, "name": name, "city": city, "expected_ke": -commission_priority(info)}
|
||||
candidates.append(candidate)
|
||||
reason = (f"策略限定城市 {policy.city}" if policy.city and city != policy.city else
|
||||
"城市尚未解锁" if not snapshot.city_unlocked(city) else "委托已关闭" if info.get("closed") else
|
||||
"接取前置条件未满足" if not condition_ok((info.get("startStep") or {}).get("condition"), snapshot) else "")
|
||||
if reason:
|
||||
rejected.append(candidate | {"reason": reason})
|
||||
continue
|
||||
steps = info.get("steps", [])
|
||||
supported = accept_supported(type_id) if accept_supported else all(
|
||||
(s.get("statusType") in ("passStage", "battle") and policy.battle_tasks)
|
||||
or self.requirement(snapshot, s, {}, policy, ranch)[0] for s in steps)
|
||||
if supported:
|
||||
return [Action("quest_accept", f"接取委托:{name}", "taskService/taskLoopReceive", {"taskTypeId": type_id, "city": city})]
|
||||
self.commission_selection = {"task_type_id": type_id, "city": city,
|
||||
**commission_selection(info, candidates, rejected)}
|
||||
return [Action("quest_accept", f"接取委托:{name}(预计{-commission_priority(info)}氪金);" + self.commission_selection["selection_reason"],
|
||||
"taskService/taskLoopReceive", {"taskTypeId": type_id, "city": city})]
|
||||
reason = next((self.requirement(snapshot, step, {}, policy, ranch)[2] for step in steps
|
||||
if not self.requirement(snapshot, step, {}, policy, ranch)[0]), "委托后续步骤当前无法自动完成")
|
||||
rejected.append(candidate | {"reason": reason})
|
||||
return []
|
||||
|
||||
def reservations(self, snapshot):
|
||||
|
||||
@@ -0,0 +1,405 @@
|
||||
"""Offline commission observability; every game transport is a fake."""
|
||||
from copy import deepcopy
|
||||
from datetime import datetime
|
||||
import json
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from ranch_assistant.commission_history import CommissionHistory, beijing_day
|
||||
from ranch_assistant.engine import Engine
|
||||
from ranch_assistant.game_data import ProgressionData
|
||||
from ranch_assistant.model import Catalog, Snapshot
|
||||
from ranch_assistant.quests import CN, QuestPolicy, TaskPlanner
|
||||
from ranch_assistant.progression import ProgressionPlanner
|
||||
from ranch_assistant.tests.test_progression import config, snapshot, step, task
|
||||
|
||||
|
||||
class CommissionHistoryTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.folder = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="commission-offline-")))
|
||||
self.catalog = Catalog()
|
||||
self.tasks = {str(400 + number): task(str(400 + number), type=4,
|
||||
name=name, reward={"ke": reward}) for number, (name, reward) in
|
||||
enumerate((("低奖励委托", 10), ("中等奖励委托", 15), ("高奖励委托", 20)))}
|
||||
self.data = ProgressionData(config(self.tasks))
|
||||
self.snapshot = snapshot(currentTasks=[])
|
||||
self.snapshot.raw["history"].update(loopTaskTime=self.snapshot.now, loopTaskNum=6,
|
||||
loopTask={"1": ["400", "401"], "2": ["402"]}, unlockCity={"1": True, "2": True})
|
||||
self.client = Mock()
|
||||
self.client.call.side_effect = AssertionError("unexpected offline game operation")
|
||||
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.snapshot.raw), self.snapshot.now)
|
||||
|
||||
def engine(self):
|
||||
engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data)
|
||||
engine.snapshot = self.snapshot
|
||||
engine.quest_policy = QuestPolicy(enabled=True)
|
||||
return engine
|
||||
|
||||
def record(self, engine, *, kind="progression_complete", path="taskService/taskComplete",
|
||||
task_id=51, type_id="402", response=None, outcome="task"):
|
||||
record = engine.battle_journal.begin(engine.snapshot, {"kind": kind, "description": "旧任务操作",
|
||||
"path": path, "payload": {}, "task_id": task_id, "task_type_id": type_id, "step_number": 1})
|
||||
if response is not None:
|
||||
engine.battle_journal.update(record, "acknowledged", response=response, response_confirmed=True)
|
||||
if outcome is not None:
|
||||
engine.battle_journal.finish(engine.snapshot, record, outcome)
|
||||
return record
|
||||
|
||||
def receipt(self, attempt, *, kind="complete", task_id=51, type_id="402", when=None, role=1,
|
||||
response=None, outcome="task", phase="done", **extra):
|
||||
when = self.snapshot.now if when is None else when
|
||||
paths = {"accept": "taskService/taskLoopReceive", "complete": "taskService/taskComplete",
|
||||
"step": "taskService/taskCompleteStep", "navigate": "", "dialogue": "", "farm": "battleService/battleEnd"}
|
||||
originals = {"accept": "progression_loop_accept", "complete": "progression_complete",
|
||||
"step": "progression_step", "navigate": "progression_navigate", "dialogue": "progression_dialogue", "farm": "map_battle"}
|
||||
return {"attempt_id": attempt, "role_id": str(role), "kind": originals[kind], "path": paths[kind],
|
||||
"task_type_id": type_id, "task_id": task_id, "step_number": 1, "phase": phase, "outcome": outcome,
|
||||
"timestamp": when, "finished_at": when if phase == "done" else None, "updated_at": when,
|
||||
"response": {"resCode": 0} if response is None else response,
|
||||
"response_confirmed": phase == "done" and outcome == "task", "payload": {},
|
||||
"baseline": {"tasks": []}, **extra}
|
||||
|
||||
def ledger(self, records, *, now=None, role=1, **options):
|
||||
ledger = CommissionHistory(self.folder / "history.json", clock=lambda: now or self.snapshot.now, **options)
|
||||
ledger.ingest(role, records, lambda key: self.tasks.get(key), self.snapshot)
|
||||
return ledger
|
||||
|
||||
def test_early_battle_return_never_relogs_previous_commission_claim(self):
|
||||
engine = self.engine()
|
||||
self.record(engine, response={"resCode": 0, "reward": {"ke": 20}})
|
||||
engine.battles.run = Mock(return_value="体力不足,未开始战斗")
|
||||
intent = {"kind": "progression_battle", "task_type_id": "402", "task_id": 52,
|
||||
"step_number": 1, "description": "下一份委托战斗"}
|
||||
with patch.object(engine, "read_snapshot"), patch.object(engine, "_refresh_progression_cache"):
|
||||
_, _, message = engine._run_progression_intent(intent)
|
||||
self.assertEqual(message, "体力不足,未开始战斗")
|
||||
self.client.call.assert_not_called()
|
||||
|
||||
def test_receipts_persist_instance_and_expected_reward_separately_from_actual(self):
|
||||
records = [self.receipt("a", kind="accept", task_id=0, type_id="401",
|
||||
response={"resCode": 0, "task": {"id": 51, "typeId": "401", "curStep": 1}}),
|
||||
self.receipt("c", type_id="401", response={"resCode": 0, "reward": {"ke": 7}})]
|
||||
ledger = self.ledger(records)
|
||||
dto = ledger.query(1)
|
||||
self.assertEqual(dto["summary"], {"accepted_count": 1, "completed_count": 1, "pending_count": 0,
|
||||
"expected_ke": 15, "confirmed_ke": 7, "unknown_reward_count": 0})
|
||||
self.assertEqual(len(dto["rows"]), 1)
|
||||
self.assertEqual((dto["rows"][0]["expected_ke"], dto["rows"][0]["confirmed_ke"]), (15, 7))
|
||||
restored = CommissionHistory(self.folder / "history.json")
|
||||
restored.ingest(1, records, self.tasks.get)
|
||||
self.assertEqual(restored.query(1)["summary"], dto["summary"])
|
||||
self.assertIn("实际获得7氪金", dto["rows"][0]["last_action"])
|
||||
|
||||
def test_wallet_total_and_missing_reward_never_become_confirmed_delta(self):
|
||||
self.snapshot.raw["master"]["ke"] = 9000
|
||||
records = [self.receipt("c", response={"resCode": 0, "ke": 9000, "master": {"ke": 9000}})]
|
||||
dto = self.ledger(records).query(1)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 1)
|
||||
self.assertEqual(dto["summary"]["confirmed_ke"], 0)
|
||||
self.assertEqual(dto["summary"]["unknown_reward_count"], 1)
|
||||
self.assertIsNone(dto["rows"][0]["confirmed_ke"])
|
||||
|
||||
def test_step_and_farming_loot_never_count_as_final_commission_reward(self):
|
||||
records = [self.receipt("s", kind="step", response={"resCode": 0, "reward": {"ke": 5}}),
|
||||
self.receipt("f", kind="farm", task_id=0, type_id="", outcome="win", source_task_id=51,
|
||||
source_task_type_id="402", settlement_confirmed=True,
|
||||
response={"resCode": 0, "stageReward": {"ke": 20}, "reward": {"ke": 20}})]
|
||||
dto = self.ledger(records).query(1)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 0)
|
||||
self.assertEqual(dto["summary"]["confirmed_ke"], 0)
|
||||
self.assertEqual({event["kind"] for event in dto["events"]}, {"step", "farm"})
|
||||
self.assertEqual(len(dto["rows"]), 1)
|
||||
|
||||
def test_snapshot_presence_and_pass_task_flag_create_no_history(self):
|
||||
self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "402", "curStep": 2}]
|
||||
self.snapshot.raw["history"]["passTask"] = {"402": True}
|
||||
engine = self.engine()
|
||||
dto = engine.commission_history()
|
||||
self.assertEqual(dto["rows"], [])
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 0)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 0)
|
||||
self.client.call.assert_not_called()
|
||||
|
||||
def test_reconciled_claim_without_receipt_remains_unknown(self):
|
||||
self.snapshot.raw["history"]["passTask"] = {"402": True}
|
||||
dto = self.ledger([self.receipt("c", phase="done", outcome="reconciled", response=None)]).query(1)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 0)
|
||||
self.assertEqual(dto["rows"][0]["status"], "unknown")
|
||||
self.assertIsNone(dto["rows"][0]["confirmed_ke"])
|
||||
|
||||
def test_reconciled_acceptance_needs_new_instance_and_does_not_invent_reason(self):
|
||||
self.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "402", "curStep": 1}]
|
||||
record = self.receipt("a", kind="accept", task_id=0, outcome="reconciled", response=None,
|
||||
baseline={"tasks": [{"id": 51, "typeId": "402"}]},
|
||||
commission_task={"id": 52, "typeId": "402", "curStep": 1})
|
||||
ledger = self.ledger([record])
|
||||
dto = ledger.query(1)
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 1)
|
||||
self.assertEqual(dto["rows"][0]["task_id"], 52)
|
||||
self.assertEqual(dto["rows"][0]["selection_code"], "unknown")
|
||||
self.snapshot.raw["currentTasks"] = []
|
||||
restored = CommissionHistory(self.folder / "history.json")
|
||||
restored.ingest(1, [record], self.tasks.get, self.snapshot)
|
||||
self.assertEqual(restored.query(1)["summary"]["accepted_count"], 1)
|
||||
|
||||
def test_old_reconciled_acceptance_cannot_bind_to_unrelated_current_instance(self):
|
||||
self.snapshot.raw["currentTasks"] = [{"id": 99, "typeId": "402", "curStep": 1}]
|
||||
stamp = self.snapshot.now - 2 * 86400
|
||||
ledger = self.ledger([self.receipt("old-a", kind="accept", task_id=0,
|
||||
when=stamp, outcome="reconciled", response=None)])
|
||||
dto = ledger.query(1, beijing_day(stamp))
|
||||
self.assertIsNone(dto["rows"][0]["task_id"])
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 0)
|
||||
|
||||
def test_fresh_snapshot_reconciliation_captures_exact_new_acceptance_instance(self):
|
||||
engine = self.engine()
|
||||
record = self.record(engine, kind="progression_loop_accept", path="taskService/taskLoopReceive",
|
||||
task_id=0, outcome=None)
|
||||
engine.battle_journal.update(record, "unknown")
|
||||
self.snapshot.raw["currentTasks"] = [{"id": 52, "typeId": "402", "curStep": 1}]
|
||||
engine.read_snapshot(sync_master=False)
|
||||
dto = engine.commission_history()
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 1)
|
||||
self.assertEqual(dto["rows"][0]["task_id"], 52)
|
||||
self.client.call.assert_not_called()
|
||||
|
||||
def test_acceptance_validates_numeric_ids_and_instance_identity(self):
|
||||
for identifier, valid in (("51", True), (True, False), (51.5, False), ("bad", False)):
|
||||
with self.subTest(identifier=identifier):
|
||||
ledger = CommissionHistory()
|
||||
ledger.ingest(1, [self.receipt(str(identifier), kind="accept", task_id=0,
|
||||
response={"task": {"id": identifier, "typeId": "402", "curStep": "1"}})], self.tasks.get)
|
||||
self.assertEqual(ledger.query(1)["summary"]["accepted_count"], int(valid))
|
||||
ledger = CommissionHistory()
|
||||
ledger.ingest(1, [self.receipt("wrong", kind="accept", task_id=0,
|
||||
response={"resCode": 0, "task": {"id": 52, "typeId": "401", "curStep": 1}})], self.tasks.get)
|
||||
self.assertEqual(ledger.query(1)["summary"]["accepted_count"], 0)
|
||||
|
||||
def test_duplicate_attempts_and_receipts_deduplicate_daily_counts_by_instance(self):
|
||||
records = [self.receipt("a1", kind="accept", task_id=0,
|
||||
response={"task": {"id": 51, "typeId": "402", "curStep": 1}}),
|
||||
self.receipt("a2", kind="accept", task_id=0,
|
||||
response={"task": {"id": "51", "typeId": "402", "curStep": 1}}),
|
||||
self.receipt("c1", response={"reward": {"ke": 20}}),
|
||||
self.receipt("c2", task_id="51", response={"reward": {"ke": 20}})]
|
||||
ledger = self.ledger(records)
|
||||
ledger.ingest(1, records, self.tasks.get)
|
||||
dto = ledger.query(1)
|
||||
self.assertEqual(len(dto["events"]), 4)
|
||||
self.assertEqual(len(dto["rows"]), 1)
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 1)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 1)
|
||||
self.assertEqual(dto["summary"]["expected_ke"], 20)
|
||||
self.assertEqual(dto["summary"]["confirmed_ke"], 20)
|
||||
|
||||
def test_beijing_midnight_repeat_types_and_cross_day_duplicate_claims(self):
|
||||
midnight = datetime(2026, 11, 13, tzinfo=CN).timestamp()
|
||||
records = [self.receipt("old", when=midnight - 1, response={"reward": {"ke": 20}}),
|
||||
self.receipt("duplicate", when=midnight + 1, response={"reward": {"ke": 20}}),
|
||||
self.receipt("new", task_id=52, when=midnight + 2, response={"reward": {"ke": 20}})]
|
||||
ledger = self.ledger(records, now=midnight + 10)
|
||||
self.assertEqual(beijing_day(midnight - 1), "2026-11-12")
|
||||
self.assertEqual(ledger.query(1)["date"], "2026-11-13")
|
||||
self.assertEqual(ledger.query(1, "2026-11-12")["summary"]["confirmed_ke"], 20)
|
||||
dto = ledger.query(1)
|
||||
self.assertEqual(len(dto["rows"]), 2)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 1)
|
||||
self.assertEqual(dto["summary"]["confirmed_ke"], 20)
|
||||
self.assertEqual(len({row["id"] for row in dto["rows"]}), 2)
|
||||
self.assertEqual(dto["dates"], ["2026-11-13", "2026-11-12"])
|
||||
|
||||
def test_pending_and_failure_states_never_claim_success(self):
|
||||
for phase, outcome, expected in (("request_pending", "", "pending"), ("unknown", "", "unknown"),
|
||||
("done", "cancelled", "cancelled"), ("done", "loss", "failed")):
|
||||
with self.subTest(expected=expected):
|
||||
ledger = CommissionHistory()
|
||||
ledger.ingest(1, [self.receipt(expected, kind="step", phase=phase, outcome=outcome)], self.tasks.get)
|
||||
dto = ledger.query(1)
|
||||
self.assertEqual(dto["rows"][0]["status"], expected)
|
||||
self.assertEqual(dto["summary"]["completed_count"], 0)
|
||||
self.assertNotIn(";已确认", dto["events"][0]["description"])
|
||||
|
||||
def test_existing_task_action_is_not_counted_as_accepted_today(self):
|
||||
dto = self.ledger([self.receipt("s", kind="step")]).query(1)
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 0)
|
||||
self.assertIsNone(dto["rows"][0]["accepted_at"])
|
||||
self.assertEqual(dto["rows"][0]["selection_code"], "already_accepted")
|
||||
|
||||
def test_role_isolation_and_dto_mutation_cannot_change_history(self):
|
||||
ledger = self.ledger([self.receipt("c", response={"reward": {"ke": 20}})])
|
||||
self.assertEqual(ledger.query(2)["rows"], [])
|
||||
dto = ledger.query(1)
|
||||
dto["rows"][0]["events"][0]["description"] = "changed"
|
||||
dto["summary"]["confirmed_ke"] = 10000
|
||||
self.assertEqual(ledger.query(1)["summary"]["confirmed_ke"], 20)
|
||||
self.assertNotEqual(ledger.query(1)["events"][0]["description"], "changed")
|
||||
|
||||
def test_bounded_retention_and_journal_rollover_preserve_imported_receipts(self):
|
||||
now = self.snapshot.now
|
||||
records = [self.receipt(str(number), task_id=number + 1, when=now - number,
|
||||
response={"reward": {"ke": 20}}) for number in range(8)]
|
||||
records.append(self.receipt("ancient", task_id=99, when=now - 91 * 86400, response={"reward": {"ke": 20}}))
|
||||
ledger = self.ledger(records, max_events=4)
|
||||
self.assertEqual(len(ledger.query(1)["events"]), 4)
|
||||
ledger.ingest(1, [], self.tasks.get)
|
||||
restored = CommissionHistory(self.folder / "history.json", max_events=4)
|
||||
self.assertEqual(restored.query(1)["summary"]["completed_count"], 4)
|
||||
|
||||
def test_history_reads_do_not_reload_journal_or_load_full_progression(self):
|
||||
engine = self.engine()
|
||||
engine.game_data = None
|
||||
self.record(engine, type_id="100", response={"reward": {"ke": 20}})
|
||||
with patch("ranch_assistant.game_data.load_progression_data", side_effect=AssertionError("unexpected full load")), \
|
||||
patch.object(engine.battle_journal, "records", side_effect=AssertionError("unexpected payload copy")), \
|
||||
patch.object(engine.battle_journal, "reload", side_effect=AssertionError("unexpected journal reload")):
|
||||
engine.commission_history()
|
||||
engine.commission_history()
|
||||
self.client.call.assert_not_called()
|
||||
|
||||
def test_history_write_failure_preserves_success_and_recovers_without_game_retry(self):
|
||||
engine = self.engine()
|
||||
engine._ensure_progression()
|
||||
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
|
||||
self.client.call.side_effect = lambda *args: {"resCode": 0, "task": {"id": 51, "typeId": "402", "curStep": 1}}
|
||||
with patch.object(engine._commission_history, "_save", side_effect=OSError("fixture disk full")):
|
||||
message = engine._execute_task_intent(intent)
|
||||
self.assertIn("已确认", message)
|
||||
dto = engine.commission_history()
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 1)
|
||||
self.assertIn("暂未写入磁盘", dto["error"])
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
self.assertIsNone(engine.battle_journal.pending(self.snapshot))
|
||||
recovered = engine.commission_history()
|
||||
self.assertEqual(recovered["error"], "")
|
||||
self.assertTrue(engine._commission_history.path.exists())
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
|
||||
def test_acceptance_timeout_stays_unknown_and_restart_never_replays(self):
|
||||
engine = self.engine()
|
||||
engine._ensure_progression()
|
||||
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
|
||||
self.client.call.side_effect = TimeoutError("offline timeout")
|
||||
with self.assertRaises(TimeoutError):
|
||||
engine._execute_task_intent(intent)
|
||||
self.assertEqual(engine.commission_history()["rows"][0]["status"], "unknown")
|
||||
restored = self.engine()
|
||||
restored._refresh_progression_cache(force=True)
|
||||
_, _, message = restored._run_progression_intent()
|
||||
self.assertIn("待核对", message)
|
||||
self.assertEqual(self.client.call.call_count, 1)
|
||||
self.assertEqual(restored.commission_history()["summary"]["accepted_count"], 0)
|
||||
|
||||
def test_accepted_reply_without_task_is_unknown_in_both_log_and_history(self):
|
||||
engine = self.engine()
|
||||
engine._ensure_progression()
|
||||
intent = engine.progression_planner.commission_plan(self.snapshot, engine.quest_policy, engine.policy)[0]
|
||||
self.client.call.side_effect = lambda *args: {"resCode": 0}
|
||||
message = engine._execute_task_intent(intent)
|
||||
self.assertIn("结果未知", message)
|
||||
self.assertNotIn(";已确认", message)
|
||||
self.assertEqual(engine.commission_history()["summary"]["accepted_count"], 0)
|
||||
self.assertIsNotNone(engine.battle_journal.pending(self.snapshot))
|
||||
|
||||
def test_offer_diagnostics_and_selection_explain_locked_city_and_runtime(self):
|
||||
engine = self.engine()
|
||||
self.snapshot.raw["history"]["unlockCity"]["2"] = False
|
||||
engine._refresh_progression_cache(force=True)
|
||||
selected = engine.progression_planner.commission_selection
|
||||
self.assertEqual(selected["task_type_id"], "401")
|
||||
self.assertEqual(selected["selection_code"], "20_ineligible")
|
||||
self.assertIn("城市尚未解锁", selected["selection_reason"])
|
||||
with patch.object(engine, "_battle_capability", side_effect=AssertionError("UI must not inspect runtime")):
|
||||
for _ in range(3):
|
||||
rows = engine.commission_offer_diagnostics()
|
||||
high = next(row for row in rows if row["task_type_id"] == "402")
|
||||
self.assertFalse(high["eligible"])
|
||||
self.assertEqual(high["reason"], "城市尚未解锁")
|
||||
self.client.call.assert_not_called()
|
||||
engine._commission_offer_supported = Mock(side_effect=lambda key: str(key) != "402")
|
||||
engine._commission_offer_reason = "保护目标规则暂不支持"
|
||||
self.snapshot.raw["history"]["unlockCity"]["2"] = True
|
||||
engine._refresh_progression_cache(force=True)
|
||||
self.assertIn("保护目标规则暂不支持", engine.progression_planner.commission_selection["selection_reason"])
|
||||
|
||||
def test_quota_and_city_filter_diagnostics_do_not_claim_receivable(self):
|
||||
engine = self.engine()
|
||||
engine.quest_policy.city = 1
|
||||
engine._refresh_progression_cache(force=True)
|
||||
high = next(row for row in engine.commission_offer_diagnostics() if row["task_type_id"] == "402")
|
||||
self.assertFalse(high["eligible"])
|
||||
self.assertIn("策略限定城市", high["reason"])
|
||||
self.snapshot.raw["history"]["loopTaskNum"] = 0
|
||||
engine._refresh_progression_cache(force=True)
|
||||
rows = engine.commission_offer_diagnostics()
|
||||
self.assertTrue(all(not row["eligible"] for row in rows))
|
||||
self.assertIn("当日接取次数已用完", next(row for row in rows if row["city"] == 1)["reason"])
|
||||
|
||||
def test_unchanged_snapshot_replans_after_beijing_midnight_grace(self):
|
||||
engine = self.engine()
|
||||
before = datetime(2026, 11, 13, 23, 59, 59, tzinfo=CN).timestamp()
|
||||
self.snapshot.raw["history"].update(loopTaskTime=before, loopTaskNum=0)
|
||||
original = deepcopy(self.snapshot.raw)
|
||||
with patch("ranch_assistant.model.time.time", return_value=before):
|
||||
engine._refresh_progression_cache(force=True)
|
||||
self.assertFalse(any(intent.kind == "progression_loop_reset" for intent in engine._progression_intents))
|
||||
with patch("ranch_assistant.model.time.time", return_value=before + 12):
|
||||
engine._refresh_progression_cache()
|
||||
self.assertEqual(self.snapshot.raw, original)
|
||||
self.assertTrue(any(intent.kind == "progression_loop_reset" for intent in engine._progression_intents))
|
||||
|
||||
def test_no_twenty_fallback_still_explains_rejected_fifteen(self):
|
||||
self.snapshot.raw["history"]["loopTask"] = {"1": ["400", "401"]}
|
||||
self.tasks["401"]["closed"] = True
|
||||
for planner in (ProgressionPlanner(self.catalog, config(self.tasks)), TaskPlanner(self.catalog)):
|
||||
self.catalog.data["task_info"] = self.tasks
|
||||
if isinstance(planner, TaskPlanner):
|
||||
action = planner.plan(self.snapshot, QuestPolicy(enabled=True), self.engine().policy)[0]
|
||||
self.assertEqual(action.payload["taskTypeId"], "400")
|
||||
else:
|
||||
self.assertEqual(planner.commission_plan(self.snapshot, QuestPolicy(enabled=True), self.engine().policy)[0].task_type_id, "400")
|
||||
self.assertEqual(planner.commission_selection["selection_code"], "no_20_offered")
|
||||
self.assertIn("未提供20", planner.commission_selection["selection_reason"])
|
||||
self.assertIn("委托已关闭", planner.commission_selection["selection_reason"])
|
||||
|
||||
def test_step_log_names_consumed_and_only_checked_items(self):
|
||||
self.catalog.data.setdefault("item_names", {})["30001"] = "石块"
|
||||
for remove, expected in ((True, "提交石块×5"), (False, "核对持有石块×5")):
|
||||
with self.subTest(remove=remove):
|
||||
engine = Engine(self.catalog, self.client, game_data=ProgressionData(config({"402": task("402", type=4,
|
||||
reward={"ke": 20}, steps=[step("getItem", statusValue={"type": "30001", "num": 5, "remove": remove})])})))
|
||||
engine.snapshot = self.snapshot
|
||||
intent = {"kind": "quest_step", "task_id": 51, "task_type_id": "402", "step_number": 1,
|
||||
"path": "taskService/taskCompleteStep", "payload": {}, "description": "提交步骤"}
|
||||
record = engine.battle_journal.begin(self.snapshot, intent)
|
||||
engine._journal_commission(record, intent, legacy=True)
|
||||
engine.battle_journal.update(record, "acknowledged", response={"resCode": 0}, response_confirmed=True)
|
||||
engine.battle_journal.finish(self.snapshot, record, "task")
|
||||
dto = engine.commission_history()
|
||||
self.assertIn(expected, dto["events"][0]["description"])
|
||||
self.assertIn("20氪金", dto["events"][0]["description"])
|
||||
|
||||
def test_navigation_and_dialogue_are_local_evidence_with_honest_labels(self):
|
||||
records = [self.receipt("n", kind="navigate", outcome="local", description="前往王城市场"),
|
||||
self.receipt("d", kind="dialogue", outcome="local", description="与妮娜对话")]
|
||||
dto = self.ledger(records).query(1)
|
||||
self.assertEqual({event["kind"] for event in dto["events"]}, {"navigate", "dialogue"})
|
||||
self.assertTrue(all(event["confirmation"] == "local" for event in dto["events"]))
|
||||
self.assertEqual(dto["summary"]["accepted_count"], 0)
|
||||
|
||||
def test_invalid_day_and_corrupt_history_preserve_file(self):
|
||||
ledger = self.ledger([])
|
||||
for day in ("20261113", "2026-02-30", "2026-1-1", 20261113):
|
||||
with self.subTest(day=day), self.assertRaises(ValueError):
|
||||
ledger.query(1, day)
|
||||
damaged = self.folder / "damaged.json"
|
||||
damaged.write_text("not-json", encoding="utf-8")
|
||||
ledger = CommissionHistory(damaged)
|
||||
ledger.ingest(1, [self.receipt("c", response={"reward": {"ke": 20}})], self.tasks.get)
|
||||
self.assertIn("无法读取", ledger.query(1)["error"])
|
||||
self.assertEqual(damaged.read_text(encoding="utf-8"), "not-json")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,369 @@
|
||||
"""Independent offline review repros; all records and accounts are synthetic."""
|
||||
from copy import deepcopy
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from ranch_assistant.battles import BattleJournal
|
||||
from ranch_assistant.commission_history import CommissionHistory, journal_event
|
||||
from ranch_assistant.engine import Engine
|
||||
from ranch_assistant.game_data import ProgressionData
|
||||
from ranch_assistant.model import Catalog, Policy, Snapshot
|
||||
from ranch_assistant.progression import ProgressionPlanner
|
||||
from ranch_assistant.quests import QuestPolicy
|
||||
|
||||
|
||||
NOW = datetime(2026, 11, 13, 4, tzinfo=timezone.utc).timestamp()
|
||||
DAY = "2026-11-13"
|
||||
INFO = {"id": "review20", "type": 4, "name": "Review commission", "reward": {"ke": 20},
|
||||
"startStep": {"condition": {}}, "steps": [{"statusType": "none", "statusValue": {}}]}
|
||||
|
||||
|
||||
def review_snapshot(role=71, tasks=()):
|
||||
return Snapshot({"master": {"id": role, "level": 20, "money": 2000, "ti": 50, "ke": 99999},
|
||||
"currentTasks": deepcopy(list(tasks)), "history": {"unlockCity": {"1": True}},
|
||||
"items": [], "monsters": [], "stacks": [], "rooms": [], "teams": []})
|
||||
|
||||
|
||||
def review_record(attempt="review-claim", *, kind="complete", task_id=81, timestamp=NOW, **changes):
|
||||
record = {"attempt_id": attempt, "role_id": "71", "task_id": task_id, "task_type_id": "review20",
|
||||
"kind": {"accept": "progression_loop_accept", "complete": "progression_reward",
|
||||
"step": "progression_step", "battle": "progression_battle"}[kind],
|
||||
"path": {"accept": "taskService/taskLoopReceive", "complete": "taskService/taskComplete",
|
||||
"step": "taskService/taskCompleteStep", "battle": ""}[kind],
|
||||
"timestamp": timestamp, "updated_at": timestamp, "finished_at": timestamp,
|
||||
"phase": "done", "outcome": "task", "payload": {},
|
||||
"commission": {"name": INFO["name"], "expected_ke": 20, "city": 1,
|
||||
"selection_code": "highest_reward", "selection_reason": "review-selected"},
|
||||
"baseline": {"tasks": []}, "response_confirmed": True,
|
||||
"response": {"resCode": 0, "reward": {"ke": 20}}}
|
||||
if kind == "accept":
|
||||
record.update(task_id=None, response={"resCode": 0,
|
||||
"task": {"id": task_id, "typeId": "review20", "curStep": 1}})
|
||||
record.update(changes)
|
||||
return record
|
||||
|
||||
|
||||
class CommissionHistoryIndependentReviewTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.folder = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="commission-independent-review-")))
|
||||
self.enterContext(patch("socket.socket.connect", side_effect=AssertionError("offline review forbids network")))
|
||||
self.history = CommissionHistory(self.folder / "history.json", clock=lambda: NOW)
|
||||
|
||||
def ingest(self, records, snapshot=None, history=None, role="71"):
|
||||
target = history if history is not None else self.history
|
||||
target.ingest(role, records, lambda key: INFO, snapshot)
|
||||
return target.query(role, DAY)
|
||||
|
||||
def test_cancelled_accept_with_task_body_is_never_confirmed(self):
|
||||
record = review_record(kind="accept", outcome="cancelled")
|
||||
event = journal_event(record, INFO, review_snapshot())
|
||||
self.assertEqual(event["status"], "cancelled")
|
||||
result = self.ingest([record])
|
||||
self.assertEqual(result["summary"]["accepted_count"], 0)
|
||||
self.assertEqual(result["summary"]["expected_ke"], 0)
|
||||
self.assertIsNone(result["rows"][0]["accepted_at"])
|
||||
|
||||
def test_pending_receipt_body_does_not_count_as_a_claim(self):
|
||||
record = review_record(phase="request_pending", outcome="", response_confirmed=False)
|
||||
result = self.ingest([record])
|
||||
self.assertEqual(result["summary"]["completed_count"], 0)
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
||||
self.assertEqual(result["summary"]["pending_count"], 1)
|
||||
self.assertIsNone(result["rows"][0]["confirmed_ke"])
|
||||
|
||||
def test_cancelled_and_failed_outcomes_stay_terminal_in_aggregate(self):
|
||||
for outcome, status in (("cancelled", "cancelled"), ("unsupported", "cancelled"), ("loss", "failed")):
|
||||
with self.subTest(outcome=outcome):
|
||||
ledger = CommissionHistory(clock=lambda: NOW)
|
||||
result = self.ingest([review_record(kind="battle", outcome=outcome)], history=ledger)
|
||||
self.assertEqual(result["events"][0]["status"], status)
|
||||
self.assertEqual(result["rows"][0]["status"], status)
|
||||
self.assertEqual(result["summary"]["pending_count"], 0)
|
||||
self.assertEqual(result["summary"]["completed_count"], 0)
|
||||
|
||||
def test_unknown_result_stays_unknown_and_pending_in_summary(self):
|
||||
result = self.ingest([review_record(phase="task_unknown", outcome="", response=None,
|
||||
response_confirmed=False)])
|
||||
self.assertEqual(result["rows"][0]["status"], "unknown")
|
||||
self.assertEqual(result["summary"]["pending_count"], 1)
|
||||
self.assertEqual(result["summary"]["completed_count"], 0)
|
||||
|
||||
def test_duplicate_claim_attempts_count_one_instance_once(self):
|
||||
result = self.ingest([review_record("claim-one"), review_record("claim-two", timestamp=NOW + 1)])
|
||||
self.assertEqual(len(result["events"]), 2, "retain both attempts as evidence")
|
||||
self.assertEqual(len(result["rows"]), 1)
|
||||
self.assertEqual(result["summary"]["completed_count"], 1)
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 20)
|
||||
|
||||
def test_duplicate_claim_on_later_day_does_not_create_new_reward(self):
|
||||
before = datetime(2026, 11, 12, 15, 59, tzinfo=timezone.utc).timestamp()
|
||||
after = before + 120
|
||||
result = self.ingest([review_record("claim-before", timestamp=before),
|
||||
review_record("claim-after", timestamp=after)])
|
||||
self.assertEqual(result["summary"]["completed_count"], 0)
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
||||
self.assertEqual(self.history.query("71", "2026-11-12")["summary"]["confirmed_ke"], 20)
|
||||
|
||||
def test_same_type_different_instances_are_counted_separately(self):
|
||||
result = self.ingest([review_record("claim-one", task_id=81),
|
||||
review_record("claim-two", task_id=82, timestamp=NOW + 1)])
|
||||
self.assertEqual(len(result["rows"]), 2)
|
||||
self.assertEqual(result["summary"]["completed_count"], 2)
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 40)
|
||||
|
||||
def test_reconciled_accept_is_reconsidered_when_snapshot_changes(self):
|
||||
record = review_record(kind="accept", task_id=81, response=None,
|
||||
response_confirmed=False, outcome="reconciled")
|
||||
first = self.ingest([record], review_snapshot())
|
||||
self.assertEqual(first["summary"]["accepted_count"], 0)
|
||||
second = self.ingest([record], review_snapshot(tasks=[{"id": 81, "typeId": "review20", "curStep": 1}]))
|
||||
self.assertEqual(second["summary"]["accepted_count"], 1)
|
||||
self.assertEqual(second["rows"][0]["task_id"], 81)
|
||||
|
||||
def test_old_accept_today_claim_uses_beijing_day_for_each_count(self):
|
||||
before = datetime(2026, 11, 12, 15, 59, tzinfo=timezone.utc).timestamp()
|
||||
after = before + 120
|
||||
today = self.ingest([review_record("accept-old", kind="accept", timestamp=before),
|
||||
review_record("claim-today", timestamp=after)])
|
||||
yesterday = self.history.query("71", "2026-11-12")
|
||||
self.assertEqual(today["summary"]["accepted_count"], 0)
|
||||
self.assertEqual(today["summary"]["expected_ke"], 0)
|
||||
self.assertEqual(today["summary"]["completed_count"], 1)
|
||||
self.assertEqual(today["summary"]["confirmed_ke"], 20)
|
||||
self.assertEqual(yesterday["summary"]["accepted_count"], 1)
|
||||
self.assertEqual(yesterday["summary"]["completed_count"], 0)
|
||||
self.assertEqual(today["rows"][0]["accepted_at"], before)
|
||||
|
||||
def test_missing_historical_metadata_never_invents_reason_or_reward(self):
|
||||
record = review_record(commission={}, response={"resCode": 0, "ke": 99999})
|
||||
result = self.ingest([record], review_snapshot())
|
||||
row = result["rows"][0]
|
||||
self.assertIsNone(row["accepted_at"])
|
||||
self.assertIsNone(row["confirmed_ke"])
|
||||
self.assertNotIn("review-selected", row["selection_reason"])
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
||||
self.assertEqual(result["summary"]["unknown_reward_count"], 1)
|
||||
|
||||
def test_unconfirmed_historical_accept_does_not_describe_itself_as_confirmed(self):
|
||||
result = self.ingest([review_record(kind="accept", commission={}, phase="request_pending",
|
||||
outcome="", response=None, response_confirmed=False)])
|
||||
self.assertEqual(result["summary"]["accepted_count"], 0)
|
||||
self.assertNotIn("已确认", result["rows"][0]["selection_reason"])
|
||||
|
||||
def test_invalid_reward_values_are_unknown_not_catalog_or_wallet_amounts(self):
|
||||
for value in (None, True, "20", -1, 1.5, float("nan"), float("inf")):
|
||||
with self.subTest(value=value):
|
||||
ledger = CommissionHistory(clock=lambda: NOW)
|
||||
result = self.ingest([review_record(response={"resCode": 0, "reward": {"ke": value}})],
|
||||
history=ledger)
|
||||
self.assertEqual(result["summary"]["completed_count"], 1)
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 0)
|
||||
self.assertIsNone(result["rows"][0]["confirmed_ke"])
|
||||
|
||||
def test_read_and_restart_are_idempotent_and_return_detached_data(self):
|
||||
records = [review_record()]
|
||||
expected = self.ingest(records)
|
||||
before = self.history.path.read_bytes()
|
||||
for _ in range(3):
|
||||
self.assertEqual(self.ingest(records), expected)
|
||||
self.assertEqual(self.history.query("71", DAY), expected)
|
||||
self.assertEqual(self.history.path.read_bytes(), before)
|
||||
restored = CommissionHistory(self.history.path, clock=lambda: NOW)
|
||||
self.assertEqual(self.ingest(records, history=restored), expected)
|
||||
copy = restored.query("71", DAY)
|
||||
copy["rows"][0]["name"] = "caller mutation"
|
||||
self.assertEqual(restored.query("71", DAY), expected)
|
||||
|
||||
def test_role_and_separate_account_paths_are_isolated(self):
|
||||
self.ingest([review_record()])
|
||||
other = review_record(role_id="72", response={"resCode": 0, "reward": {"ke": 15}})
|
||||
self.ingest([other], role="72")
|
||||
self.assertEqual(self.history.query("71", DAY)["summary"]["confirmed_ke"], 20)
|
||||
self.assertEqual(self.history.query("72", DAY)["summary"]["confirmed_ke"], 15)
|
||||
separate = CommissionHistory(self.folder / "other-account" / "history.json", clock=lambda: NOW)
|
||||
self.assertEqual(separate.query("71", DAY)["events"], [])
|
||||
|
||||
def test_ledger_survives_rolling_journal_eviction_and_restart(self):
|
||||
snapshot = review_snapshot()
|
||||
journal = BattleJournal(self.folder / "journal.json")
|
||||
journal.role(snapshot)["records"].append(review_record())
|
||||
journal.save()
|
||||
self.ingest(journal.role(snapshot)["records"])
|
||||
journal.role(snapshot)["records"].extend({"attempt_id": f"other-{i}", "role_id": "71"}
|
||||
for i in range(501))
|
||||
journal.save()
|
||||
self.assertEqual(len(journal.role(snapshot)["records"]), 500)
|
||||
self.assertNotIn("review-claim", {r["attempt_id"] for r in journal.role(snapshot)["records"]})
|
||||
self.ingest(journal.role(snapshot)["records"])
|
||||
restored = CommissionHistory(self.history.path, clock=lambda: NOW)
|
||||
result = restored.query("71", DAY)
|
||||
self.assertEqual(result["summary"]["completed_count"], 1)
|
||||
self.assertEqual(result["summary"]["confirmed_ke"], 20)
|
||||
|
||||
def test_event_cap_and_retention_preserve_newest_events_on_restart(self):
|
||||
ledger = CommissionHistory(self.folder / "bounded.json", max_events=2, retention_days=2, clock=lambda: NOW)
|
||||
self.ingest([review_record(f"event-{i}", task_id=81 + i, timestamp=NOW + i)
|
||||
for i in (-3 * 86400, 0, 1, 2)], history=ledger)
|
||||
restored = CommissionHistory(ledger.path, max_events=2, retention_days=2, clock=lambda: NOW)
|
||||
result = restored.query("71", DAY)
|
||||
self.assertEqual({e["id"] for e in result["events"]}, {"event-1", "event-2"})
|
||||
|
||||
def test_corrupt_history_is_reported_and_original_bytes_preserved(self):
|
||||
path = self.folder / "corrupt.json"
|
||||
path.write_text('{"broken":', encoding="utf-8")
|
||||
before = path.read_bytes()
|
||||
ledger = CommissionHistory(path, clock=lambda: NOW)
|
||||
result = self.ingest([review_record()], history=ledger)
|
||||
self.assertTrue(result["error"])
|
||||
self.assertEqual(result["events"], [])
|
||||
self.assertEqual(path.read_bytes(), before)
|
||||
|
||||
def test_incomplete_persisted_event_reports_error_instead_of_crashing_read(self):
|
||||
path = self.folder / "incomplete-event.json"
|
||||
path.write_text(json.dumps({"version": 1, "roles": {"71": {"bad-event": {
|
||||
"id": "bad-event", "time": NOW, "date": DAY, "kind": "complete", "status": "confirmed"}}}}),
|
||||
encoding="utf-8")
|
||||
before = path.read_bytes()
|
||||
ledger = CommissionHistory(path, clock=lambda: NOW)
|
||||
result = ledger.query("71", DAY)
|
||||
self.assertTrue(result["error"])
|
||||
self.assertEqual(path.read_bytes(), before)
|
||||
|
||||
def test_cancelled_history_row_is_labelled_cancelled_by_web(self):
|
||||
from ranch_web.policies import default_config
|
||||
from ranch_web.views import build_view
|
||||
|
||||
history = self.ingest([review_record(kind="accept", outcome="cancelled")])
|
||||
engine = Engine(Catalog())
|
||||
engine.snapshot = review_snapshot()
|
||||
engine.commission_history = Mock(return_value=history)
|
||||
dto = build_view(engine, "commissions", default_config(), {"tab": "history", "date": DAY})
|
||||
self.assertEqual(dto["rows"][0]["status_label"], "已取消")
|
||||
self.assertIn("已取消", dto["details"][dto["rows"][0]["id"]]["行动记录"])
|
||||
|
||||
|
||||
class CommissionRunMessageIndependentReviewTests(unittest.TestCase):
|
||||
def test_uncertain_accept_is_not_resent_after_engine_restart(self):
|
||||
with tempfile.TemporaryDirectory(prefix="commission-uncertain-review-") as directory:
|
||||
client = Mock()
|
||||
client.call.side_effect = TimeoutError("synthetic uncertain write")
|
||||
path = Path(directory) / "budget.json"
|
||||
data = ProgressionData({"task_info": {"review20": deepcopy(INFO)}, "scripts": {},
|
||||
"stage_info": {}, "game_setting": {"cityInfo": {"1": {}}}})
|
||||
engine = Engine(Catalog(), client, path, game_data=data)
|
||||
engine.snapshot = review_snapshot()
|
||||
engine.snapshot.raw["history"].update(loopTaskTime=engine.snapshot.now, loopTaskNum=6,
|
||||
loopTask={"1": ["review20"]})
|
||||
engine.quest_policy.enabled = True
|
||||
engine._refresh_progression_cache(force=True)
|
||||
intent = next(i for i in engine._progression_intents if not i.blocked)
|
||||
self.assertEqual(intent.kind, "progression_loop_accept")
|
||||
with self.assertRaises(TimeoutError):
|
||||
engine._run_progression_intent(intent)
|
||||
self.assertEqual(client.call.call_count, 1)
|
||||
self.assertIsNotNone(engine.battle_journal.pending(engine.snapshot))
|
||||
restored = Engine(Catalog(), client, path, game_data=data)
|
||||
restored.snapshot = review_snapshot()
|
||||
restored.quest_policy.enabled = True
|
||||
for _ in range(3):
|
||||
_, _, message = restored._run_progression_intent(intent)
|
||||
self.assertIn("核对", message)
|
||||
self.assertEqual(restored.commission_history()["summary"]["accepted_count"], 0)
|
||||
self.assertEqual(restored.commission_history()["summary"]["completed_count"], 0)
|
||||
self.assertEqual(client.call.call_count, 1)
|
||||
|
||||
def test_history_save_failure_recovers_without_replaying_game_request(self):
|
||||
with tempfile.TemporaryDirectory(prefix="commission-storage-review-") as directory:
|
||||
client = Mock()
|
||||
client.call.side_effect = AssertionError("history must never replay a game write")
|
||||
engine = Engine(Catalog(), client, Path(directory) / "budget.json",
|
||||
game_data=ProgressionData({"task_info": {"review20": deepcopy(INFO)}}))
|
||||
engine.snapshot = review_snapshot()
|
||||
engine._commission_history.clock = lambda: NOW
|
||||
engine.battle_journal.role(engine.snapshot)["records"].append(review_record())
|
||||
engine.battle_journal.save()
|
||||
with patch.object(engine._commission_history, "_save", side_effect=PermissionError("synthetic disk error")):
|
||||
engine._sync_commission_history()
|
||||
result = engine.commission_history(DAY)
|
||||
self.assertTrue(result["error"])
|
||||
self.assertEqual(result["summary"]["completed_count"], 1)
|
||||
engine._sync_commission_history()
|
||||
self.assertFalse(engine.commission_history(DAY)["error"])
|
||||
restored = CommissionHistory(engine._commission_history.path, clock=lambda: NOW)
|
||||
self.assertEqual(restored.query("71", DAY)["summary"]["completed_count"], 1)
|
||||
client.call.assert_not_called()
|
||||
|
||||
def test_battle_early_return_cannot_replay_old_commission_success(self):
|
||||
for early_return in ("resources", "cancelled", "lock"):
|
||||
with self.subTest(early_return=early_return), tempfile.TemporaryDirectory(
|
||||
prefix="commission-message-review-") as directory:
|
||||
client = Mock()
|
||||
client.call.side_effect = AssertionError("offline review forbids game writes")
|
||||
client.snapshot.side_effect = AssertionError("offline review forbids game reads")
|
||||
engine = Engine(Catalog(), client, Path(directory) / "budget.json",
|
||||
game_data=ProgressionData({"task_info": {"review20": deepcopy(INFO)}}))
|
||||
engine.snapshot = review_snapshot()
|
||||
engine.quest_policy.enabled = True
|
||||
engine._commission_history.clock = lambda: NOW
|
||||
state = engine.battle_journal.role(engine.snapshot)
|
||||
state["records"].append(review_record())
|
||||
engine.battle_journal.save()
|
||||
engine._sync_commission_history()
|
||||
history_before = engine.commission_history(DAY)
|
||||
journal_before = deepcopy(state["records"])
|
||||
engine.plans = Mock(return_value=[])
|
||||
engine.read_snapshot = Mock(return_value=engine.snapshot)
|
||||
engine._refresh_progression_cache = Mock()
|
||||
engine._intent_policy = Mock(return_value=SimpleNamespace(enabled=True, team="teamA"))
|
||||
intent = {"kind": "progression_battle", "task_id": 82, "task_type_id": "review20",
|
||||
"step_number": 1, "block_reason": ""}
|
||||
if early_return == "resources":
|
||||
expected = "review-resource-shortage"
|
||||
engine.battles.resource_reason = Mock(return_value=expected)
|
||||
elif early_return == "cancelled":
|
||||
expected = "任务 / 战斗已取消,未开始"
|
||||
def cancel_during_preflight(*args):
|
||||
engine._progression_cancel.set()
|
||||
return ""
|
||||
engine.battles.resource_reason = Mock(side_effect=cancel_during_preflight)
|
||||
else:
|
||||
expected = "同账号已有任务 / 战斗正在执行"
|
||||
engine.battles.run = Mock(return_value=expected)
|
||||
with patch.object(engine.battle_journal, "begin", wraps=engine.battle_journal.begin) as begin:
|
||||
_, _, message = engine._run_progression_intent(intent)
|
||||
begin.assert_not_called()
|
||||
client.call.assert_not_called()
|
||||
client.snapshot.assert_not_called()
|
||||
self.assertEqual(state["records"], journal_before)
|
||||
self.assertEqual(engine.commission_history(DAY), history_before)
|
||||
self.assertEqual(message, expected, "a previous confirmed claim must not replace the new blocked message")
|
||||
|
||||
|
||||
class CommissionSelectionIndependentReviewTests(unittest.TestCase):
|
||||
def test_fallback_to_ten_explains_rejected_fifteen_when_twenty_absent(self):
|
||||
tasks = {}
|
||||
for amount in (10, 15):
|
||||
tasks[str(amount)] = deepcopy(INFO) | {"id": str(amount), "name": f"review-{amount}",
|
||||
"closed": amount == 15, "reward": {"ke": amount}}
|
||||
data = {"task_info": tasks, "scripts": {}, "stage_info": {},
|
||||
"game_setting": {"cityInfo": {"1": {}, "2": {}}}}
|
||||
snapshot = review_snapshot()
|
||||
snapshot.raw["history"].update(loopTaskTime=snapshot.now, loopTaskNum=6,
|
||||
loopTask={"1": ["10"], "2": ["15"]}, unlockCity={"1": True, "2": True})
|
||||
planner = ProgressionPlanner(Catalog(), data)
|
||||
actions = planner.commission_plan(snapshot, QuestPolicy(enabled=True), Policy())
|
||||
self.assertEqual(actions[0].task_type_id, "10")
|
||||
self.assertEqual([b["task_type_id"] for b in planner.commission_selection["higher_reward_blockers"]], ["15"])
|
||||
reason = planner.commission_selection["selection_reason"]
|
||||
self.assertIn("review-15", reason)
|
||||
self.assertIn("关闭", reason)
|
||||
self.assertIn("20", reason)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user