feat(combat): add repair_weapon action to fix broken weapons

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

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