Improve task filters, exploration rewards and V4 battle simulation
This commit is contained in:
@@ -0,0 +1,184 @@
|
||||
"""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()
|
||||
Reference in New Issue
Block a user