Add hatch retention, automatic breakthroughs and exploration

This commit is contained in:
AttilaNet
2026-11-09 11:27:29 +08:00
parent 26be820ff2
commit 9f819d828a
32 changed files with 6207 additions and 83 deletions
+243
View File
@@ -0,0 +1,243 @@
"""Offline exploration policy, pending-send, snapshot and data tests."""
from copy import deepcopy
from dataclasses import asdict
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.exploration import ExplorePlanner, ExplorePolicy, ExploreTeamRule, load_exploration_areas
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.tests.test_core import workspace_temp
NOW = 1_700_000_000
AREAS = {
"1": {"id": "1", "name": "测试矿洞", "passStage": "0101", "costTi": 20,
"costTime": 3600, "level": [5, 1, 1], "team": "normal"},
"2": {"id": "2", "name": "测试森林", "passStage": "0102", "costTi": 30,
"costTime": 7200, "level": [10, 2, 2], "team": "normal"},
}
def monster(mid, level, **changes):
return {"id": mid, "typeId": "1001010", "level": level, "process": 3,
"mode": 2, "lock": False, **changes}
def make_snapshot(**changes):
value = {"master": {"id": 11, "ti": 100}, "serverId": 7, "areaId": 1,
"items": [], "stacks": [], "rooms": [], "teams": [],
"monsters": [monster(mid, level) for mid, level in ((1, 20), (2, 15), (3, 10), (4, 8), (5, 7), (6, 6), (7, 5))],
"history": {"passTask": {"1001008": True},
"passStage": {"0101": {"1": True}, "0102": {"1": True}}},
"exploreTeams": [{"id": 1, "status": 0, "area": "", "monsters": ""}], **changes}
snapshot = Snapshot(value, received_at=NOW)
return patch("time.time", return_value=NOW), snapshot
def policy(**team):
values = {"enabled": True, "area": "1", "monsters": []} | team
return ExplorePolicy(True, {"1": ExploreTeamRule(**values)})
class ExplorationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.clock, self.snapshot = make_snapshot()
self.clock.start()
self.addCleanup(self.clock.stop)
self.ranch = Policy(protect_star=6, protect_quality=5, keep_better_quality=False)
self.planner = ExplorePlanner(self.catalog, areas=AREAS)
def action(self, snapshot=None, planner=None, explore_policy=None):
return (planner or self.planner).plan(snapshot or self.snapshot, explore_policy or policy(), self.ranch)[0]
def start_confirmed(self, team, end=NOW + 3600):
team.update(status=1, area="1", monsters="1,2,3", endTime=end * 1000)
def test_static_data_and_source_extractor(self):
areas = load_exploration_areas()
self.assertEqual(len(areas), 22)
self.assertEqual(areas["1"]["name"], "废弃矿洞")
self.assertEqual(areas["1"]["level"], [4, 1, 1])
self.assertEqual(areas["1"]["passStage"], "0109")
self.assertTrue(all(row["team"] == "normal" and len(row["level"]) == 3 for row in areas.values()))
def test_policy_roundtrip_and_strict_validation(self):
configured = policy(monsters=[1, 2, 3])
self.assertEqual(ExplorePolicy.from_dict(json.loads(json.dumps(configured.to_dict()))), configured)
for value in ({"enabled": 1}, {"reserve_ti": -1}, {"reserve_ti": True},
{"teams": {"0": {"enabled": True, "area": "1", "monsters": []}}},
{"teams": {"1": {"enabled": True, "area": "bad", "monsters": []}}},
{"teams": {"1": {"enabled": True, "area": "1", "monsters": [1]}}},
{"teams": {"1": {"enabled": True, "area": "1", "monsters": [1, 1, 2]}}},
{"teams": {"1": {"enabled": True, "area": "1", "unknown": 1}}}):
with self.subTest(value=value), self.assertRaises(ValueError):
ExplorePolicy(**(asdict(ExplorePolicy()) | value))
def test_original_monster_eligibility_does_not_protect_lock_star_or_equipment(self):
selected = policy(monsters=[1, 2, 3])
for mid in (1, 2, 3):
self.snapshot.raw["monsters"][mid - 1].update(lock=True, sysLock=True, equip1=7)
action = self.action(explore_policy=selected)
self.assertEqual(action.payload["monsters"], [1, 2, 3])
self.assertEqual(self.planner.rows(self.snapshot, selected, self.ranch)[0]["state"], "可出发")
options = self.planner.member_options(self.snapshot, 1, selected, self.ranch)
self.assertTrue(all(option["automatic"] for option in options))
def test_automatic_excludes_battle_feed_gift_and_breakthrough_targets(self):
self.snapshot.raw["teams"] = [{"teamType": "battleTeam", "teamName": "teamA", "monsters": [1]}]
self.ranch.feed_targets = {"2": 1}
self.ranch.gift_targets = {"3": 1}
self.ranch.breakthrough_targets = {"4": 1}
action = self.action()
self.assertEqual(action.payload["monsters"], [5, 6, 7])
def test_manual_remains_available_when_automatic_targets_exhausted(self):
self.snapshot.raw["teams"] = [{"teamType": "battleTeam", "monsters": [1]}]
self.ranch.feed_targets = {str(mid): 1 for mid in (2, 3, 4, 5, 6, 7)}
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
row = self.planner.rows(self.snapshot, policy(), self.ranch)[0]
self.assertIn("手动", row["reason"])
manual = policy(monsters=[1, 2, 3])
self.assertEqual(self.action(explore_policy=manual).payload["monsters"], [1, 2, 3])
options = self.planner.member_options(self.snapshot, 1, manual, self.ranch)
self.assertEqual(len(options), 7)
self.assertTrue(all(not option["automatic"] for option in options))
def test_manual_missing_leader_and_other_team_members_do_not_raise(self):
for ids in ([99, 2, 3], [1, 2, 2]):
if len(set(ids)) == 3:
selected = policy(monsters=ids)
self.assertEqual(self.planner.plan(self.snapshot, selected, self.ranch), [])
row = self.planner.rows(self.snapshot, selected, self.ranch)[0]
self.assertIn("不存在", row["reason"])
self.snapshot.raw["exploreTeams"].append({"id": 2, "status": 1, "area": "2", "monsters": "2", "endTime": (NOW + 30) * 1000})
selected = policy(monsters=[1, 2, 3])
self.assertIn("其他探险队", self.planner.rows(self.snapshot, selected, self.ranch)[0]["reason"])
def test_raw_string_members_unlock_stamina_and_finish_priority(self):
self.assertFalse(self.planner.area_unlocked(self.snapshot, AREAS["1"] | {"passStage": "0103"}))
self.snapshot.raw["history"]["passStage"]["0101"] = {"2": True}
self.assertFalse(self.planner.area_unlocked(self.snapshot, AREAS["1"]))
self.snapshot.raw["history"]["passStage"]["0101"]["1"] = True
self.snapshot.raw["master"]["ti"] = 19
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
self.snapshot.raw["master"]["ti"] = 100
self.snapshot.raw["exploreTeams"].append({"id": 2, "status": 1, "area": "1", "endTime": (NOW + 60) * 1000})
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
self.snapshot.raw["exploreTeams"].pop()
self.snapshot.raw["exploreTeams"][0].update(status=1, area="1", monsters="1,2,3", endTime=(NOW - 1) * 1000)
self.assertEqual(self.action().kind, "explore_finish")
self.assertEqual(self.planner.rows(self.snapshot, policy(), self.ranch)[0]["monster_ids"], [1, 2, 3])
def test_active_zero_or_missing_deadline_is_unknown_and_never_finished(self):
for value in (None, 0, "", "not-a-time"):
with self.subTest(value=value):
self.snapshot.raw["exploreTeams"][0].update(status=1, endTime=value, monsters="1,2,3")
self.assertEqual(self.planner.plan(self.snapshot, policy(), self.ranch), [])
self.assertEqual(self.planner.rows(self.snapshot, policy(), self.ranch)[0]["state"], "状态待同步")
def test_success_with_stale_snapshot_never_repeats_start_even_after_restart(self):
with workspace_temp() as folder:
path = folder / "exploration-state.json"
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
action = self.action(planner=planner)
response = planner.execute(self.snapshot, action, Mock(return_value={"resCode": 0}))
self.assertEqual(response, {"resCode": 0})
for _ in range(3):
self.assertEqual(self.action(planner=planner).kind, "explore_blocked")
self.assertFalse(planner.reconcile(self.snapshot))
restored = ExplorePlanner(self.catalog, areas=AREAS, path=path)
self.assertEqual(self.action(planner=restored).kind, "explore_blocked")
self.assertTrue(restored.pending(self.snapshot)["confirmed"])
self.start_confirmed(self.snapshot.raw["exploreTeams"][0])
self.assertTrue(restored.reconcile(self.snapshot))
self.assertIsNone(restored.pending(self.snapshot))
def test_success_with_stale_snapshot_never_repeats_finish_even_after_restart(self):
self.snapshot.raw["exploreTeams"][0].update(status=1, area="1", monsters="1,2,3", endTime=(NOW - 1) * 1000)
with workspace_temp() as folder:
path = folder / "state.json"
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
action = self.action(planner=planner)
planner.execute(self.snapshot, action, Mock(return_value={"resCode": 0}))
for _ in range(3):
self.assertEqual(self.action(planner=planner).kind, "explore_blocked")
self.assertFalse(planner.reconcile(self.snapshot))
restored = ExplorePlanner(self.catalog, areas=AREAS, path=path)
self.assertEqual(self.action(planner=restored).kind, "explore_blocked")
self.snapshot.raw["exploreTeams"][0].update(status=0, monsters="", endTime=0)
self.assertTrue(restored.reconcile(self.snapshot))
self.assertEqual(self.action(planner=restored).kind, "explore_start")
def test_unknown_write_requires_authoritative_matching_snapshot(self):
with workspace_temp() as folder:
planner = ExplorePlanner(self.catalog, areas=AREAS, path=folder / "state.json")
action = self.action(planner=planner)
planner.mark_started(self.snapshot, action)
planner.mark_uncertain(self.snapshot, action)
restored = ExplorePlanner(self.catalog, areas=AREAS, path=folder / "state.json")
self.assertEqual(self.action(planner=restored).kind, "explore_blocked")
self.start_confirmed(self.snapshot.raw["exploreTeams"][0])
self.assertTrue(restored.reconcile(self.snapshot))
self.assertFalse(restored.reconcile(self.snapshot))
def test_unknown_action_cannot_be_forged_or_confirmed(self):
from ranch_assistant.model import Action
action = self.action()
forged = Action("explore_start", "forged", "exploreService/start", deepcopy(action.payload))
with self.assertRaises(ValueError):
self.planner.mark_started(self.snapshot, forged)
self.planner.mark_started(self.snapshot, action)
with self.assertRaises(ValueError):
self.planner.mark_started(self.snapshot, action)
self.assertTrue(self.planner.pending(self.snapshot))
self.planner._accounts.clear()
with self.assertRaises(ValueError):
self.planner.mark_started(self.snapshot, forged)
def test_pending_persistence_hashed_role_and_has_no_credentials(self):
with workspace_temp() as folder:
path = folder / "state.json"
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path, account_key="profile-only")
action = self.action(planner=planner)
planner.mark_started(self.snapshot, action)
text = path.read_text(encoding="utf-8")
state = json.loads(text)
key = next(iter(state["accounts"]))
self.assertRegex(key, r"^[0-9a-f]{64}$")
self.assertNotIn("11", key)
for secret in ("password", "token", "sdkToken", "account_name", "session_token"):
self.assertNotIn(secret, text)
other_clock, other = make_snapshot(master={"id": 12, "ti": 100})
with other_clock:
self.assertIsNone(planner.pending(other))
self.assertEqual(planner.plan(other, policy(), self.ranch)[0].kind, "explore_start")
def test_corrupt_state_blocks_instead_of_replaying(self):
with workspace_temp() as folder:
path = folder / "state.json"
path.write_text("{broken", encoding="utf-8")
planner = ExplorePlanner(self.catalog, areas=AREAS, path=path)
self.assertEqual(self.action(planner=planner).kind, "explore_blocked")
def test_worker_rows_are_compact_plain_data(self):
from ranch_assistant.exploration_gui import prepare_exploration_rows, prepare_exploration_members
from types import SimpleNamespace
engine = SimpleNamespace(snapshot=self.snapshot, explore_planner=self.planner, explore_policy=policy(), policy=self.ranch)
rows = prepare_exploration_rows(engine)
self.assertEqual(rows[0]["monster_labels"], ["#1 绿色史莱姆 Lv.20", "#2 绿色史莱姆 Lv.15", "#3 绿色史莱姆 Lv.10"])
self.assertEqual(rows[0]["remaining_text"], "—")
json.dumps(rows)
options = prepare_exploration_members(engine, 1)
self.assertLess(len(json.dumps(options)), 4000)
if __name__ == "__main__":
unittest.main()