Files
myrzx_bot/ranch_assistant/tests/test_battle_damage_profile.py
T

185 lines
10 KiB
Python

"""V4 final-damage profile boundaries; all fixtures are offline."""
from copy import deepcopy
from dataclasses import replace
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from ranch_assistant.battle_simulator import (
DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE, ExperimentalBattleRuntime,
_Battle, _prepare, combat_tables,
)
from ranch_assistant.battles import BattleOrchestrator
from ranch_assistant.engine import Engine
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.tests.test_battle_simulator import enemy, monster, request
def prepared(req):
scenario, report = _prepare(req, combat_tables())
battle = _Battle(scenario, report, combat_tables())
battle.deploy()
return battle
class DamageProfileTests(unittest.TestCase):
def test_default_offline_profile_and_explicit_v4_metadata(self):
original = request()
self.assertEqual(ExperimentalBattleRuntime().inspect(original)["damage_profile"], DEFAULT_DAMAGE_PROFILE)
original["damage_profile"] = DESKTOP_DAMAGE_PROFILE
report = ExperimentalBattleRuntime().inspect(original)
self.assertEqual(report["damage_profile"], "client_v4_x10")
self.assertEqual((report["damage_multiplier"], report["damage_cap"]), (10, 50000))
self.assertTrue(report["damage_profile_digest"])
self.assertTrue(report["approximate"] and report["faithful"] is False)
self.assertIn("Unknown damage profile", ExperimentalBattleRuntime().inspect(
request(damage_profile="unknown"))["reasons"])
self.assertFalse(ExperimentalBattleRuntime().inspect(request(damage_profile="unknown"))["supported"])
def test_v4_applies_once_with_cap_and_does_not_mutate_stats_or_request(self):
req = request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE)
before = deepcopy(req)
battle = prepared(req)
player, target = battle.by_key["player-1"], battle.by_key["configured-1-1"]
stats = replace(target.unit.stats)
hp = target.hp
self.assertEqual(battle.hurt(target, 100, player, "fixture"), 1000)
self.assertEqual(target.hp, hp - 1000)
self.assertEqual(battle.events[-1]["damage"], 1000)
self.assertEqual(battle.events[-1]["damage_profile"], DESKTOP_DAMAGE_PROFILE)
self.assertEqual(battle.events[-1]["damage_cap"], 50000)
self.assertEqual(battle.hurt(target, 5001, player, "fixture"), 50000)
self.assertEqual(target.unit.stats, stats)
self.assertEqual(req, before)
def test_enemy_environment_friendly_non_team2_and_zero_are_unchanged(self):
req = request(enemies=[enemy(hp=200000), enemy(team=3, hp=200000)],
damage_profile=DESKTOP_DAMAGE_PROFILE)
battle = prepared(req)
player = battle.by_key["player-1"]
target = battle.by_key["configured-1-1"]
other_team = battle.by_key["configured-1-2"]
self.assertEqual(battle.hurt(player, 100, target, "enemy"), 100)
self.assertEqual(battle.hurt(target, 100, None, "environment"), 100)
self.assertEqual(battle.hurt(other_team, 100, player, "other_team"), 100)
self.assertEqual(battle.hurt(target, 0, player, "zero"), 0)
def test_real_attack_uses_the_same_final_hp_order(self):
battle = prepared(request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE))
target, player = battle.by_key["configured-1-1"], battle.by_key["player-1"]
self.assertEqual(battle.hurt(target, 10, player, "real", real_attack=True), 100)
self.assertEqual(battle.hurt(target, 6000, player, "real", real_attack=True), 50000)
self.assertEqual(battle.hurt(player, 100, target, "real", real_attack=True), 100)
def test_reduction_precedes_v4_cap_in_both_hp_branches(self):
for real_attack in (False, True):
with self.subTest(real_attack=real_attack):
battle = prepared(request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE))
target, player = battle.by_key["configured-1-1"], battle.by_key["player-1"]
target.unit = replace(target.unit, stats=replace(target.unit.stats, damage_reduction=.5))
self.assertEqual(battle.hurt(target, 100, player, "reduced", real_attack=real_attack), 500)
self.assertEqual(battle.hurt(target, 11000, player, "reduced_cap", real_attack=real_attack), 50000)
def test_mining_fixed_hurt_precedes_multiplier_for_player_and_npc(self):
def fixture():
return prepared({"context": "ordinary_stage", "roster": {"master": {"level": 43},
"monsters": [monster()], "teams": [{"teamName": "teamA", "monsters": [101]}],
"monsterAttributes": []}, "team": "teamA", "damage_profile": DESKTOP_DAMAGE_PROFILE,
"original_data": {"battle": ProgressionData().stage_battle("m101")}})
battle = fixture()
player, ore = battle.by_key["player-1"], battle.by_source_id["10001"]
player.unit = replace(player.unit, stats=replace(player.unit.stats, element=3))
ore.unit = replace(ore.unit, hurt_types={**ore.unit.hurt_types, "3": 1})
self.assertEqual(battle.hurt(ore, 100, player, "fixed_hurt"), 2000)
battle = fixture()
self.assertEqual(battle.hurt(battle.by_source_id["10001"], 100,
battle.by_source_id["20001"], "fixed_hurt"), 5000)
def test_worker_transports_profile_and_battle_evidence_discloses_it(self):
req = request(enemies=[enemy(hp=200000)], damage_profile=DESKTOP_DAMAGE_PROFILE)
result = ExperimentalBattleRuntime().run(req)
self.assertEqual(result["damage_profile"], DESKTOP_DAMAGE_PROFILE)
self.assertEqual(result["damage_cap"], 50000)
self.assertEqual(next(e for e in result["events"] if e["type"] == "damage")["damage_profile"],
DESKTOP_DAMAGE_PROFILE)
evidence = BattleOrchestrator.runtime_evidence(result, "experimental")
self.assertEqual(evidence["damage_profile"], DESKTOP_DAMAGE_PROFILE)
self.assertEqual((evidence["damage_multiplier"], evidence["damage_cap"]), (10, 50000))
self.assertEqual(evidence["damage_profile_digest"], result["damage_profile_digest"])
class DesktopProfileTests(unittest.TestCase):
@staticmethod
def engine():
engine = object.__new__(Engine)
engine._ensure_progression = lambda: None
engine._select_battle_runtime = lambda mode: None
engine._battle_snapshot_source = None
engine._battle_snapshot_digest = ""
engine._battle_roster_digest = None
engine._battle_roster = None
engine.game_data = SimpleNamespace(
stage_battle=lambda stage, difficulty: {"stage": stage, "difficulty": difficulty},
task_battle=lambda task, step: {"task": task, "step": step}, manifest={})
from ranch_assistant.battle_runtime import BattleRuntime
engine.battles = SimpleNamespace(runtime=BattleRuntime())
return engine
def test_all_desktop_contexts_and_original_subrequest_carry_v4(self):
snapshot = SimpleNamespace(raw={"master": {"level": 43}, "monsters": [], "teams": []})
cases = (
({"battle_kind": "ordinary_stage", "stage_id": "0101", "difficulty": 1}, "ordinary_stage"),
({"battle_kind": "task", "task_type_id": 100, "step_number": 1}, "task_battle"),
({"battle_kind": "task", "task_type_id": 200, "step_number": 1}, "task_battle"),
({"battle_kind": "resource_stage", "stage_id": "m101", "difficulty": 1,
"stage_category": "mine"}, "ordinary_stage"),
)
for intent, context in cases:
for mode in ("experimental", "original"):
engine = self.engine()
with self.subTest(intent=intent, mode=mode):
req = Engine._battle_request(engine, snapshot, intent,
SimpleNamespace(battle_mode=mode), {"damage_profile": DEFAULT_DAMAGE_PROFILE,
**{key: intent.get(key) for key in ("stage_id", "difficulty", "task_type_id", "step_number")}})
self.assertEqual(req["context"], context)
self.assertEqual(req["damage_profile"],
DESKTOP_DAMAGE_PROFILE if mode == "experimental" else DEFAULT_DAMAGE_PROFILE)
if mode == "original":
self.assertNotIn("damage_profile", req["runtime_request"])
def test_map_failure_signature_is_scoped_to_v4(self):
engine = self.engine()
snapshot = SimpleNamespace(raw={"master": {"level": 43},
"teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}],
"monsters": [monster()], "monsterAttributes": []})
first = engine._map_roster_signature(snapshot, "teamA")
self.assertNotEqual(first, engine._map_roster_signature(snapshot, "teamB"))
with patch("ranch_assistant.battle_simulator.DESKTOP_DAMAGE_PROFILE", DEFAULT_DAMAGE_PROFILE):
self.assertNotEqual(first, engine._map_roster_signature(snapshot, "teamA"))
def test_capability_cache_is_scoped_to_actual_mode_profile(self):
engine = self.engine()
engine.quest_policy = SimpleNamespace(battle_tasks=True)
engine._is_commission = lambda intent: False
engine._is_farm = lambda intent: False
engine._intent_policy = lambda intent: policy
engine.progression_policy = SimpleNamespace(battle_mode="experimental")
engine.snapshot = SimpleNamespace()
engine.policy = SimpleNamespace()
engine._battle_snapshot_digest = "fixture"
engine._capability_cache = {}
policy = SimpleNamespace(battle_mode="experimental", team="teamA")
engine.battles = SimpleNamespace(runtime=object(), request=lambda *args: {},
resource_reason=lambda *args: "", inspect=lambda req: (True, ""))
with patch("ranch_assistant.engine.digest", side_effect=lambda value: value["damage_profile"]):
self.assertEqual(engine._battle_capability({}), (True, ""))
self.assertEqual(engine._battle_capability({}), (True, ""))
self.assertEqual(len(engine._capability_cache), 1)
policy.battle_mode = "original"
self.assertEqual(engine._battle_capability({}), (True, ""))
self.assertEqual(set(engine._capability_cache), {DEFAULT_DAMAGE_PROFILE, DESKTOP_DAMAGE_PROFILE})
if __name__ == "__main__":
unittest.main()