feat: add configurable battle loss cooldown in Web 2.0.13
Web image / image (push) Waiting to run

This commit is contained in:
AttilaNet
2026-11-17 00:17:52 +08:00
parent 598bdf5c1c
commit b976151263
23 changed files with 297 additions and 43 deletions
+19
View File
@@ -0,0 +1,19 @@
"""Local cooldown for confirmed battle losses."""
import math
from datetime import datetime, timedelta, timezone
def loss_retry_reason(state, now, policy):
limit = int(getattr(policy, "stop_after_loss", 0) or 0)
if not limit or int(state.get("losses", 0)) < limit:
return ""
last_loss = state.get("last_loss_at")
if type(last_loss) not in (int, float) or not math.isfinite(last_loss) or last_loss <= 0:
last_loss = float(now)
state["last_loss_at"] = last_loss
deadline = last_loss + getattr(policy, "loss_retry_hours", 3) * 3600
if now >= deadline:
state.update(losses=0, last_loss_at=None)
return ""
retry_at = datetime.fromtimestamp(deadline, timezone(timedelta(hours=8))).strftime("%m-%d %H:%M:%S")
return f"已达战败停止次数,冷却至 {retry_at}(北京时间)后自动重新检查并重试"
+13 -3
View File
@@ -32,6 +32,7 @@ from .resource_stages import resource_entry_reason, item_requirements, available
from .quests import indexed, stage_has_level
from .sweeping import SweepPolicy, hidden_stage_id
from .team_availability import team_availability_reason
from .battle_retry import loss_retry_reason
def value(obj, name, default=None):
@@ -152,6 +153,14 @@ class BattleJournal:
state = self.role(snapshot)
return next((r for r in state["records"] if r["attempt_id"] == state["pending"]), None)
def loss_reason(self, snapshot, policy):
state = self.role(snapshot)
before = (state.get("losses"), state.get("last_loss_at"))
reason = loss_retry_reason(state, snapshot.now, policy)
if before != (state.get("losses"), state.get("last_loss_at")):
self.save()
return reason
def records(self, snapshot):
with self.lock:
self.reload()
@@ -201,8 +210,10 @@ class BattleJournal:
shared_loss_budget = record.get("kind") != "map_battle" and not record.get("sweep_sample_id")
if outcome == "loss" and shared_loss_budget:
state["losses"] += 1
state["last_loss_at"] = snapshot.now
elif outcome == "win" and shared_loss_budget:
state["losses"] = 0
state["last_loss_at"] = None
self.save()
def cursors(self, snapshot):
@@ -350,9 +361,8 @@ class BattleOrchestrator:
return "任务实例或服务器步骤已变化,请重新规划"
if planner_validated is None and checkpoints.get(str(number), {}).get("submitted"):
return "该任务步骤已有确认记录,等待剧情 / 服务器步骤核对"
limit = max(0, int(policy.stop_after_loss))
if limit and self.journal.role(snapshot)["losses"] >= limit:
return "已达战败停止次数,请核对阵容后重置战败计数"
if reason := self.journal.loss_reason(snapshot, policy):
return reason
reason = team_availability_reason(snapshot, policy.team)
if reason:
return reason
+4
View File
@@ -956,6 +956,8 @@ class Engine:
try:
self._ensure_progression()
self._recover_confirmed_progression()
retry_reason = self.progression_planner.battle_retry_reason(self.snapshot, self.progression_policy)
journal_retry_reason = self.battle_journal.loss_reason(self.snapshot, self.progression_policy)
self._battle_snapshot_source = self.snapshot
self._battle_snapshot_digest = digest(self.snapshot.raw)
self.progression_planner.battle_capability_key = digest({
@@ -963,6 +965,7 @@ class Engine:
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),
"purchase_left": self.progression_planner.procurement_daily_left,
"loss_retry": (retry_reason, journal_retry_reason),
"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:
@@ -990,6 +993,7 @@ class Engine:
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),
"purchase_left": self.progression_planner.procurement_daily_left,
"loss_retry": (retry_reason, journal_retry_reason),
"pending": self._progression_pending(), "runtime": id(self.battles.runtime),
"day": ProgressionPlanner._loop_day(self.snapshot, self.snapshot.now - 10)})
self._progression_error = ""
+2
View File
@@ -40,6 +40,8 @@ def checked_progression_policy(data):
if not isinstance(data, dict):
raise ValueError("主线策略必须是对象")
raw = asdict(ProgressionPolicy()) | data
if type(raw["loss_retry_hours"]) is not int or not 1 <= raw["loss_retry_hours"] <= 168:
raise ValueError("战败冷却时间须为1至168小时")
for key in ("reserve_ti", "max_money"):
if type(raw[key]) is not int or not 0 <= raw[key] <= 1_000_000_000:
raise ValueError("主线策略数量超出范围:" + key)
+19 -7
View File
@@ -45,8 +45,9 @@ import uuid
from .game_data import ProgressionData, load_progression_data
from .model import Planner, seconds
from .quests import commission_priority, commission_selection, commission_reason_kind, indexed, stage_has_level
from .quests import commission_priority, commission_selection, commission_reason_kind, commission_quota_reason, indexed, stage_has_level
from .procurement import ResourceProcurement, resource_kind
from .battle_retry import loss_retry_reason
CATEGORIES = {1: ("mainline", "主线"), 2: ("sidequest", "支线"),
@@ -96,6 +97,7 @@ class ProgressionPolicy:
allow_monsters: bool = False
item_reserves: dict[str, int] = field(default_factory=dict)
stop_after_loss: int = 1
loss_retry_hours: int = 3
repair_chain: bool = True
battle_mode: str = "original"
auto_farm: bool = True
@@ -105,13 +107,15 @@ class ProgressionPolicy:
"allow_sweep", "allow_items", "allow_monsters", "repair_chain", "auto_farm"):
if not isinstance(getattr(self, name), bool):
raise ValueError(f"{name} must be a boolean")
for name in ("reserve_ti", "max_money", "stop_after_loss"):
for name in ("reserve_ti", "max_money", "stop_after_loss", "loss_retry_hours"):
value = getattr(self, name)
if type(value) is not int or value < 0:
raise ValueError(f"{name} must be a nonnegative integer")
setattr(self, name, _integer(value))
if self.stop_after_loss < 1:
raise ValueError("stop_after_loss must be at least 1")
if not 1 <= self.loss_retry_hours <= 168:
raise ValueError("loss_retry_hours must be between 1 and 168")
if (not isinstance(self.team, str) or not 1 <= len(self.team) <= 64
or self.team.strip() != self.team or not self.team.isprintable()):
raise ValueError("team must be a nonempty printable name of at most 64 characters")
@@ -203,11 +207,15 @@ class ProgressionPlanner:
"position": str(snapshot.raw.get("position") or ""), "tasks": {}, "received": {},
"unlocked": [], "finished": [], "stage_unlocks": [], "city_unlocks": [],
"stage_passes": [], "stage_levels": [], "stage_locks": [],
"pending": None, "losses": 0, "applied": [],
"pending": None, "losses": 0, "last_loss_at": None, "applied": [],
"commissions": {"day": None, "remaining": None, "offers": None, "accepted": [], "expired_ids": [], "finished": []},
})
return scope, account
def battle_retry_reason(self, snapshot, policy):
_, account = self._account(snapshot)
return loss_retry_reason(account, snapshot.now, policy)
def _tasks(self, snapshot, account):
received = {key: task for key, task in account["received"].items()
if not account["tasks"].get(f"{_integer(task.get('id'))}:{key}", {}).get("removed")}
@@ -626,8 +634,8 @@ class ProgressionPlanner:
"""Reject an unusable battle before navigation or its before-story."""
if _integer(snapshot.raw["master"].get("ti")) < policy.reserve_ti:
return "当前体力低于保留体力"
if account["losses"] >= policy.stop_after_loss:
return "达到任务战败停止次数"
if reason := loss_retry_reason(account, snapshot.now, policy):
return reason
if kind == "battle" and not step.get("battle"):
return "任务战斗配置缺失"
if kind == "passStage":
@@ -742,7 +750,7 @@ class ProgressionPlanner:
else:
return []
scope, account = self._account(snapshot)
if account["losses"] >= policy.stop_after_loss:
if loss_retry_reason(account, snapshot.now, policy):
return []
ranked = []
seen = set()
@@ -1008,7 +1016,7 @@ class ProgressionPlanner:
city_info = self.city_diagnostic(city, snapshot)
supply = None
reason = ("城市编号无效" if city <= 0 else
"当日接取次数已用完(剩余0次),等待次日刷新" if remaining <= 0 else
commission_quota_reason(snapshot) if remaining <= 0 else
f"策略限定城市 {quest_policy.city}" if quest_policy.city and city != quest_policy.city else
city_info["city_reason"] if not city_info["city_unlocked"] else
"委托列表已跨日,等待刷新确认" if recorded is not None and recorded != today and account["commissions"]["day"] != today else
@@ -1335,6 +1343,7 @@ class ProgressionPlanner:
record["next_value"] = response.get("taskStepValue")
if intent.kind == "progression_battle" and not _from_snapshot:
account["losses"] = 0
account["last_loss_at"] = None
if intent.battle_kind == "passStage":
# Exact TaskStartPanel.step2WinHandler -> passLocalStage
# effects, only after the real step settlement succeeded.
@@ -1492,6 +1501,7 @@ class ProgressionPlanner:
if intent.account_key != scope or intent.kind != "progression_battle":
raise ValueError("Battle intent/account mismatch")
account["losses"] += 1
account["last_loss_at"] = snapshot.now
if account["pending"] and account["pending"]["token"] == intent.token:
account["pending"] = None
@@ -1518,10 +1528,12 @@ class ProgressionPlanner:
for scope, account in restored.items():
if not re.fullmatch(r"[0-9a-f]{64}", scope) or not isinstance(account, dict):
raise ValueError("Invalid local progression account")
account.setdefault("last_loss_at", None)
for key in ("stage_passes", "stage_levels", "stage_locks"):
account.setdefault(key, [])
account.setdefault("commissions", {"day": None, "remaining": None, "offers": None, "accepted": [], "expired_ids": [], "finished": []})
required = {"position", "tasks", "received", "unlocked", "finished", "stage_unlocks", "city_unlocks", "pending", "losses", "applied", "stage_passes", "stage_levels", "stage_locks", "commissions"}
required.add("last_loss_at")
if set(account) != required or not isinstance(account["tasks"], dict) or not isinstance(account["received"], dict):
raise ValueError("Invalid local progression state fields")
if account["pending"]:
+2 -2
View File
@@ -265,9 +265,9 @@ class ProgressionPages:
self.progression_team.addItem(team, team)
form.addRow("推进战斗队伍", self.progression_team)
for key, label, maximum in (("reserve_ti", "保留体力", 1_000_000_000), ("max_money", "单次交付金币上限(0=不交金币)", 1_000_000_000),
("stop_after_loss", "连续失败后停止次数", 999)):
("stop_after_loss", "连续失败后停止次数", 999), ("loss_retry_hours", "战败冷却时间(小时)", 168)):
widget = IntegerInput()
widget.setRange(1 if key == "stop_after_loss" else 0, maximum)
widget.setRange(1 if key in ("stop_after_loss", "loss_retry_hours") else 0, maximum)
widget.setValue(getattr(defaults, key))
setattr(self, "progression_" + key, widget)
form.addRow(label, widget)
+8
View File
@@ -7,6 +7,14 @@ from .model import Action, Planner, seconds
CN = timezone(timedelta(hours=8))
def commission_quota_reason(snapshot):
offset = (9 if (snapshot.raw.get("client_context") or {}).get("lang") == "JP" else 8) * 3600
day = int((snapshot.now - 10 + offset) // 86400)
reset_at = (day + 1) * 86400 - offset + 10
stamp = datetime.fromtimestamp(reset_at, timezone(timedelta(seconds=offset))).strftime("%m-%d %H:%M:%S")
return f"当日接取次数已用完(剩余0次),等待 {stamp} 自动刷新后继续"
def commission_reason_kind(reason):
text = str(reason or "")
for kind, words in (
+139
View File
@@ -0,0 +1,139 @@
"""Offline checks for cooldown recovery and midnight quota refresh."""
from datetime import datetime, timedelta, timezone
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.battles import BattleJournal
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.policy_io import checked_progression_policy
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
from ranch_assistant.quests import QuestPolicy
from ranch_assistant.tests.test_progression import config, snapshot, step, task
class BattleRetryTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.tasks = {"400": task("400", type=4, steps=[step("battle", battle={"teams": []})])}
self.snapshot = snapshot(currentTasks=[{"id": 40, "typeId": "400", "curStep": 1}])
self.planner = ProgressionPlanner(self.catalog, config(self.tasks))
self.quest = QuestPolicy(enabled=True, battle_tasks=True)
self.policy = ProgressionPolicy()
def test_configured_interval_controls_next_battle_attempt(self):
self.policy.loss_retry_hours = 2
with patch("ranch_assistant.model.time.time", return_value=100000):
self.planner.battle_lost(self.snapshot, self.plan()[0])
with patch("ranch_assistant.model.time.time", return_value=107199):
self.assertTrue(self.plan()[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=107200):
self.assertFalse(self.plan()[0].blocked)
def test_retry_hour_validation(self):
self.assertEqual(checked_progression_policy({}).loss_retry_hours, 3)
for hours in (0, 169, True, 1.5):
with self.subTest(hours=hours), self.assertRaises(ValueError):
checked_progression_policy({"loss_retry_hours": hours})
def test_legacy_loss_wait_survives_planner_restore(self):
account = self.planner._account(self.snapshot)[1]
account.update(losses=1)
account.pop("last_loss_at")
state = self.planner.export_state()
self.planner.restore_state(state)
with patch("ranch_assistant.model.time.time", return_value=100000):
self.assertTrue(self.plan()[0].blocked)
state = self.planner.export_state()
self.planner.restore_state(state)
with patch("ranch_assistant.model.time.time", return_value=110799):
self.assertTrue(self.plan()[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=110800):
self.assertFalse(self.plan()[0].blocked)
def plan(self):
return self.planner.commission_plan(self.snapshot, self.quest, Policy(), battle_policy=self.policy)
def test_loss_wait_expires_without_changing_task_progress(self):
with patch("ranch_assistant.model.time.time", return_value=100000):
intent = self.plan()[0]
self.planner.battle_lost(self.snapshot, intent)
blocked = self.plan()[0]
self.assertIn("冷却", blocked.block_reason)
with patch("ranch_assistant.model.time.time", return_value=110799):
self.assertTrue(self.plan()[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=110800):
resumed = self.plan()[0]
self.assertFalse(resumed.blocked)
self.assertEqual(resumed.kind, "progression_battle")
self.assertEqual(resumed.step_number, 1)
def test_quota_exhaustion_waits_for_midnight_reset(self):
now = datetime(2026, 11, 16, 12, tzinfo=timezone(timedelta(hours=8))).timestamp()
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"].update(loopTaskTime=now, loopTaskNum=0, loopTask={"1": ["400"]})
with patch("ranch_assistant.model.time.time", return_value=now):
self.assertEqual(self.plan(), [])
row = self.planner.commission_offers(self.snapshot, self.quest, Policy())[0]
self.assertIn("00:00", row["reason"])
self.assertIn("自动", row["reason"])
with patch("ranch_assistant.model.time.time", return_value=now + 2 * 86400):
self.assertEqual(self.plan()[0].kind, "progression_loop_reset")
def test_old_policy_uses_three_hour_default(self):
self.assertEqual(self.policy.loss_retry_hours, 3)
def test_restart_keeps_original_loss_deadline(self):
with tempfile.TemporaryDirectory() as root:
path = Path(root) / "battle.json"
with patch("ranch_assistant.model.time.time", return_value=100000):
journal = BattleJournal(path)
record = journal.begin(self.snapshot, {"kind": "progression_battle"})
journal.finish(self.snapshot, record, "loss")
original = journal.loss_reason(self.snapshot, self.policy)
with patch("ranch_assistant.model.time.time", return_value=103600):
restarted = BattleJournal(path)
self.assertEqual(restarted.loss_reason(self.snapshot, self.policy), original)
with patch("ranch_assistant.model.time.time", return_value=110800):
restarted = BattleJournal(path)
self.assertEqual(restarted.loss_reason(self.snapshot, self.policy), "")
self.assertEqual(restarted.role(self.snapshot)["losses"], 0)
def test_expired_cooldown_preserves_unknown_request(self):
journal = BattleJournal()
journal.role(self.snapshot).update(losses=1, last_loss_at=100000)
record = journal.begin(self.snapshot, {"kind": "progression_battle"})
journal.update(record, "unknown", message="verify first")
with patch("ranch_assistant.model.time.time", return_value=110800):
self.assertEqual(journal.loss_reason(self.snapshot, self.policy), "")
self.assertEqual(journal.pending(self.snapshot)["phase"], "unknown")
def test_cooldown_boundary_invalidates_engine_cached_intents(self):
engine = Engine(self.catalog, game_data=ProgressionData(config(self.tasks)))
engine.snapshot = self.snapshot
engine.quest_policy = self.quest
engine._battle_capability = Mock(return_value=(True, ""))
with patch("ranch_assistant.model.time.time", return_value=100000):
engine._ensure_progression()
engine.progression_planner._account(self.snapshot)[1].update(losses=1, last_loss_at=100000)
engine.battle_journal.role(self.snapshot).update(losses=1, last_loss_at=100000)
engine._refresh_progression_cache(force=True)
self.assertTrue(engine._progression_intents[0].blocked)
with patch("ranch_assistant.model.time.time", return_value=110800):
engine._refresh_progression_cache()
self.assertFalse(engine._progression_intents[0].blocked)
self.assertEqual(engine.battle_journal.role(self.snapshot)["losses"], 0)
engine.auto = False
engine.demo = False
engine.client = Mock()
engine.read_snapshot = Mock(return_value=self.snapshot)
engine.settle_pending_growth = Mock(return_value=False)
engine.poll()
self.assertFalse(engine.last_executed)
engine.client.call.assert_not_called()
engine.quest_policy.enabled = False
engine._refresh_progression_cache(force=True)
self.assertEqual(engine._progression_intents, [])