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