From fdcd103e8a974895b4c905d2a12f9ef123087ccf Mon Sep 17 00:00:00 2001 From: ctan Date: Sun, 6 Sep 2026 10:05:55 +0200 Subject: [PATCH] feat(combat): add repair_weapon action to fix broken weapons --- src/pf1e_simulator/combat.py | 35 ++++++- tests/test_repair_weapon.py | 187 +++++++++++++++++++++++++++++++++++ 2 files changed, 221 insertions(+), 1 deletion(-) create mode 100644 tests/test_repair_weapon.py diff --git a/src/pf1e_simulator/combat.py b/src/pf1e_simulator/combat.py index 8b3a15f..09cbe75 100644 --- a/src/pf1e_simulator/combat.py +++ b/src/pf1e_simulator/combat.py @@ -358,7 +358,7 @@ class Action: "attack", "move", "wait", "swift", "free", "immediate", "full_round", "full_attack", "charge", "withdraw", "5foot_step", "cast_spell", "maneuver", "channel_energy", "hex", "deed", "spell_combat", - "inspire_courage", "retrieve_weapon", + "inspire_courage", "retrieve_weapon", "repair_weapon", ] target_id: str | None = None spell_name: str | None = None @@ -1478,6 +1478,8 @@ class CombatEngine: ) elif kind == "retrieve_weapon": self._retrieve_weapon(state, action.weapon_id) + elif kind == "repair_weapon": + self._repair_weapon(state, action.weapon_id) elif kind in ("channel_energy", "hex", "deed", "spell_combat", "inspire_courage"): self._execute_class_ability(state, target, action) elif kind == "charge": @@ -1648,6 +1650,37 @@ class CombatEngine: f"retrieve {weapon_id} (restored)" ) + def _repair_weapon(self, state: CombatantState, weapon_id: str | None) -> None: + """Repair a broken weapon: remove it from ``weapon_broken`` and reset damage. + + No-op (with a log line) when ``weapon_id`` is None or the weapon was never + damaged. Also removes the transient ``disarmed`` condition originating + from the sunder that broke the weapon, so the repaired weapon is fully + usable again. + """ + if weapon_id is None: + self._log( + f"round {self._current_round} {state.combatant.id}: " + f"repair: nothing to repair" + ) + return + if weapon_id not in state.weapon_damage: + self._log( + f"round {self._current_round} {state.combatant.id}: " + f"repair {weapon_id}: nothing to repair" + ) + return + state.weapon_damage.pop(weapon_id, None) + state.weapon_broken.discard(weapon_id) + state.active_conditions = [ + c for c in state.active_conditions + if not (c.condition.name == "disarmed" and c.source == "maneuver: sunder") + ] + self._log( + f"round {self._current_round} {state.combatant.id}: " + f"repair {weapon_id} (restored)" + ) + def _maneuver_cmb(self, state: CombatantState) -> int: return ( state.combatant.cmb diff --git a/tests/test_repair_weapon.py b/tests/test_repair_weapon.py new file mode 100644 index 0000000..46c632d --- /dev/null +++ b/tests/test_repair_weapon.py @@ -0,0 +1,187 @@ +"""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()