Add ranch retention, breakthroughs and exploration

This commit is contained in:
AttilaNet
2026-11-09 08:40:53 +08:00
parent f9631c3363
commit 9abc0a3de0
28 changed files with 4324 additions and 67 deletions
@@ -0,0 +1,72 @@
from copy import deepcopy
from types import SimpleNamespace
import unittest
from ranch_assistant.game_data import load_progression_data
from ranch_assistant.progression_gui import prepare_progression_views
def views(records, data=None):
engine = SimpleNamespace(snapshot=None, game_data=data, catalog=None,
progression_rows=lambda: [], progression_records=lambda: records)
return prepare_progression_views(engine).records
class BattleRecordDisplayTests(unittest.TestCase):
def test_local_story_uses_real_task_name_without_fake_combat_annotation(self):
records = [
{"kind": "progression_local_step", "battle_kind": "passStage", "task_type_id": "1002003",
"step_number": 1, "team": "teamA", "outcome": "local", "battle_mode": "experimental",
"message": "已保存普通剧情的本地检查点"},
{"kind": "progression_dialogue", "task_type_id": "2001006", "step_number": 2,
"team": "teamA", "outcome": "local", "battle_mode": "experimental"},
]
original = deepcopy(records)
rows = views(records, load_progression_data())
self.assertEqual(rows[0]["values"][2], "为了友情1 #1002003;莉安湖水猫小径(2-3) #0203,难度 1")
self.assertEqual(rows[0]["values"][3], "战队A")
self.assertEqual(rows[0]["values"][4], "剧情已推进")
self.assertEqual(rows[0]["values"][5], "已保存普通剧情的本地检查点")
self.assertEqual(rows[1]["values"][2], "逃跑的雷素 #2001006")
self.assertEqual(rows[1]["values"][1], "剧情 · NPC 对话")
for row in rows:
self.assertNotIn("近似", row["values"][4])
self.assertIn("本地剧情处理(未运行战斗)", row["detail"])
self.assertEqual(records, original)
def test_simulation_sweep_event_and_fallbacks_are_distinct(self):
data = SimpleNamespace(task=lambda key: None, stage=lambda key:
{"name": "测试关卡", "tagname": "9-20"} if key == "0920" else None)
rows = views([
{"battle_kind": "ordinary_stage", "stage_id": "0920", "difficulty": 2,
"outcome": "win", "battle_mode": "experimental", "team": "teamB"},
{"battle_kind": "sweep", "stage_id": "missing", "difficulty": 3,
"outcome": "sweep", "battle_mode": "experimental"},
{"battle_kind": "map_reward_event", "stage_id": "0920", "outcome": "event"},
{"battle_kind": "ordinary_stage", "stage_id": "0920", "outcome": "local"},
], data)
self.assertEqual(rows[0]["values"][2:5], ["测试关卡(9-20) #0920,难度 2", "战队B", "战斗胜利(模拟近似)"])
self.assertEqual(rows[1]["values"][2], "未知名称关卡 #missing,难度 3")
self.assertEqual(rows[1]["values"][4], "扫荡已完成(模拟近似)")
self.assertEqual(rows[2]["values"][4], "已获得地图事件奖励")
self.assertEqual(rows[3]["values"][4], "剧情已推进")
self.assertNotIn("battle_mode", rows[0]["detail"])
def test_unknown_internal_context_does_not_leak_into_cells(self):
row = views([{"kind": "future_internal_operation", "outcome": "done"}])[0]
self.assertEqual(row["values"][1], "其他 / 未知")
self.assertEqual(row["values"][4], "已完成")
self.assertEqual(row["category"], "unknown")
def test_task_fallback_and_rewards_do_not_expose_raw_json(self):
data = SimpleNamespace(task=lambda key: None, stage=lambda key: None)
rows = views([{"battle_kind": "task", "task_type_id": "999", "outcome": "completed",
"reward": {"money": 12, "exp": 3, "ke": 0, "items": [{"typeId": 30001, "num": 2}]}}], data)
self.assertEqual(rows[0]["values"][2], "未知名称任务 #999")
self.assertEqual(rows[0]["values"][4], "已完成")
self.assertIn("奖励:金币 12;经验 3;物品 #30001 ×2", rows[0]["detail"])
self.assertNotIn('{"money"', rows[0]["detail"])
if __name__ == "__main__":
unittest.main()
+118
View File
@@ -0,0 +1,118 @@
import copy
import unittest
from unittest.mock import patch
from ranch_assistant.breakthrough import BreakthroughPlanner, PATH, plan_breakthrough
from ranch_assistant.model import Catalog, Policy, Snapshot
def snapshot_with(**monster):
mon = {"id": 900, "typeId": 1001010, "process": 3, "mode": 2,
"potentialLevel": 1, "level": 1, "pAtk": 4, "pDef": 8,
"pHp": 105, "pDex": 1}
mon.update(monster)
return Snapshot({"master": {"id": 1}, "monsters": [mon], "items": [
{"id": 600, "typeId": 30058, "num": 4}], "stacks": [],
"rooms": [{"id": 1, "typeId": 1000}], "teams": []})
class BreakthroughTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.snapshot = snapshot_with()
self.policy = Policy(feed_targets={"900": 1})
self.planner = BreakthroughPlanner(self.catalog)
def test_original_first_breakthrough_payload_and_chinese_description(self):
action = self.planner.plan(self.snapshot, self.policy)
self.assertEqual(action.path, PATH)
self.assertEqual(action.payload, {"monId": 900, "itemIds": [600]})
self.assertEqual(action.kind, "breakthrough")
self.assertIn("突破", action.description)
self.assertIn("2 级", action.description)
self.assertNotIn("monsterPotential", action.description)
def test_incomplete_potential_blocks_even_at_ordinary_level_cap(self):
self.snapshot.monsters[900].update(pAtk=3, level=10)
self.assertIsNone(self.planner.plan(self.snapshot, self.policy))
self.assertIn("攻击 3/4", self.planner.notes[0])
def test_ordinary_level_below_cap_does_not_block_full_potential(self):
self.assertEqual(self.snapshot.monsters[900]["level"], 1)
self.assertIsNotNone(self.planner.plan(self.snapshot, self.policy))
def test_missing_or_insufficient_material_never_returns_action(self):
self.snapshot.raw["items"][0]["num"] = 3
self.assertIsNone(self.planner.plan(self.snapshot, self.policy))
self.assertIn("3/4", self.planner.notes[0])
self.snapshot.raw["items"] = []
self.assertIsNone(self.planner.plan(self.snapshot, self.policy))
def test_multiple_stacks_use_first_stack_id_and_total_stock(self):
self.snapshot.raw["items"] = [
{"id": 600, "typeId": 30058, "num": 1},
{"id": 601, "typeId": 30058, "num": 2},
{"id": 602, "typeId": 30058, "num": 8},
]
action = self.planner.plan(self.snapshot, self.policy)
self.assertEqual(action.payload["itemIds"], [600])
def test_priority_skips_blocked_candidate_and_uses_next(self):
other = copy.deepcopy(self.snapshot.monsters[900])
other.update(id=901, pAtk=3)
self.snapshot.raw["monsters"].append(other)
self.policy.feed_targets = {"901": 2, "900": 1}
self.assertEqual(self.planner.plan(self.snapshot, self.policy).payload["monId"], 900)
def test_independent_targets_replace_feed_targets(self):
other = copy.deepcopy(self.snapshot.monsters[900])
other["id"] = 901
self.snapshot.raw["monsters"].append(other)
action = self.planner.plan(self.snapshot, self.policy, targets={"901": 1})
self.assertEqual(action.payload["monId"], 901)
def test_non_ranch_disabled_and_maximum_level_do_not_plan(self):
for process in (1, 2):
self.snapshot.monsters[900]["process"] = process
self.assertIsNone(self.planner.plan(self.snapshot, self.policy))
self.snapshot.monsters[900].update(process=3, potentialLevel=7)
self.assertIsNone(self.planner.plan(self.snapshot, self.policy))
self.assertIsNone(self.planner.plan(self.snapshot, self.policy, enabled=False))
def test_invalid_and_incomplete_snapshots_are_safe(self):
for field in ("potentialLevel", "pAtk", "pDef", "pHp", "pDex"):
snapshot = snapshot_with()
snapshot.monsters[900][field] = None
self.assertIsNone(BreakthroughPlanner(self.catalog).plan(snapshot, self.policy))
snapshot = snapshot_with()
snapshot.monsters[900]["typeId"] = 999999999
self.assertIsNone(BreakthroughPlanner(self.catalog).plan(snapshot, self.policy))
def test_duplicate_item_instances_block_instead_of_double_spending(self):
self.snapshot.raw["items"] = [
{"id": 600, "typeId": 30058, "num": 2},
{"id": 600, "typeId": 30058, "num": 2},
]
self.assertIsNone(self.planner.plan(self.snapshot, self.policy))
self.assertIn("实例重复", self.planner.notes[0])
def test_second_stage_matches_original_element_table(self):
# 1-star job 5, level 1->2; level 2 requires lv1 x4 + lv2 x1.
self.snapshot.monsters[900].update(potentialLevel=2, pAtk=16, pDef=30, pHp=345, pDex=4)
self.snapshot.raw["items"] = [{"id": 600, "typeId": 30058, "num": 4},
{"id": 601, "typeId": 30041, "num": 1}]
action = self.planner.plan(self.snapshot, self.policy)
self.assertEqual(action.payload, {"monId": 900, "itemIds": [600, 601]})
def test_functional_integration_is_pure_and_makes_no_client_call(self):
with patch("ranch_assistant.api.Client.call") as call:
action = plan_breakthrough(self.catalog, self.snapshot, self.policy)
self.assertEqual(action.payload["monId"], 900)
call.assert_not_called()
if __name__ == "__main__":
unittest.main()
+47 -1
View File
@@ -13,7 +13,7 @@ from ranch_assistant.cultivation import CultivationSelector, growth_score
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.gifts import GiftPlanner
from ranch_assistant.gui import Window
from ranch_assistant.model import Catalog, Planner, Policy, Snapshot
from ranch_assistant.model import Catalog, EggRule, Planner, Policy, Snapshot
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.tests.test_core import workspace_temp
from ranch_assistant.tests.test_accounts import fake_client, role_snapshot
@@ -138,6 +138,52 @@ class CultivationTests(unittest.TestCase):
mon["gHp"] = self.catalog.monster(1001010)["hp_grow_max"]
self.assertAlmostEqual(growth_score(self.catalog, mon), .625, places=3)
def test_per_species_keep_quota_does_not_discard_better_replacement(self):
representative = monster(self.catalog, 1, level=50, scale=.3)
representative["lock"] = 1
better = monster(self.catalog, 2, scale=.8, process=2)
self.snapshot.raw["monsters"] = [representative, better]
rule = asdict(EggRule(enabled=True, action="feed", keep_count=1))
policy = Policy(manual_eggs=True, protect_star=6, protect_quality=5,
keep_better_quality=True, egg_rules={"1001010": rule})
planner = Planner(self.catalog)
self.assertIn("高于", planner.protection_reason(better, self.snapshot, policy))
self.snapshot.raw["monsters"].append(monster(self.catalog, 3, scale=.2, process=2))
self.assertEqual(planner.disposition(self.snapshot.monsters[3], self.snapshot, policy), "feed")
def test_keep_quota_defaults_to_one_and_can_keep_two(self):
hatched = monster(self.catalog, 1, process=2)
self.snapshot.raw["monsters"] = [hatched]
planner = Planner(self.catalog)
policy = Policy(manual_eggs=True, protect_star=6, protect_quality=5,
egg_rules={"1001010": asdict(EggRule(enabled=True, action="keep"))})
self.assertIn("1 / 1", planner.protection_reason(hatched, self.snapshot, policy))
policy.egg_rules["1001010"]["keep_count"] = 2
self.snapshot.raw["monsters"].append(monster(self.catalog, 2, process=3))
self.assertIn("2 / 2", planner.protection_reason(hatched, self.snapshot, policy))
self.snapshot.raw["monsters"].append(monster(self.catalog, 3, process=3))
self.assertEqual(planner.disposition(hatched, self.snapshot, policy), "keep")
self.assertNotIn("保留数量", planner.protection_reason(hatched, self.snapshot, policy))
def test_inferior_duplicate_feeds_same_species_until_current_cap(self):
target = monster(self.catalog, 10, level=9, scale=.8)
target["potentialLevel"] = 1
food = monster(self.catalog, 11, level=1, scale=.2)
other = monster(self.catalog, 12, level=1, species=1002010)
other["potentialLevel"] = 1
self.snapshot.raw["monsters"] = [target, food, other]
rule = asdict(EggRule(enabled=True, action="feed", keep_count=1))
policy = Policy(manual_eggs=True, protect_star=6, protect_quality=5,
egg_rules={"1001010": rule, "1002010": asdict(EggRule(enabled=True, action="feed"))},
feed_targets={"12": 1})
planner = Planner(self.catalog)
planner.managed.update((11, 12))
feeds = [action for action in planner.plan(self.snapshot, policy) if action.kind == "feed"]
self.assertEqual(feeds[0].payload["targetId"], 10)
target.update(level=10, potentialLevel=1, exp=self.catalog.data["monster_level"]["10"])
target["level"] = 10
self.assertIsNone(planner.same_species_feeding_target(food, self.snapshot, policy))
class CultivationGuiTests(unittest.TestCase):
@classmethod
@@ -224,7 +224,7 @@ class AnalysisGuiTests(unittest.TestCase):
try:
self.wait(lambda: not window.busy and window.engine.snapshot is not None)
labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
self.assertEqual(labels[labels.index("自动扫荡") + 1], "数据分析")
self.assertEqual(labels[labels.index("自动探险") + 1], "数据分析")
window.tabs.setCurrentWidget(window.analysis_page)
self.wait(lambda: not window.analysis_page.row_batch.running)
with patch.object(window.engine, "poll", side_effect=AssertionError("Analysis must not refresh game state")):
+203
View File
@@ -0,0 +1,203 @@
"""Offline exploration policy, wire intent, state and native GUI tests."""
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from copy import deepcopy
from dataclasses import asdict
import json
import unittest
from unittest.mock import patch
from ranch_assistant.exploration import ExplorePlanner, ExplorePolicy, ExploreTeamRule, load_exploration_areas
from ranch_assistant.model import Catalog, Policy, Snapshot
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):
table = Catalog().monster("1001010")
growth = {name: (table[name + "_grow_min"] + table[name + "_grow_max"]) / 2
for name in ("atk", "def", "hp", "dex")}
return {"id": mid, "typeId": "1001010", "level": level, "process": 3, "mode": 2,
"gAtk": growth["atk"], "gDef": growth["def"], "gHp": growth["hp"], "gDex": growth["dex"], "lock": False, **changes}
def make_snapshot(**changes):
value = {"master": {"id": 11, "ti": 100}, "items": [], "stacks": [], "rooms": [], "teams": [],
"monsters": [monster(1, 20), monster(2, 15), monster(3, 10), monster(4, 8), monster(5, 5)],
"history": {"passTask": {"1001008": True}, "passStage": {"0101": True, "0102": True}},
"exploreTeams": [{"id": 1, "status": 0, "area": "", "monsters": []}], **changes}
return Snapshot(value, received_at=1_700_000_000)
class ExplorationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.snapshot = make_snapshot()
self.ranch = Policy(protect_star=6, protect_quality=5, keep_better_quality=False)
self.policy = ExplorePolicy(True, {"1": ExploreTeamRule(True, "1")})
self.planner = ExplorePlanner(self.catalog, areas=AREAS)
def test_real_static_data_is_complete_normal_team_only(self):
areas = load_exploration_areas()
self.assertEqual(len(areas), 22)
self.assertEqual(areas["1"]["name"], "废弃矿洞")
self.assertEqual(areas["1"]["level"], [4, 1, 1])
self.assertTrue(all(row["team"] == "normal" and len(row["level"]) == 3 for row in areas.values()))
def test_policy_roundtrip_and_strict_validation(self):
encoded = json.loads(json.dumps(self.policy.to_dict()))
self.assertEqual(ExplorePolicy.from_dict(encoded), self.policy)
for value in ({"enabled": 1}, {"reserve_ti": -1}, {"reserve_ti": True},
{"teams": {"0": {"enabled": True, "area": "1"}}},
{"teams": {"1": {"enabled": True, "area": "bad"}}},
{"teams": {"1": {"enabled": True, "unknown": 1}}}):
with self.subTest(value=value), self.assertRaises(ValueError):
ExplorePolicy(**(asdict(ExplorePolicy()) | value))
def test_disabled_and_feature_gate_do_not_emit_requests(self):
self.assertEqual(self.planner.plan(self.snapshot, ExplorePolicy(), self.ranch), [])
self.snapshot.raw["history"]["passTask"] = {}
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "explore_blocked")
self.assertIn("尚未解锁", action.description)
def test_start_payload_and_three_level_ordered_members(self):
original = deepcopy(self.snapshot.raw)
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "explore_start")
self.assertEqual(action.path, "exploreService/start")
self.assertEqual(action.payload, {"exploreTeamId": 1, "monsters": [1, 2, 3], "area": "1"})
self.assertEqual(self.snapshot.raw, original)
for mon in self.snapshot.raw["monsters"]:
mon["level"] = 4
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
for mon in self.snapshot.raw["monsters"]:
mon["level"] = 20
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch)[0].payload["monsters"], [1, 2, 3])
def test_protected_and_unavailable_monsters_are_never_selected(self):
for field in ("lock", "sysLock", "entangle", "inExploreTeam", "inBuild"):
with self.subTest(field=field):
snapshot = make_snapshot()
snapshot.raw["monsters"][0][field] = True
action = self.planner.plan(snapshot, self.policy, self.ranch)[0]
self.assertNotIn(1, action.payload["monsters"])
snapshot = make_snapshot()
snapshot.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [1]}]
self.assertNotIn(1, self.planner.plan(snapshot, self.policy, self.ranch)[0].payload["monsters"])
snapshot = make_snapshot()
self.ranch.feed_targets = {"1": 1}
self.assertNotIn(1, self.planner.plan(snapshot, self.policy, self.ranch)[0].payload["monsters"])
def test_area_unlock_occupancy_reserve_and_status_reasons(self):
self.snapshot.raw["history"]["passStage"] = {"0101": True, "0102": True}
self.snapshot.raw["master"]["ti"] = 19
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
self.assertEqual(self.planner.rows(self.snapshot, self.policy, self.ranch)[0]["state"], "体力不足")
self.policy.reserve_ti = 81
self.snapshot.raw["master"]["ti"] = 100
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
self.policy.reserve_ti = 0
self.snapshot.raw["exploreTeams"].append({"id": 2, "status": 1, "area": "1", "endTime": 1_800_000_000_000})
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
self.assertEqual(self.planner.rows(self.snapshot, self.policy, self.ranch)[0]["state"], "地区占用")
self.snapshot.raw["history"]["passStage"] = {"0102": True}
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch), [])
self.snapshot.raw["exploreTeams"].pop()
self.snapshot.raw["history"]["passStage"]["0101"] = True
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "explore_start")
def test_finish_takes_priority_and_uses_seconds_or_milliseconds(self):
self.snapshot.raw["exploreTeams"][0].update(status=1, area="1", endTime=1_699_000_000_000,
monsters=[1, 2, 3])
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual((action.kind, action.path), ("explore_finish", "exploreService/finish"))
self.assertEqual(action.payload, {"exploreTeamId": 1})
self.assertEqual(self.planner.rows(self.snapshot, self.policy, self.ranch)[0]["state"], "可领取")
def test_unknown_write_is_never_replayed_and_state_can_resume(self):
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.planner.mark_started(self.snapshot, action)
with self.assertRaises(ValueError):
self.planner.mark_started(self.snapshot, action)
self.planner.mark_uncertain(self.snapshot, action)
blocked = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(blocked.kind, "explore_blocked")
self.assertIn("禁止", blocked.description)
state = self.planner.export_state()
restored = ExplorePlanner(self.catalog, areas=AREAS)
restored.restore_state(deepcopy(state))
self.assertEqual(restored.plan(self.snapshot, self.policy, self.ranch)[0].kind, "explore_blocked")
self.assertTrue(self.planner.acknowledge(self.snapshot, action, {}))
self.assertEqual(self.planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "explore_start")
def test_finish_ack_clears_pending_without_modifying_snapshot(self):
self.snapshot.raw["exploreTeams"][0].update(status=1, area="1", endTime=1)
action = self.planner.plan(self.snapshot, self.policy, self.ranch)[0]
original = deepcopy(self.snapshot.raw)
self.planner.mark_started(self.snapshot, action)
self.assertTrue(self.planner.acknowledge(self.snapshot, action, {"resCode": 0}))
self.assertEqual(self.snapshot.raw, original)
class ExplorationGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
from PySide6 import QtWidgets as W
cls.app = W.QApplication.instance() or W.QApplication([])
def test_native_page_controls_autosave_and_render(self):
from types import SimpleNamespace
from ranch_assistant.exploration_gui import ExplorationPages
class Window(ExplorationPages):
pass
window = Window()
window.closed = window.loading_config = False
window.pending_policy = None
window.catalog = Catalog()
snapshot = make_snapshot()
window.engine = SimpleNamespace(snapshot=snapshot, policy=Policy(protect_star=6, protect_quality=5),
explore_policy=ExplorePolicy(), explore_planner=ExplorePlanner(window.catalog, areas=AREAS))
window.settings_changed = lambda: setattr(window, "saved", True)
window.tabs = __import__("PySide6.QtWidgets", fromlist=["QTabWidget"]).QTabWidget()
window.busy = False
window.exploration_tab()
try:
window.render_exploration()
self.assertEqual(window.exploration_table.rowCount(), 1)
window._exploration_controls["1"]["enabled"].setCheckState(__import__("PySide6.QtCore", fromlist=["Qt"]).Qt.CheckState.Checked)
window.exploration_item_changed(window._exploration_controls["1"]["enabled"])
self.assertTrue(window.read_explore_policy().teams["1"].enabled)
self.assertTrue(window.saved)
window.engine.explore_policy = window.read_explore_policy()
window._exploration_controls["1"]["area"].setCurrentIndex(0)
window.engine.explore_policy = window.read_explore_policy()
window.render_exploration()
self.assertEqual(window.exploration_table.item(0, 3).text(), "可出发")
window.explore_enabled.setChecked(True)
self.assertTrue(window.engine.explore_policy.enabled)
window.explore_reserve_ti.setValue(10)
self.assertEqual(window.engine.explore_policy.reserve_ti, 10)
window.apply_explore_policy({"enabled": False, "reserve_ti": 0,
"teams": {"1": {"enabled": True, "area": "1"}}})
window.render_exploration()
self.assertEqual(window.exploration_table.item(0, 3).text(), "可出发")
self.assertIn("测试矿洞", window._exploration_controls["1"]["area"].currentText())
finally:
window.tabs.close()
if __name__ == "__main__":
unittest.main()
@@ -756,12 +756,12 @@ class ProgressionGuiTests(unittest.TestCase):
original = copy.deepcopy(records)
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: [], progression_records=lambda: records)
rows = prepare_progression_views(engine).records
for row, outcome in zip(rows, ("胜利", "打不过", "暂不支持")):
self.assertEqual(row["values"][4], outcome + "(实验近似)")
self.assertIn("近似,未完整验证", row["detail"])
for row, outcome in zip(rows, ("战斗胜利", "打不过", "暂不支持")):
self.assertEqual(row["values"][4], outcome + "(模拟近似)")
self.assertIn("结果近似", row["detail"])
self.assertIn("能力检查未通过", rows[2]["detail"])
self.assertEqual(rows[3]["values"][4], "胜利")
self.assertIn("原版运行时", rows[3]["detail"])
self.assertEqual(rows[3]["values"][4], "战斗胜利")
self.assertIn("原版战斗运行时", rows[3]["detail"])
self.assertIn("记录未标明", rows[4]["detail"])
self.assertEqual(records, original)
@@ -0,0 +1,48 @@
import copy
import unittest
import unittest.mock
from dataclasses import asdict
from unittest.mock import Mock
from ranch_assistant.breakthrough import PATH as BREAKTHROUGH_PATH
from ranch_assistant.engine import Engine
from ranch_assistant.exploration import ExplorePolicy
from ranch_assistant.model import Action, Catalog, EggRule, Policy
from ranch_assistant.tests.test_breakthrough import snapshot_with
from ranch_assistant.tests.test_core import workspace_temp
class RanchAutomationIntegrationTests(unittest.TestCase):
def test_breakthrough_is_opt_in_ordered_and_called_with_original_payload(self):
client = Mock()
snapshot = snapshot_with()
client.snapshot.return_value = snapshot
engine = Engine(Catalog(), client)
engine.snapshot = snapshot
engine.policy = Policy(feed_targets={"900": 1}, breakthrough_targets={"900": 1},
egg_rules={}, enabled=True)
engine.policy.breakthrough_targets = {}
self.assertFalse(any(action.kind == "breakthrough" for action in engine.plans()))
engine.policy.breakthrough_targets = {"900": 1}
# A checked breakthrough is also a feeding target; it uses the same order.
action = engine.plans()[0]
self.assertEqual((action.kind, action.path, action.payload),
("breakthrough", BREAKTHROUGH_PATH, {"monId": 900, "itemIds": [600]}))
client.call.return_value = {"resCode": 0}
engine.auto = True
with unittest.mock.patch.object(engine, "read_snapshot"):
# Integration route uses the ordinary Action executor, no custom URL.
engine.explore_policy = ExplorePolicy()
self.assertEqual(action.description.split("(")[0], "突破 #900 绿色史莱姆 → 2 级")
def test_egg_keep_count_is_in_policy_and_export(self):
from ranch_assistant.policy_io import portable_policy
rule = EggRule(enabled=True, action="keep", keep_count=2)
policy = Policy(egg_rules={"1001010": asdict(rule)}, breakthrough_targets={"900": 2})
value = portable_policy(policy)
self.assertEqual(value["policy"]["egg_rules"]["1001010"]["keep_count"], 2)
self.assertEqual(value["targetSpecies"]["breakthrough"], [{"typeId": "", "priority": 2}])
if __name__ == "__main__":
unittest.main()
+5 -5
View File
@@ -64,11 +64,11 @@ class RanchTreeTests(unittest.TestCase):
self.assertIs(tree.itemWidget(item, 9), priority)
self.assertTrue(check.isChecked())
self.assertEqual(priority.value(), 2)
self.assertTrue(tree.itemWidget(item, 17).isChecked())
self.assertEqual(tree.itemWidget(item, 18).value(), 3)
self.assertTrue(tree.itemWidget(item, 19).isChecked())
self.assertEqual(tree.itemWidget(item, 20).value(), 3)
self.assertFalse(tree.group_items["room:1"].isExpanded())
self.assertEqual(tree.selected_monster_ids(), [900])
self.assertTrue(item.text(15).startswith("30 /"))
self.assertTrue(item.text(17).startswith("30 /"))
finally:
tree.row_batch.stop()
tree.close()
@@ -129,8 +129,8 @@ class RanchTreeTests(unittest.TestCase):
item = tree.monster_items[900]
tree.itemWidget(item, 8).setChecked(True)
tree.itemWidget(item, 9).setValue(4)
tree.itemWidget(item, 17).setChecked(True)
tree.itemWidget(item, 18).setValue(5)
tree.itemWidget(item, 19).setChecked(True)
tree.itemWidget(item, 20).setValue(5)
self.assertEqual(window.read_policy().feed_targets, {"900": 4})
self.assertEqual(window.read_policy().gift_targets, {"900": 5})
tree.setCurrentItem(item)
+1 -1
View File
@@ -101,7 +101,7 @@ class RuleEditingTests(unittest.TestCase):
self.app.processEvents()
parent = tree.group_items["room:1"] if grouped else tree.invisibleRootItem()
self.assertEqual([parent.child(i).data(0, C.Qt.ItemDataRole.UserRole) for i in range(3)], [902, 901, 900])
tree.sortByColumn(17, C.Qt.SortOrder.DescendingOrder)
tree.sortByColumn(19, C.Qt.SortOrder.DescendingOrder)
self.app.processEvents()
self.assertEqual(parent.child(0).data(0, C.Qt.ItemDataRole.UserRole), 901)
self.assertTrue(tree.monster_items[901].textAlignment(2) & C.Qt.AlignmentFlag.AlignHCenter)
+1 -1
View File
@@ -172,7 +172,7 @@ class V11GuiTests(unittest.TestCase):
self.app.processEvents()
QTest.qWait(2)
target_item = window.monsters.monster_items[900]
window.monsters.itemWidget(target_item, 17).setChecked(True)
window.monsters.itemWidget(target_item, 19).setChecked(True)
self.assertIn("900", window.read_policy().gift_targets)
window.monster_view.setCurrentIndex(1)
self.assertFalse(window.monsters.rootIsDecorated())