185 lines
9.7 KiB
Python
185 lines
9.7 KiB
Python
"""Aggregate contract tests; synthetic rosters and public original task data."""
|
|
from copy import deepcopy
|
|
import threading
|
|
import unittest
|
|
|
|
from ranch_assistant.battle_quick import MAX_GENERATED, prepare, simulate_quick
|
|
from ranch_assistant.battle_simulator import (
|
|
DESKTOP_DAMAGE_PROFILE, ExperimentalBattleRuntime, _prepare, combat_tables, simulate,
|
|
)
|
|
from ranch_assistant.battles import BattleOrchestrator
|
|
from ranch_assistant.game_data import ProgressionData
|
|
from ranch_assistant.tests.test_battle_simulator import battle_of, enemy, monster, request
|
|
|
|
|
|
class QuickBattleTests(unittest.TestCase):
|
|
def test_default_worker_matches_aggregate_and_preserves_detailed_entrypoint(self):
|
|
req = request()
|
|
result = ExperimentalBattleRuntime().run(req)
|
|
self.assertEqual(result, simulate_quick(req))
|
|
self.assertEqual(result["simulation_method"], "aggregate_hp_dps")
|
|
self.assertNotEqual(result["model"], simulate(req)["model"])
|
|
self.assertTrue(result["approximate"])
|
|
self.assertFalse(result["faithful"])
|
|
self.assertFalse(result["settlement_eligible"])
|
|
|
|
def test_original_player_and_authored_enemy_stats_are_preserved(self):
|
|
req = request(enemies=[enemy(atk=31, hp=101, dex=7)])
|
|
battle_of(req).update(scaleAbility=1.2, scaleHp=1.5)
|
|
detailed, _ = _prepare(req, combat_tables())
|
|
quick, report = prepare(req)
|
|
self.assertEqual([u.stats for u in quick.units], [u.stats for u in detailed.units])
|
|
self.assertEqual(report["units"][1]["stats"]["hp"], 151)
|
|
|
|
def test_unknown_controllers_skills_and_path_data_are_warnings(self):
|
|
req = request(players=[monster(species=1001020)], enemies=[enemy(controller=[
|
|
{"type": "unmodeled", "para": {}}, {"type": "monSteps", "para": {"points": ["absent"]}}])])
|
|
battle_of(req)["controller"] = [{"type": "other_effect", "para": {}}]
|
|
battle_of(req).pop("battleField")
|
|
report = ExperimentalBattleRuntime().inspect(req)
|
|
self.assertTrue(report["supported"], report["reasons"])
|
|
self.assertTrue(report["assumptions"])
|
|
self.assertIn("unmodeled", report["aggregate_controllers"])
|
|
self.assertTrue(any(d["code"] == "aggregate_skill" for d in report["diagnostics"]))
|
|
self.assertEqual(simulate_quick(req)["execution_status"], "completed")
|
|
|
|
def test_missing_growth_or_original_species_still_refuses(self):
|
|
req = request()
|
|
req["roster"]["monsters"][0].pop("gAtk")
|
|
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
|
|
req = request(enemies=[enemy(type="unknown")])
|
|
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
|
|
|
|
def test_empty_survival_battle_runs_until_original_clock(self):
|
|
req = request(seconds=3, enemies=[])
|
|
battle_of(req)["winType"] = ["2"]
|
|
result = simulate_quick(req)
|
|
self.assertEqual(result["outcome"], "win")
|
|
self.assertEqual(result["elapsed_ms"], 3000)
|
|
self.assertEqual(result["battle_data"]["leftTime"], 0)
|
|
self.assertEqual(result["terminal_reason"], "battle_time_limit")
|
|
|
|
def test_standalone_maker_has_a_bounded_real_numeric_enemy_budget(self):
|
|
req = request(seconds=140, enemies=[])
|
|
battle_of(req)["winType"] = ["2"]
|
|
battle_of(req)["controller"] = [{"type": "monMaker", "para": {
|
|
"monType": 1001010, "team": 2, "hp": 1, "atk": 0, "interval": 1}}]
|
|
result = simulate_quick(req)
|
|
self.assertEqual(result["outcome"], "win")
|
|
self.assertEqual(result["generated_units"], MAX_GENERATED)
|
|
self.assertTrue(result["spawn_bound_reached"])
|
|
self.assertGreater(result["damage_hp_lost"]["2"], 0)
|
|
self.assertEqual(result["elapsed_ms"], 140000)
|
|
|
|
def test_unknown_generated_species_is_missing_numeric_data(self):
|
|
req = request(enemies=[])
|
|
battle_of(req)["controller"] = [{"type": "monMaker", "para": {"monType": 999999999}}]
|
|
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
|
|
|
|
def test_zero_capacity_team_can_deploy_uncounted_authored_enemies(self):
|
|
req = request(enemies=[enemy(countUnit=False)])
|
|
battle_of(req)["teams"][0]["numMax"] = 0
|
|
result = simulate_quick(req)
|
|
self.assertTrue(result["supported"], result["reasons"])
|
|
self.assertIsNotNone(result["units"][1]["joined_ms"])
|
|
self.assertEqual(result["execution_status"], "completed")
|
|
|
|
def test_weak_team_loses_without_assigned_victory(self):
|
|
result = simulate_quick(request(players=[monster(level=1)], enemies=[enemy(hp=10000, atk=10000)]))
|
|
self.assertEqual(result["outcome"], "loss")
|
|
self.assertEqual(result["alive_num"], 0)
|
|
self.assertFalse(result["battle_data"]["win"])
|
|
|
|
def test_protect_any_and_protect_all_use_actual_remaining_hp(self):
|
|
req = request(seconds=3, players=[monster(level=1)], enemies=[
|
|
enemy(mid=11, team=1, protectTarget=True, hp=1, atk=0),
|
|
enemy(mid=12, team=1, protectTarget=True, hp=10000, atk=0),
|
|
enemy(mid=13, hp=100000, atk=20)])
|
|
battle_of(req).update(winType=["2"], loseType=["3", "2"])
|
|
result = simulate_quick(req)
|
|
self.assertEqual(result["outcome"], "loss")
|
|
self.assertLess(result["elapsed_ms"], 3000)
|
|
battle_of(req)["loseType"] = ["4", "2"]
|
|
result = simulate_quick(req)
|
|
self.assertEqual(result["outcome"], "win")
|
|
self.assertEqual(result["elapsed_ms"], 3000)
|
|
protected = [u for u in result["units"] if u["protect_target"]]
|
|
self.assertEqual(sum(u["hp"] > 0 for u in protected), 1)
|
|
|
|
def test_destroy_any_and_destroy_all_are_distinct(self):
|
|
req = request(seconds=3, enemies=[enemy(mid=11, destroyTarget=True, hp=1, atk=0),
|
|
enemy(mid=12, destroyTarget=True, hp=100000, atk=0)])
|
|
battle_of(req)["winType"] = ["3"]
|
|
self.assertEqual(simulate_quick(req)["outcome"], "win")
|
|
battle_of(req)["winType"] = ["4"]
|
|
result = simulate_quick(req)
|
|
self.assertEqual(result["outcome"], "loss")
|
|
self.assertGreater(next(u for u in result["units"] if u["source_id"] == "12")["hp"], 0)
|
|
|
|
def test_task_1002013_public_configuration_runs_without_changing_inputs(self):
|
|
req = request(context="task_pass_stage", damage_profile=DESKTOP_DAMAGE_PROFILE,
|
|
players=[monster(level=20), monster(102, level=20), monster(103, level=20)])
|
|
req["original_data"]["battle"] = ProgressionData().task_battle("1002013", 1)
|
|
before = deepcopy(req)
|
|
result = simulate_quick(req)
|
|
self.assertTrue(result["supported"], result["reasons"])
|
|
self.assertIn(result["outcome"], ("win", "loss"))
|
|
self.assertEqual(req, before)
|
|
boss = next(u for u in result["units"] if u["species"] == 3012010)
|
|
nest = next(u for u in result["units"] if u["species"] == 9998002)
|
|
if boss["joined_ms"] is not None:
|
|
self.assertIsNotNone(nest["died_ms"])
|
|
self.assertGreaterEqual(boss["joined_ms"], nest["died_ms"])
|
|
|
|
def test_task_1001001_blank_default_mids_preserve_original_stats(self):
|
|
req = request(context="task_battle")
|
|
req["original_data"]["battle"] = ProgressionData().task_battle("1001001", 1)
|
|
self.assertTrue(any(m.get("mid") == "" for t in battle_of(req)["teams"] for m in t["mons"] if m))
|
|
before = deepcopy(req)
|
|
detailed, _ = _prepare(req, combat_tables())
|
|
quick, report = prepare(req)
|
|
self.assertTrue(report["supported"], report["reasons"])
|
|
self.assertEqual([u.stats for u in quick.units], [u.stats for u in detailed.units])
|
|
result = simulate_quick(req)
|
|
self.assertEqual(result["execution_status"], "completed")
|
|
self.assertIn(result["outcome"], ("win", "loss"))
|
|
self.assertEqual(req, before)
|
|
|
|
def test_cap_applies_per_hit_after_expected_skill_gain(self):
|
|
req = request(players=[monster(pAtk=10000)], enemies=[enemy(hp=1000000, atk=0)],
|
|
seconds=1, damage_profile=DESKTOP_DAMAGE_PROFILE)
|
|
result = simulate_quick(req)
|
|
attack_ms = result["units"][0]["stats"]["attack_ms"]
|
|
self.assertLessEqual(result["team_budgets"]["1"]["peak_expected_dps"], round(50000 * 1000 / attack_ms, 3))
|
|
self.assertEqual(result["damage_multiplier"], 10)
|
|
self.assertEqual(result["damage_cap"], 50000)
|
|
|
|
def test_anomaly_records_and_trace_bounds_are_preserved(self):
|
|
req = request(players=[monster(mid=100001, feel=201)], trace_limit=0)
|
|
report = ExperimentalBattleRuntime().inspect(req)
|
|
result = simulate_quick(req)
|
|
for anomaly in report["anomalies"]:
|
|
self.assertIn(anomaly, result["anomalies"])
|
|
self.assertEqual(result["battle_data"]["cheatRecords"], result["anomalies"])
|
|
self.assertFalse(result["experimental_settlement_eligible"])
|
|
self.assertEqual(result["events"], [])
|
|
|
|
def test_cancel_and_technical_timeout_have_no_settlement_data(self):
|
|
event = threading.Event()
|
|
event.set()
|
|
for result in (simulate_quick(request(), cancel_event=event), simulate_quick(request(), timeout=0)):
|
|
self.assertIn(result["outcome"], ("cancelled", "timeout"))
|
|
self.assertFalse(result["terminal"])
|
|
self.assertIsNone(result["battle_data"])
|
|
|
|
def test_local_runtime_evidence_retains_model_and_hp_dps(self):
|
|
result = simulate_quick(request())
|
|
evidence = BattleOrchestrator.runtime_evidence(result, "experimental")
|
|
for name in ("model", "simulation_method", "team_budgets", "generated_units", "spawn_bound_reached"):
|
|
self.assertEqual(evidence[name], result[name])
|
|
self.assertNotIn(name, result["battle_data"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|