feat(template): carry the combat facts the .hdt states, so house rules reach combat

Main6E states them on the power itself -- KILLING, DOESBODY, DOESDAMAGE,
DOESKNOCKBACK, alongside the DEFENSE carried on 2026-08-24. hdt_parser read
only DEFENSE; `killing` came from KillingAttackRanged.__init__ hardcoding
True. Parsed then dropped, the same shape as `types` and AdderTemplate.options.

That made a campaign's template edits inert. kirby-cost is the only thing in
the platform that reads a .hdt, so it is the only place a house rule can enter
the model -- a GM setting KILLING="No" for a heroic campaign got a character
that still resolved killing damage, with nothing to indicate the edit was
ignored. Proved by copying Main6E with that one edit: Ravel's RKA still
reported killing=True. It now reports False, with no code changed.

The flags are TRI-STATE. None means "the template said nothing", which is not
False: a constructor may set the fact itself, and a silent template must not
undo it while an explicit "No" must. apply_template also skips any attribute
exposed as a read-only property -- Maneuver derives does_damage from its own
effect string, and an object that works the answer out from itself is not
waiting to be told.

1456 passed, 0 skipped (KIRBY_COST_AUTHORED + KIRBY_COST_HDT set).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Xof4ZUS5n6A5ibX3PXNYbs

Author: pdbethke

kirby_cost/io/hdt_parser.py

@@ -331,6 +331,10 @@ def _parse_generic_object(self, elem: etree.Element) -> Dict[str, Any]:
             'target': elem.get('TARGET', ''),
             'range': elem.get('RANGE', ''),
             'defense': elem.get('DEFENSE', ''),
+            'killing': self._parse_optional_yesno(elem, 'KILLING'),
+            'does_body': self._parse_optional_yesno(elem, 'DOESBODY'),
+            'does_damage': self._parse_optional_yesno(elem, 'DOESDAMAGE'),
+            'does_knockback': self._parse_optional_yesno(elem, 'DOESKNOCKBACK'),
 
             # Input/option labels
             'input_label': elem.get('INPUTLABEL', ''),
@@ -540,6 +544,20 @@ def _get_text(self, elem: Optional[etree.Element]) -> str:
             return ''
         return (elem.text or '').strip()
 
+    @staticmethod
+    def _parse_optional_yesno(elem, attribute: str):
+        """Yes/No attribute as a tri-state: None when the attribute is absent.
+
+        The distinction matters. `killing` is also set by some object
+        constructors, so "the template did not mention it" has to be
+        distinguishable from "the template said No" -- otherwise applying a
+        template would silently clear a class's own answer.
+        """
+        raw = elem.get(attribute)
+        if raw is None:
+            return None
+        return raw.strip().upper().startswith('Y')
+
     def _parse_float(self, value: str) -> float:
         """Parse a string to float, returning 0.0 on error."""
         if not value:

kirby_cost/objects/base.py

@@ -591,6 +591,34 @@ def apply_template(self, tmpl: "TemplateData", option_id: str = None) -> None:
             self._duration = tmpl.duration
         if tmpl.target and self.target in ("", "N/A") and "TARGET" not in stated:
             self.target = tmpl.target
+        # DEFENSE, on the same terms as TARGET: the template states it, the
+        # document rarely does, and the constructor's default is "NONE" --
+        # which reads as an answer rather than as an absence.
+        if tmpl.defense and self.defense in ("", "NONE") and "DEFENSE" not in stated:
+            self.defense = tmpl.defense
+        # Combat facts stated by the template. These are what let a GM's house
+        # rules reach the fight: kirby-cost reads the .hdt, so a campaign that
+        # edits KILLING="No" on the killing attacks, or turns knockback off,
+        # emits changed facts that kirby-combat consumes without knowing a rule
+        # was changed. The tri-state is load-bearing -- see TemplateData.killing.
+        # An HDC file that states the attribute itself still wins over both.
+        for attribute, xml_name in (
+            ("killing", "KILLING"),
+            ("does_body", "DOESBODY"),
+            ("does_damage", "DOESDAMAGE"),
+            ("does_knockback", "DOESKNOCKBACK"),
+        ):
+            stated_value = getattr(tmpl, attribute, None)
+            if stated_value is None or xml_name in stated:
+                continue
+            # A subclass may DERIVE the fact rather than store it -- Maneuver
+            # computes does_damage from its own effect string and exposes it
+            # read-only. That is an authority, not a gap: an object that works
+            # the answer out from itself is not waiting to be told. Skip it.
+            descriptor = getattr(type(self), attribute, None)
+            if isinstance(descriptor, property) and descriptor.fset is None:
+                continue
+            setattr(self, attribute, stated_value)
         # RANGE is the word that decides whether a power reaches at all, and
         # only the template states it — an HDC file never does. Without it
         # every power read as un-ranged and range_value returned 0.

kirby_cost/template/dataclasses.py

@@ -5,6 +5,7 @@
 loader converts raw dicts into these before handing them to domain objects.
 """
 from dataclasses import dataclass, field
+from typing import Optional
 
 
 @dataclass(frozen=True)
@@ -95,6 +96,24 @@ class TemplateData:
     #: at all, and it is stated only by the template.
     range: str = ""
     target: str = ""
+    #: Which defence the power is tested against -- NORMAL, MENTAL, POWER,
+    #: SPECIAL, NONE. `hdt_parser` has always read it (:333) and nothing
+    #: carried it, so every loaded power reported the constructor's "NONE"
+    #: and a consumer had to guess. kirby-combat guessed by xmlid and said so:
+    #: "without a reliable signal in kirby-cost's parse we default to PD for
+    #: HKA/HTH and ED for ranged blasts".
+    defense: str = ""
+    #: Combat facts the template states about the power itself. TRI-STATE:
+    #: ``None`` means "the template said nothing", which is NOT the same as
+    #: ``False`` -- a class such as KillingAttackRanged sets ``killing = True``
+    #: in its constructor, and a template that is silent must not undo that.
+    #: An explicit ``KILLING="No"`` in the .hdt DOES undo it, which is the
+    #: point: a GM running a heroic campaign edits the template, kirby-cost
+    #: emits the changed fact, and kirby-combat acts on it. Same for the rest.
+    killing: Optional[bool] = None
+    does_body: Optional[bool] = None
+    does_damage: Optional[bool] = None
+    does_knockback: Optional[bool] = None
     uses_end: bool = False
     is_power: bool = False
     class_name: str = ""

kirby_cost/template/hdt_provider.py

@@ -311,6 +311,11 @@ def _template_data(entry: dict[str, Any], *, is_power: bool) -> TemplateData:
         duration=entry.get("duration") or "",
         range=(_attrs(entry).get("RANGE") or ""),
         target=entry.get("target") or "",
+        defense=entry.get("defense") or "",
+        killing=entry.get("killing"),
+        does_body=entry.get("does_body"),
+        does_damage=entry.get("does_damage"),
+        does_knockback=entry.get("does_knockback"),
         uses_end=bool(entry.get("uses_end")),
         is_power=is_power,
         # The engine resolves classes through its own xmlid registry; the

tests/test_template_states_combat_facts.py

@@ -0,0 +1,70 @@
+"""A campaign's .hdt states combat facts, and the engine emits them.
+
+This is the seam that makes house rules possible. A GM who wants killing
+attacks to behave as normal damage in a heroic campaign, or who wants to turn
+knockback off, edits the template -- and every consumer downstream sees the
+changed fact without anyone editing code. kirby-cost is the only thing that
+reads the .hdt, so kirby-cost is where those facts have to enter the model.
+
+Before 2026-08-25 they did not enter it at all: `KillingAttackRanged.__init__`
+hardcoded `self.killing = True` and the template's `KILLING="Yes"` was read by
+`hdt_parser` and dropped. Editing the .hdt changed nothing.
+"""
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+import pytest
+
+from kirby_cost.io.hdt_parser import HDTParser
+from kirby_cost.template.dataclasses import TemplateData
+from kirby_cost.objects.powers.killing_attack_ranged import KillingAttackRanged
+
+
+def _parse(tag_text: str) -> dict:
+    return HDTParser()._parse_generic_object(ET.fromstring(tag_text))
+
+
+def test_the_parser_reads_killing_from_the_template():
+    entry = _parse('<RKA KILLING="Yes" DEFENSE="NORMAL"/>')
+
+    assert entry["killing"] is True
+
+
+def test_a_template_that_says_no_is_not_the_same_as_a_template_that_is_silent():
+    """The tri-state is load-bearing. `KillingAttackRanged` sets killing in
+    its own constructor, so "absent" must not read as "No" -- otherwise
+    applying any template at all would quietly disarm every killing attack."""
+    assert _parse('<RKA KILLING="No"/>')["killing"] is False
+    assert _parse('<RKA/>')["killing"] is None
+
+
+def test_a_house_rule_in_the_template_reaches_the_loaded_power():
+    """The whole point: change the .hdt, change what the engine emits."""
+    power = KillingAttackRanged()
+    assert power.killing is True, "the class's own default"
+
+    power.apply_template(TemplateData(xmlid="RKA", killing=False))
+
+    assert power.killing is False
+
+
+def test_a_silent_template_leaves_the_class_default_alone():
+    power = KillingAttackRanged()
+
+    power.apply_template(TemplateData(xmlid="RKA"))
+
+    assert power.killing is True
+
+
+@pytest.mark.parametrize("attribute", ["does_body", "does_knockback"])
+def test_the_other_combat_facts_travel_the_same_road(attribute):
+    """Not just killing -- knockback and BODY are stated by the template too,
+    and a campaign that turns one off should not need a code change either."""
+    power = KillingAttackRanged()
+
+    power.apply_template(TemplateData(xmlid="RKA", **{attribute: True}))
+    assert getattr(power, attribute) is True
+
+    power.apply_template(TemplateData(xmlid="RKA", **{attribute: False}))
+    assert getattr(power, attribute) is False