182 lines
9.1 KiB
Python
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()
|