Add automatic mining and ticket resource stages
This commit is contained in:
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user