Fix fast automation routing and blocked quest navigation loops

Isolate hatch, gift, exploration and breakthrough timers; cancel queued automation after settings change. Check battle readiness before local quest navigation and reject exploring teams or disabled sweeps before entry.
This commit is contained in:
AttilaNet
2026-11-09 12:14:47 +08:00
parent 9f819d828a
commit eaaad3488b
9 changed files with 931 additions and 37 deletions
@@ -0,0 +1,275 @@
"""Offline regressions for exploring teams and isolated fast schedulers."""
from copy import deepcopy
from types import SimpleNamespace
import unittest
from unittest.mock import Mock
from ranch_assistant.battles import BattleOrchestrator
from ranch_assistant.engine import Engine
from ranch_assistant.exploration import ExplorePolicy
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.maps import stages
from ranch_assistant.model import Action, Catalog, Policy, Snapshot
from ranch_assistant.sweeping import SweepPolicy, SweepRunner
from ranch_assistant.team_availability import team_availability_reason
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_assistant.tests.test_gift_timing import GIFT, GiftClient, gift_policy
from ranch_assistant.tests.test_hatch_timing import HatchClient, policy_for as hatch_policy
from ranch_assistant.tests.test_ranch_automation_integration import FakeClient as AutomationClient
from ranch_assistant.tests.test_ranch_automation_integration import raw as automation_raw
from ranch_assistant.tests.test_core import workspace_temp
COMBAT_WRITES = {"stageService/stageStart", "battleService/battleStart",
"battleService/battleEnd", "taskService/taskCompleteStep"}
class BusyTeamTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, snapshot = scenario()
self.raw = deepcopy(snapshot.raw)
self.raw["currentTasks"] = []
self.raw["teams"][0]["monsters"] = [900, 901, 902]
for mid in (901, 902):
member = deepcopy(self.raw["monsters"][0])
member["id"] = mid
self.raw["monsters"].append(member)
self.snapshot = Snapshot(deepcopy(self.raw))
self.client = Mock()
self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw))
self.client.call.side_effect = lambda path, payload: (
{"resCode": 0, "triggerEvent": False} if path.endswith("stageStart")
else {"resCode": 0, "reward": {}})
self.runtime = ExperimentalRuntime()
def occupy(self, count, *, active=False):
self.raw = deepcopy(self.snapshot.raw)
selected = {int(mid) for mid in self.raw["teams"][0]["monsters"][:count]}
for member in (mon for mon in self.raw["monsters"] if int(mon["id"]) in selected):
if active:
member.pop("inExploreTeam", None)
else:
member["inExploreTeam"] = 1
if active:
self.raw["exploreTeams"] = [{"id": 77, "status": 1, "area": "1",
"monsters": ",".join(str(mid) for mid in (900, 901, 902)[:count]), "endTime": 9999999999999}]
self.snapshot = Snapshot(deepcopy(self.raw))
def map_engine(self, *, cleared):
self.raw["history"]["passStage"]["0102"] = ["1", "2", "3"] if cleared else []
info = deepcopy(self.catalog.data["stage_info"])
for row in info.values():
for level in row["level"].values():
level["battle"] = {"fixture": True}
data = ProgressionData({"task_info": {}, "stage_info": info,
"game_setting": self.catalog.data["game_setting"]})
engine = Engine(self.catalog, self.client, self.folder / "purchase.json",
game_data=data, experimental_runtime=self.runtime)
engine.policy = Policy(enabled=False, keep_money=0)
engine.sweep_policy = SweepPolicy(True,
{"0102": {"enabled": True, "level": "1", "limit": 3}})
engine.master_sync.settle = Mock()
engine.auto = True
return engine
def assert_no_combat_writes(self):
paths = [call.args[0] for call in self.client.call.call_args_list]
self.assertFalse(COMBAT_WRITES.intersection(paths), paths)
self.runtime.run.assert_not_called()
def test_shared_reason_is_pure_and_rejects_the_whole_selected_team(self):
for active in (False, True):
for count, expected in ((0, ""), (1, "1/3"), (3, "3/3")):
with self.subTest(active=active, count=count):
self.setUp()
self.occupy(count, active=active)
before = deepcopy(self.raw)
reason = team_availability_reason(self.snapshot, "teamA")
if expected:
self.assertIn("探险", reason)
self.assertIn(expected, reason)
self.assertIn("整队", reason)
else:
self.assertEqual(reason, "")
self.assertEqual(self.raw, before)
self.assertEqual(team_availability_reason(self.snapshot, "missing"), "未找到所选战队")
def test_all_sweep_kinds_reject_any_exploring_member_before_writes(self):
for cleared in (True, False):
for active in (False, True):
for count in (1, 3):
with self.subTest(cleared=cleared, active=active, count=count):
self.setUp()
self.occupy(count, active=active)
engine = self.map_engine(cleared=cleared)
engine.poll()
stage = next(stage for stage in stages(self.catalog, engine.snapshot)
if stage.stage_id == "0102" and stage.level == "1")
reason = engine.map_stage_reason(engine.snapshot, stage, engine.sweep_policy)
self.assertIn("探险", reason)
self.assertIn("整队", reason)
self.assert_no_combat_writes()
def test_direct_sweep_rechecks_occupancy_instead_of_filtering_members(self):
self.occupy(1, active=True)
runner = SweepRunner(self.catalog)
policy = SweepPolicy(True, {"0101": {"enabled": True, "level": "3", "limit": 3}})
stage = next(stage for stage in stages(self.catalog, self.snapshot)
if stage.stage_id == "0101" and stage.level == "3")
with self.assertRaisesRegex(ValueError, "探险.*整队"):
runner.run(self.client, self.snapshot, stage, policy)
self.assert_no_combat_writes()
self.assertEqual(runner.used(self.snapshot, stage), 0)
def test_task_and_ordinary_battles_reject_either_occupancy_marker(self):
for active in (False, True):
for task in (False, True):
with self.subTest(active=active, task=task):
self.setUp()
self.occupy(2, active=active)
runner = BattleOrchestrator(self.catalog, runtime=self.runtime)
intent = {"kind": "progression_battle", "task_id": 5 if task else 0,
"task_type_id": "100" if task else "", "step_number": 1,
"stage_id": "0101", "difficulty": "1",
"battle_kind": "battle" if task else "ordinary_stage"}
if task:
self.snapshot.raw["currentTasks"] = [{"id": 5, "typeId": "100", "curStep": 1}]
message = runner.run(self.client, self.snapshot, intent, SimpleNamespace(
enabled=True, team="teamA", stop_after_loss=0, reserve_ti=0,
allow_items=True, item_reserves={}, max_money=100000, battle_mode="experimental"))
self.assertIn("探险", message)
self.assertIn("整队", message)
self.assert_no_combat_writes()
def test_disabling_sweep_invalidates_old_rules_without_touching_pending_barrier(self):
stage = next(stage for stage in stages(self.catalog, self.snapshot)
if stage.stage_id == "0101" and stage.level == "3")
runner = SweepRunner(self.catalog)
runner.state["pending"] = {"stage": "0101", "level": "3", "phase": "扫荡结算待确认"}
pending = deepcopy(runner.state["pending"])
policy = SweepPolicy(False, {"0101": {"enabled": True, "level": "3", "limit": 3}})
self.assertIn("关闭", runner.reason(self.snapshot, stage, policy))
self.assertIsNone(runner.next(self.snapshot, policy))
with self.assertRaisesRegex(ValueError, "关闭"):
runner.run(self.client, self.snapshot, stage, policy)
self.assertEqual(runner.state["pending"], pending)
self.client.call.assert_not_called()
class FastSchedulingTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
def automation_engine(self):
catalog = Catalog()
client = AutomationClient(automation_raw(catalog))
engine = Engine(catalog, client, self.folder / "purchase.json")
engine.master_sync.settle = Mock()
engine.settle_pending_growth = Mock(return_value=False)
engine.auto = True
return engine, client
def test_hatch_only_cannot_execute_a_commission(self):
client = HatchClient(Catalog())
engine = Engine(client=client, catalog=Catalog())
engine.policy = hatch_policy(client)
engine.auto = True
hatch_actions = engine.hatch_planner.hatch_actions
engine.hatch_planner.hatch_actions = Mock(return_value=[])
engine.tasks.plan = Mock(return_value=[Action("quest_test", "不应执行委托",
"taskService/acceptTask", {"taskId": 1})])
engine.poll(hatch_only=True)
self.assertEqual(client.calls, [])
engine.hatch_planner.hatch_actions = hatch_actions
engine.tasks.plan = Mock(return_value=[])
engine.poll(hatch_only=True)
self.assertEqual([path for path, _ in client.calls], ["stackService/stackAddMonster"])
def test_hatch_fast_kind_retains_existing_hatch_behavior(self):
catalog = Catalog()
client = HatchClient(catalog)
engine = Engine(catalog, client)
engine.policy = hatch_policy(client)
engine.auto = True
engine.poll_automation("hatch")
self.assertEqual([path for path, _ in client.calls], ["stackService/stackAddMonster"])
def test_fast_kinds_execute_only_their_own_action(self):
for kind in ("explore", "breakthrough"):
with self.subTest(kind=kind):
self.setUp()
engine, client = self.automation_engine()
if kind == "explore":
engine.explore_policy = ExplorePolicy(True,
{"77": {"enabled": True, "area": "1", "monsters": []}})
area = engine.explore_planner.areas["1"]
client.value["history"]["passStage"] = {area["passStage"]: {"1": True}}
client.value["monsters"][0]["level"] = 60
else:
engine.policy = Policy(fill=False, collect=False, dispatch=False, feed=False,
breakthrough_targets={"900": 1})
engine.poll_automation(kind)
expected = "exploreService/start" if kind == "explore" else "monsterService/monsterPotentialUpgrade"
self.assertEqual([path for path, _ in client.calls], [expected])
def test_fast_kind_ignores_another_due_kind_and_all_other_strategies(self):
engine, client = self.automation_engine()
engine.explore_policy = ExplorePolicy(True,
{"77": {"enabled": True, "area": "1", "monsters": []}})
area = engine.explore_planner.areas["1"]
client.value["history"]["passStage"] = {area["passStage"]: {"1": True}}
client.value["monsters"][0]["level"] = 60
engine.policy = Policy(fill=False, collect=False, dispatch=False, feed=False,
breakthrough_targets={"900": 1})
other = Action("progression", "不应执行", "taskService/navigate", {"intent": {}})
engine._execute_legacy_task = Mock()
original_plans = engine.plans
engine.plans = Mock(side_effect=lambda: [other] + original_plans())
_, _, message = engine.poll_automation("breakthrough")
self.assertEqual([path for path, _ in client.calls], ["monsterService/monsterPotentialUpgrade"])
engine._execute_legacy_task.assert_not_called()
client.calls.clear()
client.value["monsters"][0]["pAtk"] += 1
_, _, message = engine.poll_automation("gift")
self.assertEqual(client.calls, [])
self.assertIn("赠礼", message)
def test_gift_fast_path_does_not_run_progression_or_maps(self):
catalog = Catalog()
client = GiftClient(catalog)
engine = Engine(catalog, client)
engine.policy = gift_policy()
engine.auto = True
forbidden = Action("progression", "不应执行", "taskService/navigate", {"intent": {}})
original_plans = engine.plans
engine.plans = Mock(side_effect=lambda: [forbidden] + original_plans())
engine._execute_legacy_task = Mock()
snapshot, _, _ = engine.poll_automation("gift")
self.assertEqual([path for path, _ in client.calls], [GIFT])
self.assertEqual(snapshot.monsters[1]["feel"], 10)
engine._execute_legacy_task.assert_not_called()
def test_fast_path_respects_stop_and_cross_kind_pending_barriers(self):
for kind in ("explore", "breakthrough", "gift"):
with self.subTest(kind=kind, stopped=True):
engine, client = self.automation_engine()
engine.auto = False
engine.poll_automation(kind)
self.assertEqual(client.calls, [])
with self.subTest(kind=kind, pending=True):
engine, client = self.automation_engine()
engine._breakthrough_pending = {"kind": "invalid", "role_id": "1",
"uncertain": True, "message": "待核对"}
_, plans, _ = engine.poll_automation(kind)
self.assertEqual((client.calls, plans), ([], []))
def test_unknown_fast_kind_is_rejected(self):
engine, _ = self.automation_engine()
with self.assertRaises(ValueError):
engine.poll_automation("progression")
if __name__ == "__main__":
unittest.main()