Add automatic mining and ticket resource stages

This commit is contained in:
AttilaNet
2026-11-10 12:54:48 +08:00
parent 0109cc0d1c
commit 5082c2df5c
20 changed files with 1615 additions and 67 deletions
+2 -1
View File
@@ -99,7 +99,7 @@ class MapCacheGuiTests(unittest.TestCase):
window.engine.snapshot = snapshot
window.map_rules = {"0102": {"enabled": False, "level": "1", "limit": 3}}
original = window.engine.stage_cache.get(snapshot)
statuses = {"bd00": "特殊关卡暂不支持自动挑战"}
statuses = {"bd00": "尚未开启“允许矿洞 / 门票关卡”资源关开关"}
def reason(current, stage, policy, *, team_ids=None):
self.assertIs(current, snapshot)
self.assertTrue(policy.allow_challenge)
@@ -134,6 +134,7 @@ class MapCacheGuiTests(unittest.TestCase):
self.assertEqual(item.text(5), status)
self.assertEqual(item.toolTip(5), status)
self.assertEqual(window._map_items["bd00"].text(5), statuses["bd00"])
self.assertFalse(window.map_allow_special.isChecked())
self.assertIs(window.engine.stage_cache.rows, original)
self.assertEqual(client.calls, [])
finally:
@@ -0,0 +1,181 @@
"""Focused mining scenarios from the original m101/m113/m125 configurations."""
import unittest
from dataclasses import replace
from ranch_assistant.battle_simulator import (
ExperimentalBattleRuntime, _Battle, _prepare, combat_tables, simulate,
)
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.tests.test_battle_simulator import enemy, monster, request
from ranch_assistant.tests.test_resource_protocol import original_roster
class MiningBattleSimulationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data = ProgressionData()
@staticmethod
def mining(stage="m101"):
return {"context": "ordinary_stage", "stage_id": stage, "difficulty": 1,
"roster": original_roster(), "team": "teamB", "seed": 0,
"trace_limit": 10000, "original_data": {
"battle": ProgressionData().stage_battle(stage)}}
@staticmethod
def unit(result, source_id):
return next(unit for unit in result["units"] if unit.get("source_id") == str(source_id))
def test_original_mining_targets_are_supported_without_instant_settlement(self):
for stage in ("m101", "m113", "m125"):
with self.subTest(stage=stage):
report = ExperimentalBattleRuntime().inspect(self.mining(stage))
self.assertTrue(report["supported"], report["reasons"])
self.assertTrue(report["approximate"])
self.assertFalse(report["settlement_eligible"])
self.assertFalse(report["experimental_settlement_eligible"])
def test_m101_natural_win_requires_all_three_ore_deaths(self):
req = self.mining()
battle = req["original_data"]["battle"]
battle["teams"][0]["mons"] = [mon for mon in battle["teams"][0]["mons"]
if mon.get("protectTarget") or mon.get("destroyTarget")]
result = simulate(req)
ores = [unit for unit in result["units"] if unit["destroy_target"]]
miners = [unit for unit in result["units"] if unit["protect_target"]]
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["terminal_reason"], "objective")
self.assertEqual(len(ores), 3)
self.assertTrue(all(unit["state"] == "dead" and unit["hp"] == 0 for unit in ores))
self.assertTrue(all(unit["state"] == "active" for unit in miners))
self.assertGreater(result["elapsed_ms"], 1000)
self.assertEqual(result["battle_data"]["leftTime"], 300000 - result["elapsed_ms"])
self.assertNotIn("9998010", result["battle_data"]["killMonster"])
for miner in miners:
self.assertTrue(any(event["type"] == "attack" and event["actor"] == miner["id"]
and event["target"] == "configured-1-" + str(int(miner["lock_target"]) - 10000)
for event in result["events"]))
def test_locked_miners_do_not_switch_to_nearby_auto_target_enemies(self):
req = self.mining()
battle = req["original_data"]["battle"]
for mon in battle["teams"][0]["mons"]:
if mon.get("destroyTarget"):
mon["hp"] = 1
result = simulate(req)
miners = [unit for unit in result["units"] if unit["protect_target"]]
self.assertEqual(len(miners), 3)
for miner in miners:
attacks = [event for event in result["events"] if event["type"] == "attack"
and event["actor"] == miner["id"]]
expected = "configured-1-" + str(int(miner["lock_target"]) - 10000)
death = self.unit(result, int(miner["lock_target"]))["died_ms"]
self.assertTrue(death)
locked_attacks = [event for event in attacks if event["at_ms"] < death]
self.assertTrue(locked_attacks)
self.assertTrue(all(event["target"] == expected for event in locked_attacks))
def test_players_prefer_defense_over_non_auto_target_ore(self):
req = self.mining()
req["roster"]["monsters"][0].update(pHp=10000)
req["original_data"]["battle"]["time"] = 20
result = simulate(req)
attacks = [event for event in result["events"] if event["type"] == "attack"
and event["actor"] == "player-1"]
self.assertTrue(attacks)
self.assertTrue(all(event["target"] not in ("configured-1-1", "configured-1-2", "configured-1-3")
for event in attacks))
def test_one_miner_death_is_not_protect_all_loss(self):
req = self.mining()
battle = req["original_data"]["battle"]
battle["teams"][0]["mons"] = [mon for mon in battle["teams"][0]["mons"]
if mon.get("protectTarget") or mon.get("destroyTarget")]
for mon in battle["teams"][0]["mons"]:
if mon.get("protectTarget"):
mon["hp"] = 100 if mon["mid"] == 20001 else 1000000
elif mon.get("destroyTarget"):
mon["atk_dis"] = 1000
mon["isObject"] = False
mon["ai"] = 1
req["roster"]["monsters"][0].update(pHp=1000000)
battle["time"] = 10
result = simulate(req)
self.assertEqual(self.unit(result, 20001)["state"], "dead")
self.assertEqual(self.unit(result, 20002)["state"], "active")
self.assertEqual(self.unit(result, 20003)["state"], "active")
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["terminal_reason"], "battle_time_limit")
self.assertEqual(result["elapsed_ms"], 10000)
def test_weak_team_loses_without_any_assigned_victory(self):
for stage in ("m101", "m113", "m125"):
with self.subTest(stage=stage):
result = simulate(self.mining(stage))
self.assertEqual(result["outcome"], "loss")
self.assertTrue(result["terminal"])
self.assertFalse(result["battle_data"]["win"])
self.assertEqual(result["execution_status"], "completed")
def test_count_unit_false_miners_join_beside_a_full_player_team(self):
req = self.mining()
req["roster"]["master"]["level"] = 43
players = [monster(mid=1000001 + i, pHp=100000) for i in range(4)]
req["roster"]["monsters"] = players
req["roster"]["teams"][0]["monsters"] = [mon["id"] for mon in players]
req["original_data"]["battle"]["time"] = 1
result = simulate(req)
self.assertEqual(sum(unit["team"] == 1 and unit["count_unit"]
and unit["state"] == "active" for unit in result["units"]), 4)
self.assertTrue(all(self.unit(result, mid)["state"] == "active"
for mid in (20001, 20002, 20003)))
def test_m113_time_trigger_forces_configured_unit_into_battle(self):
req = self.mining("m113")
req["roster"]["monsters"][0].update(pHp=1000000)
result = simulate(req)
trigger = next(event for event in result["events"] if event["type"] == "trigger"
and event.get("effect") == "monJoin")
deploy = next(event for event in result["events"] if event["type"] == "deploy"
and event["actor"] == "configured-1-23")
self.assertEqual(trigger["at_ms"], 35000)
self.assertGreater(deploy["at_ms"], trigger["at_ms"])
def test_unknown_mining_objectives_and_controllers_still_refuse(self):
for kind, value in (("winType", ["2"]), ("loseType", ["4"])):
req = self.mining()
req["original_data"]["battle"][kind] = value
self.assertEqual(simulate(req)["outcome"], "unsupported")
req = self.mining()
req["original_data"]["battle"]["teams"][0]["mons"][0]["controller"].append({"type": "unknown"})
self.assertEqual(simulate(req)["outcome"], "unsupported")
def test_fix_hurt_uses_attack_value_and_source_element_guard(self):
scenario, report = _prepare(self.mining(), combat_tables())
battle = _Battle(scenario, report, combat_tables())
battle.deploy()
ore = battle.by_source_id["10001"]
player = battle.by_key["player-1"]
miner = battle.by_source_id["20001"]
self.assertGreater(ore.unit.stats.defense, 0)
player.unit = replace(player.unit, stats=replace(player.unit.stats, element=3))
battle.apply_damage(player, ore, 100, "fixture")
player_damage = battle.events[-1]["damage"]
battle.apply_damage(miner, ore, 100, "fixture")
miner_damage = battle.events[-1]["damage"]
self.assertEqual((player_damage, miner_damage), (99, 425))
def test_ordinary_elimination_behavior_and_guards_are_unchanged(self):
req = request(enemies=[enemy(hp=1), enemy(hp=1, wave=2, joinTime=4)])
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["terminal_reason"], "elimination")
self.assertTrue(any(event["type"] == "deploy" and event["wave"] == 2
for event in result["events"]))
req["original_data"]["battle"]["triggers"] = [{"type": "monDead", "effects": []}]
self.assertEqual(simulate(req)["outcome"], "unsupported")
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,115 @@
"""Independent, offline admission checks for pickaxe resource stages."""
import unittest
from types import SimpleNamespace
from ranch_assistant.battle_runtime import BattleRuntime, NATIVE_ADMISSION_ENABLED
from ranch_assistant.battle_simulator import ExperimentalBattleRuntime
from ranch_assistant.battles import BattleOrchestrator
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.maps import stages
from ranch_assistant.model import Catalog, Snapshot
from ranch_assistant.sweeping import SweepRunner
from tools.battle_runtime.inputs import MON_FIELDS
MINES = ("m101", "m113", "m125")
def original_roster():
"""A complete synthetic level-one roster, never an account snapshot."""
monster = dict.fromkeys(MON_FIELDS, 0)
monster.update(id=1000001, typeId=1001010, level=1, mode=2,
process=3, potentialLevel=1, nicName="")
history = dict.fromkeys(("numAddMoney", "numChicken", "countBattle"), 0)
history.update(dict.fromkeys(("monLib", "equipLib", "passAchi",
"guide_record", "unlockCity"), []))
history.update(dict.fromkeys((
"numFeedMonsters", "numKillMonsters", "historyGacha", "passTask",
"unlockTask", "loopTask", "unlockStage", "passStage",
"payTypeCount", "everyDayBuyProductNum"), {}))
history["guide_main"] = ""
return {
"master": {"id": 1, "level": 1, "globalAtk": 0,
"globalDef": 0, "globalHp": 0, "globalDex": 0},
"monsters": [monster], "monsterAttributes": [], "items": [],
"teams": [{"teamName": "teamB", "teamType": "battleTeam",
"monsters": [1000001, 0]}],
"history": history,
}
class ResourceRuntimeAdmissionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data = ProgressionData()
source = cls.data.manifest["source"]
cls.identity = {"apk_sha256": source["apk_sha256"],
"main_swf_sha256": source["main_swf_sha256"]}
def request(self, stage_id, purpose="offline_validation"):
return {
"context": "ordinary_stage", "stage_id": stage_id, "difficulty": 1,
"purpose": purpose, "roster": original_roster(), "team": "teamB",
"original_data": {"source": "original_apk",
"resource_identity": self.identity,
"battle": self.data.stage_battle(stage_id)},
"battle_position": {"battleType": "stage", "stageId": stage_id,
"stageLevel": "1", "taskTypeId": None, "taskStep": 0},
}
def test_original_inspection_supports_mining_without_grant_settlement(self):
for stage_id in MINES:
with self.subTest(stage=stage_id):
report = BattleRuntime().inspect(self.request(stage_id))
self.assertEqual(report["reasons"], [], report)
self.assertTrue(report["supported"], report)
self.assertTrue(report["faithful"], report)
self.assertFalse(report["settlement_eligible"], report)
def test_original_online_admission_still_requires_completed_qa(self):
orchestrator = BattleOrchestrator(None, None, BattleRuntime())
for stage_id in MINES:
with self.subTest(stage=stage_id):
request = self.request(stage_id, "settlement")
report = BattleRuntime().inspect(request)
self.assertEqual(report["settlement_eligible"], NATIVE_ADMISSION_ENABLED)
self.assertEqual(report["native_admission_validation_pending"],
not NATIVE_ADMISSION_ENABLED)
supported, reason = orchestrator.inspect({
"runtime_request": request, "battle_mode": "original"})
self.assertEqual(supported, NATIVE_ADMISSION_ENABLED, reason)
def test_experimental_model_admits_mining_without_claiming_fidelity(self):
for stage_id in MINES:
with self.subTest(stage=stage_id):
report = ExperimentalBattleRuntime().inspect(self.request(stage_id))
self.assertTrue(report["supported"], report)
self.assertTrue(report["approximate"], report)
self.assertFalse(report["faithful"], report)
self.assertFalse(report["settlement_eligible"], report)
self.assertFalse(report["experimental_settlement_eligible"], report)
class ResourceSweepBoundaryTests(unittest.TestCase):
def test_special_resource_stages_cannot_use_empty_data_sweep(self):
catalog = Catalog()
snapshot = Snapshot({
"master": {"id": 1, "ti": 1000, "money": 0},
"history": {"unlockStage": {key: [1] for key in MINES}},
"teams": [{"teamName": "teamB", "teamType": "battleTeam",
"monsters": [1000001]}],
"monsters": [{"id": 1000001}], "items": [], "currentTasks": [],
"stacks": [], "rooms": [],
})
policy = SimpleNamespace(enabled=True, team="teamB", keep_stamina=0)
for stage in stages(catalog, snapshot):
if stage.stage_id not in MINES:
continue
with self.subTest(stage=stage.stage_id):
self.assertFalse(stage.sweep)
self.assertTrue(SweepRunner(catalog).reason(snapshot, stage, policy))
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,309 @@
"""Resource-stage contracts; all network and runtime boundaries are offline fakes."""
import unittest
from copy import deepcopy
from types import SimpleNamespace
from unittest.mock import Mock
from ranch_assistant.maps import resource_stages, stages
from ranch_assistant.resource_stages import resource_entry_reason
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.stage_cache import StageCache
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_assistant.engine import Engine
from ranch_assistant.drop_statistics import analyze
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Policy
from ranch_assistant.tests.test_core import workspace_temp
class ResourceStageTests(unittest.TestCase):
def setUp(self):
self.catalog, self.snapshot = scenario()
from ranch_assistant.game_data import load_progression_data
data = load_progression_data()
self.catalog.data["stage_info"] = deepcopy(data.stages)
self.catalog.data["stage_sp"] = data.stage_sp
self.catalog.data["mine_info"] = {"mines": data.mines}
self.snapshot.raw["history"]["unlockStage"].update({k: ["1"] for k in ("m101", "m113", "m125", "lzex01", "dg202")})
self.snapshot.raw["history"]["passStage"].update({k: ["1"] for k in ("m101", "m113", "m125", "lzex01", "dg202")})
self.snapshot.raw["master"]["ti"] = 1000
self.snapshot.raw["items"] = [{"id": 1, "typeId": "20009", "num": 2}]
def stage(self, key="m101", level="1"):
if key in ("m101", "m113", "m125"):
self.snapshot.raw["history"]["unlockStage"][key] = {"1": True}
return next(row for row in stages(self.catalog, self.snapshot) if row.stage_id == key and row.level == level)
def test_resource_policy_defaults_and_strict_types(self):
policy = SweepPolicy()
self.assertFalse(policy.allow_special)
self.assertEqual(policy.keep_tickets, 0)
SweepPolicy(allow_special=True, keep_tickets=2)
for changes in ({"allow_special": 1}, {"keep_tickets": True}, {"keep_tickets": -1}):
with self.subTest(changes=changes), self.assertRaises(ValueError):
SweepPolicy(**changes)
def test_mine_category_is_from_original_mine_mapping_not_prefix_or_pick_cost(self):
mine = {"type": "mine1", "layers": [{"objs": [
{"type": "stage", "stageId": "m101", "typeId": "water1"},
{"type": "stage", "stageId": "m103", "typeId": "monster"},
]}]}
catalog = type("Catalog", (), {"data": {
"game_setting": {"cityInfo": {}}, "stage_sp": {}, "item_names": {},
"stage_info": {
"m101": {"name": "水矿", "city": 0, "special": True,
"cost": {"ti": 0, "items": [{"typeId": "20009", "num": 1}]},
"level": {"1": {"cost": 16, "battle_available": True}, "2": {"cost": 2}, "3": {"cost": 3}}},
"m103": {"name": "守卫", "city": 0, "special": True,
"cost": {"ti": 0}, "level": {"1": {"cost": 16}}},
"dg202": {"name": "地下城矿点", "city": 5, "special": True,
"cost": {"ti": 0, "items": [{"typeId": "20009", "num": 1}]},
"level": {"1": {"cost": 16}}},
}, "mine_info": {"mines": {"mine1": mine}},
}})()
snapshot = type("Snapshot", (), {"raw": {"history": {"unlockStage": {}, "passStage": {}}}})()
rows = {(row.stage_id, row.level): row for row in stages(catalog, snapshot)}
self.assertEqual(rows["m101", "1"].category, "mine")
self.assertEqual(rows["m101", "1"].stamina, 16)
self.assertTrue(rows["m101", "1"].battle_available)
self.assertEqual(rows["m101", "2"].reason, "矿点仅支持原入口难度1")
self.assertEqual(rows["m103", "1"].category, "special")
self.assertEqual(rows["dg202", "1"].category, "special")
self.assertEqual([row.stage_id for row in resource_stages(catalog, snapshot)], ["m101"])
def test_real_mine_costs_inventory_reservation_and_capability_gates(self):
for key, stamina, tool in (("m101", 16, "20009"), ("m113", 20, "20010"), ("m125", 22, "20011")):
with self.subTest(key=key):
stage = self.stage(key)
self.assertEqual((stage.category, stage.stamina), ("mine", stamina))
self.assertEqual(stage.tickets, self.catalog.item_name(tool) + "×1")
self.assertFalse(stage.sweep)
policy = SweepPolicy(enabled=True, allow_special=True)
self.assertEqual(resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy), "")
policy.keep_tickets = 2
self.assertIn("保留", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
policy.keep_tickets = 0
self.snapshot.raw["items"] = [
{"id": 1, "typeId": "20009", "num": 2, "lock": 1},
{"id": 2, "typeId": "20009", "num": 2, "usingNum": 1},
{"id": 3, "typeId": "20009", "num": 1, "busy": True},
]
self.assertEqual(resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy), "")
self.snapshot.raw["master"]["ti"] = 15
self.assertIn("体力", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
def test_default_catalog_retains_ordinary_maps_and_gains_real_mines(self):
from ranch_assistant.model import Catalog
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.resource_stages import with_resource_data
catalog = Catalog()
snapshot = demo_snapshot(catalog)
snapshot.raw["history"].setdefault("unlockStage", {})
snapshot.raw["history"].setdefault("passStage", {})
snapshot.raw["history"]["unlockStage"]["0101"] = ["1"]
snapshot.raw["history"]["unlockStage"]["m101"] = {"1": True}
snapshot.raw["history"]["passStage"]["m101"] = {"1": True}
rows = {(row.stage_id, row.level): row for row in stages(with_resource_data(catalog), snapshot)}
self.assertEqual(rows["0101", "1"].category, "ordinary")
self.assertTrue(rows["0101", "1"].unlocked)
self.assertTrue(rows["m101", "1"].battle_available)
self.assertEqual(rows["m101", "1"].stamina, 16)
def test_augmenting_after_plain_catalog_render_recomputes_classification(self):
from ranch_assistant.model import Catalog
from ranch_assistant.resource_stages import with_resource_data
catalog = Catalog()
from ranch_assistant.engine import demo_snapshot
snapshot = demo_snapshot(catalog)
self.assertEqual(next(row for row in stages(catalog, snapshot)
if row.stage_id == "m101" and row.level == "1").category, "special")
rows = {(row.stage_id, row.level): row for row in stages(with_resource_data(catalog), snapshot)}
for key in ("m101", "m113", "m125"):
self.assertEqual(rows[key, "1"].category, "mine")
self.assertTrue(rows[key, "1"].battle_available)
self.assertEqual(rows["bd00", "1"].category, "ticket")
def test_duplicate_requirements_are_combined_and_only_explicit_resources_enter(self):
policy = SweepPolicy(enabled=True, allow_special=True)
row = self.catalog.data["stage_info"]["m101"]
row["cost"]["items"] = [{"typeId": "20009", "num": 1}, {"typeId": "20009", "num": 2}]
self.assertIn("矿镐", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
self.snapshot.raw["items"][0]["num"] = 3
self.assertEqual(resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy), "")
self.assertEqual(self.stage("lzex01").category, "ticket")
self.assertEqual(self.stage("bd00").category, "ticket")
self.assertEqual(self.stage("bd01").category, "special")
self.assertEqual(self.stage("02f5").category, "special")
self.assertEqual(self.stage("dg202").category, "special")
for level in ("2", "3"):
self.assertIn("难度1", resource_entry_reason(self.catalog, self.snapshot, self.stage(level=level), policy))
self.catalog.data["stage_info"]["m101"]["level"]["1"]["battle_available"] = False
self.assertIn("战斗配置", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
policy.allow_special = False
self.assertIn("未开启", resource_entry_reason(self.catalog, self.snapshot, self.stage(), policy))
def test_old_map_cache_rebuilds_locally_and_new_cache_round_trip(self):
with workspace_temp() as folder:
path = folder / "maps.json"
import json
from dataclasses import asdict
original = StageCache(self.catalog, path).get(self.snapshot)
path.write_text(json.dumps({"schema": 1, "gameVersion": "1.9.68", "owner": str(self.snapshot.raw["master"]["id"]),
"savedAt": self.snapshot.now, "stages": [{key: value for key, value in asdict(row).items()
if key not in ("category", "battle_available")} for row in original]}, ensure_ascii=False), encoding="utf-8")
rows = StageCache(self.catalog, path).get(self.snapshot)
self.assertEqual(next(row for row in rows if row.stage_id == "m101" and row.level == "1").category, "mine")
restored = StageCache(self.catalog, path).get(self.snapshot)
self.assertEqual(next(row for row in restored if row.stage_id == "m101" and row.level == "1").category, "mine")
class ResourceStageExecutionTests(unittest.TestCase):
def setUp(self):
self.folder = self.enterContext(workspace_temp())
self.catalog, self.snapshot = scenario()
from ranch_assistant.game_data import load_progression_data
data = load_progression_data()
self.catalog.data["stage_info"] = deepcopy(data.stages)
self.catalog.data["stage_sp"] = data.stage_sp
self.catalog.data["mine_info"] = {"mines": data.mines}
self.raw = deepcopy(self.snapshot.raw)
self.raw["currentTasks"] = []
self.raw["history"]["unlockStage"]["m101"] = ["1"]
self.raw["history"]["passStage"]["m101"] = ["1"]
self.raw["master"].update(ti=1000, timeTi=0)
self.raw["master"]["level"] = 62
self.raw["items"] = [{"id": 1, "typeId": "20009", "num": 4}]
self.runtime = ExperimentalRuntime()
self.client = Mock()
self.client.snapshot.side_effect = lambda: __import__("ranch_assistant.model", fromlist=["Snapshot"]).Snapshot(deepcopy(self.raw))
self.client.call.side_effect = self.respond
self.data = ProgressionData({"task_info": {}, "stage_info": deepcopy(data.stages),
"stage_sp": data.stage_sp, "mine_info": {"mines": data.mines},
"game_setting": data.game_setting, "battle_members": data.data["battle_members"]})
self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data,
experimental_runtime=self.runtime)
self.engine.policy = Policy(enabled=False, keep_money=0)
self.engine.sweep_policy = SweepPolicy(True,
{"m101": {"enabled": True, "level": "1", "limit": 3}}, allow_challenge=False, allow_special=True)
self.engine.master_sync.settle = Mock()
self.engine.auto = True
def respond(self, path, payload):
if path == "stageService/stageStart":
return {"resCode": 0, "triggerEvent": False}
return {"resCode": 0, "reward": {"money": 25}}
def paths(self):
return [call.args[0] for call in self.client.call.call_args_list]
def test_explicit_resource_runs_model_not_sweep_even_when_challenge_is_off(self):
snapshot, _, message = self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.assertEqual(self.client.call.call_args_list[0].args[1], {"stageTypeId": "m101", "stageLevel": "1"})
self.assertEqual(self.runtime.run.call_args.args[0]["context"], "ordinary_stage")
data = self.client.call.call_args_list[1].args[1]["battleData"]
self.assertNotEqual(data["totalDamage"], 0)
self.assertEqual(self.engine.sweeper.last_outcome, "resource")
record = self.engine.battle_journal.records(snapshot)[0]
with self.engine.sweeper.statistics.connection() as db:
sample = db.execute("SELECT source, kind FROM samples WHERE stage='m101' AND level='1'").fetchone()
self.assertEqual(dict(sample), {"source": "battle:" + record["attempt_id"], "kind": "sweep"})
self.assertEqual(self.engine.sweeper.used(snapshot, self.engine.stage_cache.get(snapshot)[0].__class__(
"m101", "1", "", 0, True, True, True, 16, "")), 1)
def test_unsupported_disabled_and_bad_level_never_send_start(self):
self.runtime.supported = False
self.engine.poll()
self.client.call.assert_not_called()
def test_inventory_wait_refresh_and_direct_entry_recheck(self):
self.raw["items"][0]["num"] = 0
self.engine.poll()
self.client.call.assert_not_called()
self.raw["items"][0]["num"] = 3
self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.raw["items"][0]["num"] = 0
self.engine.poll()
self.assertEqual(len(self.paths()), 3)
self.assertEqual(self.engine.sweeper.used(self.engine.snapshot, next(row for row in stages(self.engine._map_catalog(), self.engine.snapshot)
if row.stage_id == "m101" and row.level == "1")), 1)
def test_event_reward_records_existing_kind_without_model_or_second_entry(self):
self.client.call.side_effect = lambda path, payload: {"resCode": 0, "triggerEvent": True,
"stageEvent": {"resCode": 0, "result": {"money": 9}, "costTi": 16}}
snapshot, _, message = self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart"])
self.runtime.run.assert_not_called()
self.assertEqual(self.engine.sweeper.last_outcome, "resource_event")
totals, _ = analyze(
self.catalog, self.engine.sweeper.statistics.snapshot(snapshot.raw["master"]["id"]), "m101", "1", source="all")
self.assertEqual(totals["n"], 1)
self.assertEqual(totals["spent"], 16)
self.assertEqual(totals["known"], 1)
self.engine.sweeper.remember_map_reward(snapshot, self.engine.battle_journal.records(snapshot)[0],
self.client.call.call_args_list[0].args[1], event=True)
totals, _ = analyze(self.catalog, self.engine.sweeper.statistics.snapshot(snapshot.raw["master"]["id"]), "m101", "1", source="all")
self.assertEqual(totals["n"], 1)
self.raw["items"][0]["num"] = 0
self.engine.poll()
self.assertEqual(len(self.paths()), 1)
def test_unknown_start_is_retained_without_replay(self):
self.client.call.side_effect = TimeoutError("fixture")
with self.assertRaises(TimeoutError):
self.engine.poll()
record = self.engine.battle_journal.pending(self.engine.snapshot)
self.assertEqual(record["stage_category"], "mine")
self.client.call.reset_mock()
self.engine.poll()
self.client.call.assert_not_called()
def test_default_catalog_resource_and_ordinary_coexist_and_reserved_tool_blocks(self):
from ranch_assistant.model import Catalog, Snapshot
self.catalog = Catalog()
self.snapshot = Snapshot(deepcopy(self.raw))
self.data = ProgressionData()
self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json", game_data=self.data,
experimental_runtime=self.runtime)
self.engine.policy = Policy(enabled=False, keep_money=0)
self.engine.sweep_policy = SweepPolicy(True,
{"m101": {"enabled": True, "level": "1", "limit": 3}}, allow_challenge=False, allow_special=True)
self.engine.master_sync.settle = Mock()
self.engine.auto = True
rows = {(row.stage_id, row.level): row for row in self.engine.stage_cache.get(self.snapshot)}
self.assertEqual(rows["0101", "1"].category, "ordinary")
self.assertEqual(rows["m101", "1"].category, "mine")
self.engine.poll()
self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"])
self.client.call.reset_mock()
reserved = Engine(self.catalog, self.client, self.folder / "reserved.json", game_data=self.data,
experimental_runtime=self.runtime)
reserved.policy = Policy(enabled=False, keep_money=0)
reserved.sweep_policy = SweepPolicy(True,
{"m101": {"enabled": True, "level": "1", "limit": 3}}, allow_challenge=False, allow_special=True)
reserved.master_sync.settle = Mock()
reserved.auto = True
reserved.quest_policy.item_reserves["20009"] = 4
reserved.poll()
self.client.call.assert_not_called()
def test_common_admission_aggregates_busy_inventory_and_all_reserves(self):
self.snapshot.raw["history"]["unlockStage"]["m101"] = ["1"]
self.snapshot.raw["items"] = [
{"id": 1, "typeId": "20009", "num": 2},
{"id": 2, "typeId": "20009", "num": 2, "usingNum": 1},
{"id": 3, "typeId": "20009", "num": 5, "lock": 1},
]
policy = self.engine._map_policy()
policy.keep_tickets = 1
self.engine.quest_policy.item_reserves["20009"] = 2
policy.item_reserves["20009"] = 2
self.engine._map_catalog().data["stage_info"]["m101"]["cost"]["items"] = [
{"typeId": "20009", "num": 1}, {"typeId": "20009", "num": 1}]
intent = {"kind": "map_battle", "stage_category": "mine", "battle_kind": "resource_stage",
"stage_id": "m101", "difficulty": "1", "task_id": 0}
self.assertIn("保留", self.engine.battles.resource_reason(self.snapshot, intent, policy, self.engine.policy))
self.snapshot.raw["items"][1]["usingNum"] = 0
self.assertEqual(self.engine.battles.resource_reason(self.snapshot, intent, policy, self.engine.policy), "")
@@ -0,0 +1,358 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
import unittest
import json
import copy
import threading
from dataclasses import asdict
from dataclasses import replace
from unittest.mock import Mock, patch
from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import Window
from ranch_assistant.native_widgets import IntegerInput
from ranch_assistant.model import Snapshot
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.sweeping import SweepPolicy
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_core import workspace_temp
class ResourceStageGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, window):
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy:
return
self.fail("Offline Qt task did not finish")
def maps_ready(self, window):
self.wait(window)
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.map_render_timer.running:
return
self.fail("Map rendering did not finish")
def resource_fixture(self, window):
catalog, snapshot = scenario()
from ranch_assistant.maps import stages as build_stages
cached = build_stages(catalog, snapshot)
stages = []
for row in cached:
if row.stage_id == "bd00":
continue
stages.append(row)
stages.extend([
replace(cached[0], stage_id="m101", level="1", name="矿洞", category="mine", sweep=False),
replace(cached[0], stage_id="m101", level="2", name="矿洞", category="mine", sweep=False),
replace(cached[0], stage_id="t101", level="1", name="门票关", category="ticket", sweep=False),
replace(cached[0], stage_id="bd00", level="1", name="其他特殊关", category="special", sweep=False),
])
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
cached_rows = object()
window.engine.snapshot = snapshot
window.engine.stage_cache.rows = cached_rows
window.engine.stage_cache.get = Mock(return_value=stages)
window.engine.map_stage_reason = Mock(return_value="资源不足:矿镐,单次需要 2,当前库存 1,保留 1")
for row in stages:
if row.category in ("mine", "ticket"):
row.battle_available = True
window.map_rules = {"m101": {"enabled": True, "level": "1", "limit": 4},
"t101": {"enabled": True, "level": "1", "limit": 2}}
return snapshot, cached_rows
def test_special_stages_require_separate_opt_in_and_ticket_reserve(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
self.assertIsInstance(window.map_allow_special, W.QCheckBox)
self.assertIsInstance(window.map_keep_tickets, IntegerInput)
self.assertFalse(window.map_allow_special.isChecked())
self.assertEqual(window.map_keep_tickets.value(), 0)
self.assertEqual(window.tabs.tabText(window.tabs.indexOf(window.map_page)), "自动扫荡")
self.assertFalse(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 0)
finally:
window.close()
def test_special_policy_autosaves_and_survives_restart(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.map_enabled.setChecked(True)
window.map_allow_special.setChecked(True)
window.map_keep_tickets.setValue(7)
window.pending_policy = {"sweep_policy": Mock()}
window.map_allow_special.setChecked(False)
self.assertFalse(window.engine.sweep_policy.allow_special)
self.assertFalse(window.pending_policy["sweep_policy"].allow_special)
window.map_allow_special.setChecked(True)
self.assertTrue(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 7)
QTest.qWait(350)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))["sweep_policy"]
self.assertTrue(saved["allow_special"])
self.assertEqual(saved["keep_tickets"], 7)
self.assertTrue(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 7)
finally:
window.close()
restored = Window(folder)
restored.timer.stop()
try:
self.wait(restored)
restored.show()
restored.tabs.setCurrentWidget(restored.map_page)
self.app.processEvents()
self.assertTrue(restored.map_enabled.isChecked())
self.assertTrue(restored.map_allow_special.isChecked())
self.assertTrue(restored.map_allow_special.isEnabled())
QTest.mouseClick(restored.map_allow_special, C.Qt.MouseButton.LeftButton, pos=restored.map_allow_special.rect().center())
self.assertFalse(restored.map_allow_special.isChecked())
self.assertFalse(restored.engine.sweep_policy.allow_special)
QTest.mouseClick(restored.map_allow_special, C.Qt.MouseButton.LeftButton, pos=restored.map_allow_special.rect().center())
self.assertTrue(restored.map_allow_special.isChecked())
self.assertEqual(restored.map_keep_tickets.value(), 7)
self.assertFalse(restored.strategy_toggle.isChecked())
finally:
restored.close()
def test_import_retains_resource_rules_while_execution_stays_stopped(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
sweep = SweepPolicy(enabled=True, allow_special=True, keep_tickets=9,
rules={"m101": {"enabled": True, "level": "1", "limit": 2}})
source = window.config_value() | {"sweep_policy": sweep.__dict__}
path = folder / "policies.json"
path.write_text(json.dumps(portable_config(source)), encoding="utf-8")
window.set_strategy_checked(True)
window.engine.auto = True
with patch("ranch_assistant.gui.W.QFileDialog.getOpenFileName", return_value=(str(path), "")):
window.import_policies()
self.assertTrue(window.map_allow_special.isChecked())
self.assertEqual(window.map_keep_tickets.value(), 9)
self.assertEqual(window.map_rules["m101"], {"enabled": True, "level": "1", "limit": 2})
self.assertEqual(asdict(window.engine.sweep_policy), sweep.__dict__)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
finally:
window.close()
def test_full_catalog_keeps_ordinary_and_real_mine_rows_without_rebuilding_cache(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot = window.engine.snapshot
snapshot.raw["history"].update(unlockStage={"0101": ["1"], "m101": ["1"], "m113": ["1"], "m125": ["1"]},
passStage={"0101": ["1"]})
cached_rows = window.engine.stage_cache.get(snapshot, refresh=True)
window.map_rules = {"0101": {"enabled": True, "level": "1", "limit": 3},
"m101": {"enabled": True, "level": "1", "limit": 2}}
with patch("ranch_assistant.stage_cache.stages", side_effect=AssertionError("Inventory render rebuilt map cache")), \
patch.object(window.engine, "map_stage_reason", return_value=""):
window.tabs.setCurrentWidget(window.map_page)
window.map_category.setCurrentIndex(window.map_category.findData("all"))
self.maps_ready(window)
self.assertIn("0101", window._map_items)
self.assertIn("m101", window._map_items)
for key, stamina in (("m101", 16), ("m113", 20), ("m125", 22)):
combo = window.maps_tree.itemWidget(window._map_items[key], 3)
self.assertEqual([combo.itemData(i) for i in range(combo.count())], ["1"])
self.assertIn(f"体力 单次 {stamina}", window._map_items[key].text(6))
window.map_category.setCurrentIndex(window.map_category.findData("ordinary"))
self.maps_ready(window)
self.assertIn("0101", window._map_items)
self.assertNotIn("m101", window._map_items)
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
self.maps_ready(window)
self.assertIn("m101", window._map_items)
self.assertEqual(window.map_rules["m101"], {"enabled": True, "level": "1", "limit": 2})
self.assertEqual(window.map_rules["0101"], {"enabled": True, "level": "1", "limit": 3})
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
def test_category_filter_preserves_rules_and_supported_mine_levels(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot, cached_rows = self.resource_fixture(window)
window.tabs.setCurrentWidget(window.map_page)
window.map_category.setCurrentIndex(window.map_category.findData("ordinary"))
window.render_maps()
self.maps_ready(window)
self.assertIn("普通关卡", [window.map_category.itemText(i) for i in range(window.map_category.count())])
self.assertEqual(set(window._map_items), {"0101", "0102"})
window.engine.map_stage_reason.return_value = "资源自动入场未开启"
window.map_rules["m101"]["enabled"] = False
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
window.map_keep_tickets.setValue(1)
self.maps_ready(window)
self.assertIn("m101", window._map_items)
self.assertIn("t101", window._map_items)
self.assertNotIn("bd00", window._map_items)
window.map_allow_special.setChecked(True)
self.maps_ready(window)
window._map_items["m101"].setCheckState(0, C.Qt.CheckState.Checked)
difficulty = window.maps_tree.itemWidget(window._map_items["m101"], 3)
self.assertEqual([difficulty.itemData(i) for i in range(difficulty.count())], ["1"])
self.assertEqual(window._map_items["m101"].text(5), "铜矿镐不足:单次需 1,可用 0,保留 1")
window.map_category.setCurrentIndex(window.map_category.findData("ordinary"))
self.maps_ready(window)
self.assertEqual(set(window._map_items), {"0101", "0102"})
self.assertEqual(window.map_rules["m101"], {"enabled": True, "level": "1", "limit": 4})
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
def test_resource_challenge_preserves_model_result_and_never_claims_sweep(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot, cached_rows = self.resource_fixture(window)
snapshot.raw["items"] = [{"id": 701, "typeId": "20009", "num": 10}]
window.map_allow_special.setChecked(True)
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
window.map_rules["m101"]["enabled"] = False
for status in ("暂不支持:非上场目标;lockTarget", "实验近似:真实模型结果已保存,等待结算"):
with self.subTest(status=status):
window.engine.map_stage_reason.return_value = status
window.render_maps()
self.maps_ready(window)
self.assertEqual(window._map_items["m101"].text(5), status)
window.engine.map_stage_reason.return_value = ""
window.render_maps()
self.maps_ready(window)
self.assertEqual(window._map_items["m101"].text(5), "将按实际模拟结果挑战;不是扫荡")
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
def test_legacy_gui_policy_defaults_to_resources_disabled(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
sweep = window.config_value()["sweep_policy"]
sweep.pop("allow_special")
sweep.pop("keep_tickets")
window.load_config(window.config_value() | {"sweep_policy": sweep})
self.assertFalse(window.read_sweep_policy().allow_special)
self.assertEqual(window.read_sweep_policy().keep_tickets, 0)
finally:
window.close()
def test_disabling_special_access_is_immediate_while_worker_is_busy(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
release, entered = threading.Event(), threading.Event()
try:
self.wait(window)
window.map_enabled.setChecked(True)
window.map_allow_special.setChecked(True)
window.persist_settings()
def held_worker():
entered.set()
if not release.wait(4):
raise TimeoutError("test worker was not released")
window.run_job("held_worker", held_worker)
self.assertTrue(entered.wait(1))
window.map_keep_tickets.setValue(5)
window.persist_settings()
pending = window.pending_policy["sweep_policy"]
self.assertTrue(window.engine.sweep_policy.allow_special)
self.assertTrue(pending.allow_special)
with patch.object(window, "cancel_progression") as cancel:
window.map_allow_special.setChecked(False)
self.assertTrue(window.busy)
self.assertFalse(window.engine.sweep_policy.allow_special)
self.assertFalse(pending.allow_special)
cancel.assert_not_called()
release.set()
self.wait(window)
self.assertFalse(window.engine.sweep_policy.allow_special)
self.assertEqual(window.engine.sweep_policy.keep_tickets, 5)
finally:
release.set()
self.wait(window)
window.close()
def test_resource_cost_uses_aggregated_requirements_and_current_inventory(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot, cached_rows = self.resource_fixture(window)
window.resource_catalog().data["stage_info"]["m101"] = {
"cost": {"ti": 10, "items": [{"typeId": "20009", "num": 1}, {"typeId": "20009", "num": 2}]},
"level": {"1": {"cost": 6, "battle_available": True}}}
window.resource_catalog().data["item_names"]["20009"] = "铜矿镐"
snapshot.raw["items"] = [{"id": 701, "typeId": "20009", "num": 4},
{"id": 702, "typeId": "20009", "num": 2, "usingNum": 1}]
window.map_enabled.setChecked(True)
window.map_allow_special.setChecked(True)
window.map_keep_tickets.setValue(1)
window.map_category.setCurrentIndex(window.map_category.findData("resource"))
self.maps_ready(window)
item = window._map_items["m101"]
self.assertIn("体力 单次 6 / 可用 100 / 保留 0", item.text(6))
self.assertIn("铜矿镐 单次 3 / 可用 5 / 保留 1", item.text(6))
snapshot.raw["items"][0]["num"] = 1
window.engine.snapshot = Snapshot(copy.deepcopy(snapshot.raw))
window.render_maps()
self.maps_ready(window)
self.assertIn("铜矿镐 单次 3 / 可用 2 / 保留 1", item.text(6))
self.assertIn("铜矿镐", item.text(5))
self.assertIn("单次需 3", item.text(5))
self.assertIn("可用 2", item.text(5))
self.assertIn("保留 1", item.text(5))
self.assertIs(window.engine.stage_cache.rows, cached_rows)
finally:
window.close()
class ResourceStagePolicyTests(unittest.TestCase):
def test_legacy_defaults_round_trip_and_invalid_resource_fields(self):
legacy = portable_config({})
del legacy["sweep_policy"]["allow_special"]
del legacy["sweep_policy"]["keep_tickets"]
imported = import_config(legacy)
self.assertFalse(imported["sweep_policy"]["allow_special"])
self.assertEqual(imported["sweep_policy"]["keep_tickets"], 0)
policy = SweepPolicy(allow_special=True, keep_tickets=7,
rules={"m101": {"enabled": True, "level": "1", "limit": 4}})
exported = portable_config({"sweep_policy": policy.__dict__})
self.assertEqual(import_config(exported)["sweep_policy"], policy.__dict__)
for field, invalid in (("allow_special", 1), ("keep_tickets", -1), ("keep_tickets", True)):
with self.subTest(field=field, invalid=invalid):
with self.assertRaises(ValueError):
import_config(exported | {"sweep_policy": exported["sweep_policy"] | {field: invalid}})
if __name__ == "__main__":
unittest.main()
@@ -14,6 +14,7 @@ from ranch_assistant.gui import Window
from ranch_assistant import presentation
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.engine import Engine
from ranch_assistant.stage_cache import StageCache
from ranch_assistant.api import Client, Session, encode
from ranch_assistant.tests.test_activities import scenario
from ranch_assistant.tests.test_core import workspace_temp
@@ -200,8 +201,16 @@ class ResponsivenessTests(unittest.TestCase):
catalog, snapshot = scenario()
window.catalog = catalog
window.engine.catalog = catalog
window.engine.stage_cache = StageCache(catalog)
window.engine.snapshot = snapshot
window.render_maps()
self.wait(window)
for _ in range(400):
self.app.processEvents()
QTest.qWait(5)
if not window.map_render_timer.running:
break
self.assertFalse(window.map_render_timer.running)
original = window.maps_tree.topLevelItem(0).child(0)
edit = window.maps_tree.itemWidget(original, 8)
edit.setText("12")
@@ -125,6 +125,8 @@ class RuleEditingTests(unittest.TestCase):
catalog, snapshot = scenario()
window.catalog = catalog
window.engine.catalog = catalog
from ranch_assistant.stage_cache import StageCache
window.engine.stage_cache = StageCache(catalog)
window.engine.snapshot = snapshot
window.render_maps()
self.wait(lambda: not window.map_render_timer.running)