Prioritize commission rewards and fix built-in battle simulation flow

This commit is contained in:
AttilaNet
2026-11-08 20:07:26 +08:00
parent 1ee030a8e3
commit 001ed9d36d
12 changed files with 260 additions and 59 deletions
+45 -1
View File
@@ -12,7 +12,7 @@ import unittest
from unittest.mock import patch
from ranch_assistant.battle_simulator import (
ExperimentalBattleRuntime, ORIGINAL_APK_SHA256, Stats, _offline_audit,
ExperimentalBattleRuntime, ORIGINAL_APK_SHA256, Stats, _offline_audit, _plain,
combat_battles, combat_tables, damage_roll, simulate,
)
@@ -262,6 +262,50 @@ class SimulatorTests(unittest.TestCase):
self.assertEqual(result["kill_monster"], {}) # Original stage enemies are mode 1.
self.assertTrue(any(e["type"] == "wave" for e in result["events"]))
def test_task1002002_lianlake_admits_original_cosmetic_controllers(self):
corpus = combat_battles()
step = corpus["task_info"]["1002002"]["steps"][0]
self.assertEqual(step["statusType"], "passStage")
stage, level = step["statusValue"]["stage"], step["statusValue"]["level"]
self.assertEqual((stage, level), ("0201", "1"))
req = request(context="task_pass_stage", battle_position={
"battleType": "stage", "stageId": stage, "stageLevel": level,
"taskTypeId": "1002002", "taskStep": 0})
req["original_data"]["battle"] = _plain(corpus["stage_info"][stage]["level"][level]["battle"])
before = deepcopy(req)
baseline = deepcopy(req)
for team in battle_of(baseline)["teams"]:
for mon in team["mons"]:
mon["controller"] = []
with patch("socket.socket", side_effect=AssertionError("No network")), \
patch("zipfile.ZipFile", side_effect=AssertionError("No APK access")):
report = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(report["supported"], report["reasons"])
result, reference = simulate(req), simulate(baseline)
self.assertEqual(result["execution_status"], "completed")
self.assertTrue(result["requires_realtime_wait"])
self.assertTrue(any(d["code"] == "cosmetic_controller" for d in result["diagnostics"]))
for key in ("events", "elapsed_ms", "units", "battle_data", "anomalies"):
self.assertEqual(result[key], reference[key], key)
self.assertEqual(report["units"][1]["stats"]["atk"], 80)
self.assertEqual(report["units"][1]["stats"]["hp"], 1100)
self.assertEqual(req, before)
def test_buff_movie_cannot_bypass_substantive_or_unknown_controller_rejection(self):
for controller in (
{"type": "buffMovie", "para": {"type": "none", "stopMove": True}},
{"type": "buffMovie", "para": {"type": "stun"}},
{"type": "buffMovie", "para": None},
{"type": "buffMovie"},
{"type": "buff", "para": {"type": "none"}},
{"type": "unknown", "para": {"type": "none"}},
):
with self.subTest(controller=controller):
result = simulate(request(enemies=[enemy(controller=[controller])]))
self.assertEqual(result["outcome"], "unsupported")
self.assertIsNone(result["battle_data"])
self.assertIn("Unsupported monster controller: " + controller["type"], result["reasons"])
def test_full_snapshot_stats_follow_monster_vo_including_server_attributes(self):
mon = monster(level=10, gAtk=3.125, gDef=2.5, gHp=30.25, gDex=1.25,
tpLevel=2, pAtk=12, pDef=8, pHp=80, pDex=3, feel=120, upStar=1)
@@ -0,0 +1,73 @@
from types import SimpleNamespace
import unittest
from unittest.mock import Mock
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog, Policy
from ranch_assistant.progression import ProgressionPlanner
from ranch_assistant.quests import QuestPolicy, TaskPlanner
from ranch_assistant.tests.test_progression import config, snapshot, step, task
class CommissionPriorityTests(unittest.TestCase):
def setUp(self):
self.catalog = Catalog()
self.tasks = {str(400 + i): task(str(400 + i), type=4, reward={"ke": reward})
for i, reward in enumerate((10, 15, 20))}
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.quest = QuestPolicy(enabled=True)
self.ranch = Policy()
def test_reward_ranking_across_cities_and_fallback_when_unavailable(self):
planner = ProgressionPlanner(self.catalog, config(self.tasks))
self.assertEqual(planner.commission_plan(self.snapshot, self.quest, self.ranch)[0].task_type_id, "402")
self.tasks["402"]["closed"] = True
planner = ProgressionPlanner(self.catalog, config(self.tasks))
self.assertEqual(planner.commission_plan(self.snapshot, self.quest, self.ranch)[0].task_type_id, "401")
self.quest.city = 1
self.assertEqual(planner.commission_plan(self.snapshot, self.quest, self.ranch)[0].payload["city"], 1)
def test_legacy_planner_uses_same_reward_order(self):
self.catalog.data["task_info"] = self.tasks
action = TaskPlanner(self.catalog).plan(self.snapshot, self.quest, self.ranch)[0]
self.assertEqual(action.payload["taskTypeId"], "402")
def test_active_commission_precedes_new_offer(self):
self.tasks["400"]["steps"] = [step("passLevel", statusValue={"level": 99})]
self.snapshot.raw["currentTasks"] = [{"id": 50, "typeId": "400", "curStep": 1}]
planner = ProgressionPlanner(self.catalog, config(self.tasks))
actions = planner.commission_plan(self.snapshot, self.quest, self.ranch)
self.assertTrue(actions[0].blocked)
self.assertFalse(any(action.kind == "progression_loop_accept" for action in actions))
def test_commission_execution_precedes_mainline_and_ranch(self):
engine = Engine(self.catalog)
engine.snapshot = demo_snapshot(self.catalog)
engine.progression_policy.enabled = engine.quest_policy.enabled = True
engine._commission_planner_available = True
engine.game_data = SimpleNamespace(task=lambda key: {"type": 4 if key == "400" else 1})
engine._progression_intents = [
{"kind": "progression_step", "task_type_id": key, "description": key}
for key in ("100", "400")]
self.assertEqual(engine.plans()[0].payload["intent"]["task_type_id"], "400")
self.assertTrue(engine._intent_policy({"task_type_id": "400"}).auto_farm)
def test_material_shortage_uses_supported_farming_source(self):
self.quest.allow_items = True
self.tasks["400"]["steps"] = [step("getItem", statusValue={"type": "30001", "num": 3, "remove": True})]
engine = Engine(self.catalog)
engine.snapshot = self.snapshot
engine.quest_policy = self.quest
engine.game_data = SimpleNamespace(task=self.tasks.get)
engine.progression_planner = Mock()
engine.progression_planner.requirement.return_value = (False, [], "missing")
engine.progression_planner.farming_intents.return_value = [{"kind": "sweep"}]
self.assertTrue(engine._commission_offer_supported("400"))
engine.progression_planner.farming_intents.return_value = []
self.assertFalse(engine._commission_offer_supported("400"))
if __name__ == "__main__":
unittest.main()
+57 -14
View File
@@ -318,9 +318,14 @@ class ProgressionGuiTests(unittest.TestCase):
self.assertEqual(window.progression_auto_farm.isChecked(), ProgressionPolicy().auto_farm)
else:
self.assertFalse(hasattr(window, "progression_auto_farm"))
self.assertEqual(window.progression_battle_mode.currentData(), "original")
self.assertIn("近似", window.progression_battle_mode.toolTip())
self.assertIn("委托", window.progression_battle_mode.toolTip())
self.assertEqual(window.progression_battle_mode.currentData(), "experimental")
self.assertEqual(window.engine.progression_policy.battle_mode, "experimental")
self.assertTrue(window.progression_battle_mode.isHidden())
settings = window.progression_tabs.widget(1).widget()
self.assertEqual(settings.layout().indexOf(window.progression_battle_mode), -1)
self.assertFalse(any("战斗模式" in label.text() for label in settings.findChildren(W.QLabel)))
for text in ("原始属性", "实验模拟", "战斗时长后提交", "近似", "实际记录"):
self.assertIn(text, window.progression_status.text())
self.assertFalse(window.strategy_toggle.isChecked())
for widget in (window.ranch_enabled, window.quest_enabled, window.daily_enabled, window.map_enabled, window.gift_enabled):
widget.setChecked(False)
@@ -364,7 +369,7 @@ class ProgressionGuiTests(unittest.TestCase):
self.wait(first)
self.wait(second)
self.assertEqual(asdict(first.read_progression_policy()), expected)
self.assertEqual(asdict(second.read_progression_policy()), asdict(ProgressionPolicy()))
self.assertEqual(asdict(second.read_progression_policy()), asdict(ProgressionPolicy()) | {"battle_mode": "experimental"})
self.assertFalse(first.strategy_toggle.isChecked())
self.assertFalse(second.strategy_toggle.isChecked())
finally:
@@ -396,15 +401,21 @@ class ProgressionGuiTests(unittest.TestCase):
finally:
window.close()
def test_battle_mode_autosaves_without_starting_and_reaches_worker_policy(self):
def test_legacy_original_mode_normalizes_for_autosave_and_worker_policy(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.engine.run_progression_once = Mock()
self.assertEqual(window.progression_battle_mode.currentData(), "original")
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("experimental"))
legacy = asdict(configured_policy()) | {"battle_mode": "original"}
window.load_config(window.config_value() | {"progression_policy": legacy})
self.assertEqual(window.progression_battle_mode.currentData(), "experimental")
self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy()))
self.assertEqual(legacy["battle_mode"], "original")
# Older GUI glue can write the hidden field again after load_config.
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("original"))
self.assertEqual(window.read_progression_policy().battle_mode, "experimental")
QTest.qWait(350)
self.wait(window)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
@@ -418,7 +429,7 @@ class ProgressionGuiTests(unittest.TestCase):
observations = []
def preview():
observations.append((window.engine.progression_policy.battle_mode, C.QThread.currentThread()))
return window.engine.snapshot, [], "已预览所选战斗模式"
return window.engine.snapshot, [], "已预览模拟战斗策略"
window.engine.refresh_progression = Mock(side_effect=preview)
window.refresh_progression()
self.wait(window)
@@ -428,6 +439,33 @@ class ProgressionGuiTests(unittest.TestCase):
finally:
window.close()
def test_saved_original_and_missing_modes_load_as_experimental_without_starting(self):
for mode in ("original", None):
with self.subTest(mode=mode), workspace_temp() as folder:
legacy = asdict(configured_policy())
if mode is None:
del legacy["battle_mode"]
else:
legacy["battle_mode"] = mode
path = folder / "settings.json"
path.write_text(json.dumps({"progression_policy": legacy}), encoding="utf-8")
window = gui.Window(folder)
window.timer.stop()
try:
window.engine.run_progression_once = Mock()
self.wait(window)
self.assertEqual(window.progression_battle_mode.currentData(), "experimental")
self.assertTrue(window.progression_battle_mode.isHidden())
self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy()))
self.assertEqual(asdict(window.engine.progression_policy), asdict(configured_policy()))
window.persist_settings()
self.assertEqual(json.loads(path.read_text(encoding="utf-8"))["progression_policy"], asdict(configured_policy()))
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
finally:
window.close()
def test_additional_and_unavailable_teams_round_trip_visibly_without_starting(self):
with workspace_temp() as folder:
window = gui.Window(folder)
@@ -710,17 +748,22 @@ class ProgressionGuiTests(unittest.TestCase):
def test_experimental_record_outcomes_keep_their_approximate_label(self):
records = [
{"battle_mode": "experimental", "faithful": False, "approximate": True, "outcome": "win"},
{"battle_mode": "experimental", "outcome": "loss"},
{"execution_mode": "experimental", "outcome": "unsupported", "reason": "能力检查未通过"},
{"battle_mode": "original", "outcome": "win"},
{"outcome": "win"},
]
original = copy.deepcopy(records)
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: [], progression_records=lambda: records)
rows = prepare_progression_views(engine).records
self.assertIn("实验近似", rows[0]["values"][4])
self.assertIn("近似,未完整验证", rows[0]["detail"])
self.assertEqual(rows[1]["values"][4], "胜利")
self.assertIn("原版运行时", rows[1]["detail"])
self.assertIn("记录未标明", rows[2]["detail"])
self.assertEqual(records[0]["outcome"], "win")
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.assertIn("记录未标明", rows[4]["detail"])
self.assertEqual(records, original)
def test_repeated_sorted_table_updates_do_not_reinsert_owned_items(self):
table = CachedTable(["编号", "名称"])