Files
myrzx_bot/ranch_assistant/tests/test_mining_battle_simulation.py
T

182 lines
9.1 KiB
Python

"""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()