"""Tests for the ``repair_weapon`` action (repairing a broken weapon). L8 of the ``llm-policy-contract`` plan: ``Action`` gains a ``repair_weapon`` kind (reusing the existing ``weapon_id`` field) so a policy can restore a weapon that a sunder maneuver broke. The weapon is removed from ``state.weapon_broken``, its accumulated damage is reset, and the transient ``disarmed`` condition originating from the sunder is removed so the repaired weapon is fully usable again via ``usable_attacks()``. No default policy emits ``repair_weapon``; it is only accepted by ``_execute`` (usage via custom policy / LLM). """ from __future__ import annotations from pf1e_simulator.combat import Action, CombatantState, CombatEngine from pf1e_simulator.conditions import Condition from pf1e_simulator.effects import ActiveCondition, StatModifier from pf1e_simulator.grid import Grid from pf1e_simulator.map import MapSpec, TerrainType from pf1e_simulator.models import ( AbilityScores, ACProfile, AttackSpec, Combatant, DamageComponent, Saves, ) from pf1e_simulator.rng import ScriptedRng, SeededRng def make_combatant(cid: str, *, attack_bonus: int = 2) -> Combatant: attack = AttackSpec( id=f"{cid}-w", name="sword", kind="melee", attack_bonus=attack_bonus, damage=[DamageComponent(formula="1d4", types=["slashing"])], ) return Combatant( id=cid, name=cid, level=1, size="Medium", abilities=AbilityScores( str_score=10, dex_score=10, con_score=10, int_score=10, wis_score=10, cha_score=10, ), hp_max=6, ac=ACProfile(total=13, touch=13, flat_footed=13), bab=attack_bonus, initiative_mod=0, speed_land_ft=30, saves=Saves(fort=0, ref=0, will=0), attacks=[attack], ) def make_state(combatant: Combatant, side: str, pos: tuple[int, int]) -> CombatantState: return CombatantState(combatant=combatant, side=side, pos=pos, hp=combatant.hp_max) def make_grid() -> Grid: legend = {".": TerrainType(type="floor", move_cost=1)} spec = MapSpec(name="test", terrain=tuple(["." * 8] * 8), legend=legend) return Grid.from_spec(spec) def make_engine(queue: list[int], states: list[CombatantState]) -> CombatEngine: return CombatEngine(ScriptedRng(queue), make_grid(), states) def _weapon_ids(state: CombatantState) -> list[str]: return [w.id for w in state.usable_attacks()] def _sunder_disarmed_condition() -> ActiveCondition: return ActiveCondition( condition=Condition( name="disarmed", modifiers=(StatModifier(target="attack", value=-4),), ), rounds_left=1, source="maneuver: sunder", ) # --- Test 1: repair restores a broken weapon --------------------------------- def test_repair_restores_broken_weapon() -> None: a_spec = make_combatant("a", attack_bonus=2) b_spec = make_combatant("b") a = make_state(a_spec, "players", (1, 1)) b = make_state(b_spec, "monsters", (1, 2)) b.weapon_damage = {"b-w": 10} b.weapon_broken = {"b-w"} b.active_conditions.append(_sunder_disarmed_condition()) engine = make_engine([], [a, b]) engine._execute(b, Action(kind="repair_weapon", weapon_id="b-w")) assert not b.weapon_broken assert not b.weapon_damage assert "b-w" in _weapon_ids(b) assert not any( c.condition.name == "disarmed" and c.source == "maneuver: sunder" for c in b.active_conditions ) assert "repair b-w (restored)" in engine._transcript[-1] # --- Test 2: weapon_id=None -> nothing to repair, state unchanged ------------ def test_repair_none_logs_nothing_to_repair() -> None: a_spec = make_combatant("a", attack_bonus=2) b_spec = make_combatant("b") a = make_state(a_spec, "players", (1, 1)) b = make_state(b_spec, "monsters", (1, 2)) b.weapon_damage = {"b-w": 10} b.weapon_broken = {"b-w"} engine = make_engine([], [a, b]) engine._execute(b, Action(kind="repair_weapon")) assert "nothing to repair" in engine._transcript[-1] assert b.weapon_broken == {"b-w"} assert b.weapon_damage == {"b-w": 10} # --- Test 3: id never damaged -> log, state unchanged ------------------------ def test_repair_unknown_id_logs_nothing_to_repair() -> None: a_spec = make_combatant("a", attack_bonus=2) b_spec = make_combatant("b") a = make_state(a_spec, "players", (1, 1)) b = make_state(b_spec, "monsters", (1, 2)) engine = make_engine([], [a, b]) engine._execute(b, Action(kind="repair_weapon", weapon_id="b-w")) assert "nothing to repair" in engine._transcript[-1] assert not b.weapon_broken assert not b.weapon_damage # --- Test 4: real sunder then repair restores the weapon --------------------- def test_sunder_then_repair_restores_weapon() -> None: a_spec = make_combatant("a", attack_bonus=2) b_spec = make_combatant("b") a = make_state(a_spec, "players", (1, 1)) b = make_state(b_spec, "monsters", (1, 2)) engine = make_engine([12] * 5, [a, b]) for _ in range(5): engine._execute(a, Action(kind="maneuver", target_id="b", maneuver="sunder")) assert "b-w" in b.weapon_broken assert "b-w" not in _weapon_ids(b) assert any( c.condition.name == "disarmed" and c.source == "maneuver: sunder" for c in b.active_conditions ) engine._execute(b, Action(kind="repair_weapon", weapon_id="b-w")) assert not b.weapon_broken assert not b.weapon_damage assert "b-w" in _weapon_ids(b) assert not any( c.condition.name == "disarmed" and c.source == "maneuver: sunder" for c in b.active_conditions ) assert "repair b-w (restored)" in engine._transcript[-1] # --- Test 5: determinism ----------------------------------------------------- def _run_with_repair() -> tuple[str, ...]: a_spec = make_combatant("a", attack_bonus=5) b_spec = make_combatant("b") a = make_state(a_spec, "players", (1, 1)) b = make_state(b_spec, "monsters", (1, 2)) b.weapon_damage = {"b-w": 10} b.weapon_broken = {"b-w"} def policy(engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]: if state.combatant.id == "b": return (Action(kind="repair_weapon", weapon_id="b-w"),) return (Action(kind="wait"),) engine = CombatEngine(SeededRng(42), make_grid(), [a, b], policy=policy) return engine.run().transcript def test_determinism_same_seed_same_transcript() -> None: assert _run_with_repair() == _run_with_repair()