rom24-quickmud-python 2.9.6__tar.gz → 2.9.7__tar.gz

{rom24_quickmud_python-2.9.6 → rom24_quickmud_python-2.9.7}/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.7]
+
+### Fixed
+- **INV-015 AFFECT-TICK-LIFECYCLE — expired ROM-canonical affects leaked stat modifiers and bitvectors** (`mud/affects/engine.py:tick_spell_effects`, `mud/handler.py:affect_remove`): ROM `src/update.c:762-786 affect_update` calls `src/handler.c:1317 affect_remove` on expiry, which `affect_modify(FALSE)` (subtracts the stat mod, clears the bitvector) → unlinks from `ch->affected` → calls `affect_check` (re-sets the bit only if another affect still provides it). The Python tick path was a bare `affected.remove(affect)` — no stat unwind, no bitvector clear. Symptom for any `AffectData` whose `type` is the ROM-canonical integer spell SN (the `isinstance(spell_name, str)` guard at engine.py:32 skipped the `spell_effects` cleanup branch for these): permanent stat boosts and phantom `affected_by` bits after every expiry. Fix: new module-level `mud/handler.py:affect_remove(ch, paf)` mirrors `src/handler.c:1317` exactly. `tick_spell_effects` routes raw ROM-canonical entries through it. **Spell-effects-managed entries (the `apply_spell_effect` shadow-mirror path used by frenzy/bless/weaken/etc.) keep bare list removal** — `remove_spell_effect` already handles their stat unwind; double-routing would double-unwind (caught by `tests/integration/test_spell_affects_persistence.py` + `tests/test_affects.py` regressions during implementation, hence the split).
+- INV-015 row added to `docs/parity/CROSS_FILE_INVARIANTS_TRACKER.md`, ✅ ENFORCED. Two enforcement tests in `tests/integration/test_inv015_affect_tick_lifecycle.py` — stat-modifier unwind, and bitvector preservation when a second affect provides the same bit (mirrors ROM `affect_check`).
+
 ## [2.9.6]
 
 ### Added

{rom24_quickmud_python-2.9.6/rom24_quickmud_python.egg-info → rom24_quickmud_python-2.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.6
+Version: 2.9.7
 Summary: A modern Python port of the ROM 2.4b6 MUD engine with full telnet server and JSON world loading
 Author-email: Mark Jedrzejczyk <mark.jedrzejczyk@gmail.com>
 Maintainer-email: Mark Jedrzejczyk <mark.jedrzejczyk@gmail.com>

{rom24_quickmud_python-2.9.6 → rom24_quickmud_python-2.9.7}/mud/affects/engine.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from mud.handler import affect_remove
 from mud.models.character import Character
 from mud.utils import rng_mm
 
@@ -43,8 +44,28 @@ def tick_spell_effects(character: Character) -> list[str]:
                 or int(getattr(next_affect, "duration", 0) or 0) > 0
             )
 
+            # ROM src/handler.c:1317 affect_remove — affect_modify(FALSE)
+            # subtracts the stat mod and clears the bitvector; affect_check
+            # re-sets the bit only if another affect still provides it.
+            # INV-015 fix (2.9.7): was a bare `affected.remove(affect)`,
+            # which leaked stat mods and bitvectors for any AffectData
+            # whose `type` is an integer SN (the ROM-canonical form).
+            #
+            # Python has a parallel apply path: `Character.apply_spell_effect`
+            # already calls `_apply_stat_modifier(+mod)`, mirrors a shadow
+            # AffectData into `ch.affected`, and on expiry the
+            # `remove_spell_effect` branch below unwinds via
+            # `_apply_stat_modifier(-mod)`. For those entries the shadow
+            # AffectData's modifier was NEVER applied via `affect_modify(True)`,
+            # so calling `affect_modify(False)` on it would double-unwind.
+            # Split: spell_effects-managed entries get bare list removal;
+            # raw ROM-canonical AffectData routes through affect_remove.
+            spell_effects_managed = isinstance(spell_name, str) and spell_name in effects
             if affect in affected:
-                affected.remove(affect)
+                if spell_effects_managed:
+                    affected.remove(affect)
+                else:
+                    affect_remove(character, affect)
 
             if isinstance(spell_name, str) and spell_name in effects:
                 touched_names.add(spell_name)

{rom24_quickmud_python-2.9.6 → rom24_quickmud_python-2.9.7}/mud/handler.py

@@ -442,6 +442,36 @@ def affect_check(ch: Character, where: int, vector: int) -> None:
                             return
 
 
+def affect_remove(ch: Character, paf: Affect) -> None:
+    """Remove an affect from a character — ROM ``src/handler.c:1317``.
+
+    Mirrors ROM exactly: ``affect_modify(ch, paf, FALSE)`` (subtracts
+    the stat modifier and clears the bitvector in
+    ``affected_by``/``imm_flags``/``res_flags``/``vuln_flags``),
+    unlinks ``paf`` from ``ch.affected``, then calls
+    ``affect_check(ch, where, vector)`` which re-sets the bitvector
+    only if another affect on the char or equipped objects still
+    provides it. INV-015 enforcement point for the affect-tick
+    lifecycle contract.
+    """
+
+    affected = getattr(ch, "affected", None)
+    if not isinstance(affected, list) or not affected:
+        return
+
+    where = getattr(paf, "where", 0)
+    vector = getattr(paf, "bitvector", 0)
+
+    affect_modify(ch, paf, False)
+
+    try:
+        affected.remove(paf)
+    except ValueError:
+        pass
+
+    affect_check(ch, where, vector)
+
+
 def affect_to_obj(obj: Object, paf: Affect) -> None:
     """
     Add an affect to an object.

{rom24_quickmud_python-2.9.6 → rom24_quickmud_python-2.9.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rom24-quickmud-python"
-version = "2.9.6"
+version = "2.9.7"
 description = "A modern Python port of the ROM 2.4b6 MUD engine with full telnet server and JSON world loading"
 readme = "README.md"
 license = "MIT"

{rom24_quickmud_python-2.9.6 → rom24_quickmud_python-2.9.7/rom24_quickmud_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.6
+Version: 2.9.7
 Summary: A modern Python port of the ROM 2.4b6 MUD engine with full telnet server and JSON world loading
 Author-email: Mark Jedrzejczyk <mark.jedrzejczyk@gmail.com>
 Maintainer-email: Mark Jedrzejczyk <mark.jedrzejczyk@gmail.com>

{rom24_quickmud_python-2.9.6 → rom24_quickmud_python-2.9.7}/rom24_quickmud_python.egg-info/SOURCES.txt

@@ -707,6 +707,7 @@ tests/integration/test_inv012_object_list_canonical.py
 tests/integration/test_inv013_add_object_carrier.py
 tests/integration/test_inv013_object_location_coherence.py
 tests/integration/test_inv014_object_registry_membership.py
+tests/integration/test_inv015_affect_tick_lifecycle.py
 tests/integration/test_invisibility_combat.py
 tests/integration/test_json_loader_parity.py
 tests/integration/test_lookup_parity.py

rom24_quickmud_python-2.9.7/tests/integration/test_inv015_affect_tick_lifecycle.py

@@ -0,0 +1,143 @@
+"""INV-015 AFFECT-TICK-LIFECYCLE enforcement.
+
+ROM ``src/update.c:762-786 affect_update`` decrements each
+``ch->affected`` entry's duration; on expiry it calls
+``src/handler.c:1317 affect_remove``, which in turn:
+
+1. calls ``affect_modify(ch, paf, FALSE)`` — subtracts the stat
+   modifier (``mod_stat[STR] -= mod``) AND clears the bitvector in
+   ``ch->affected_by`` (handler.c:1110-1117);
+2. unlinks the affect from ``ch->affected``;
+3. calls ``affect_check(ch, where, vector)``, which re-sets the
+   bitvector ONLY if another affect (on ``ch`` or on equipped
+   objects) still provides it.
+
+The Python tick path at ``mud/affects/engine.py:tick_spell_effects``
+historically just did ``affected.remove(affect)`` on expiry. When the
+``AffectData`` carried an integer ``type`` (the ROM-canonical form,
+since ``type`` is a spell SN per ``src/merc.h:648-659``), the parallel
+``spell_effects`` cleanup at engine.py:55-68 never fired, because the
+``isinstance(spell_name, str)`` guard skipped non-string types. Net:
+the bitvector leaked into ``affected_by`` permanently, and any stat
+modifier applied via ``affect_modify(TRUE)`` was never undone.
+
+This test pins the contract: after enough ticks to expire an Affect
+that was applied via the canonical ``affect_modify`` + list append
+sequence, the stat mod must be undone and the bitvector must be
+clear. Add a test here when introducing a new path that decrements
+``AffectData.duration`` to zero.
+"""
+
+from __future__ import annotations
+
+from mud.affects.engine import tick_spell_effects
+from mud.handler import affect_modify
+from mud.models.character import AffectData, Character
+from mud.models.constants import AffectFlag, Stat
+
+
+APPLY_STR = 1
+TO_AFFECTS = 0
+
+
+def _build_char() -> Character:
+    ch = Character(name="affect-tick-pc", is_npc=False)
+    ch._ensure_mod_stat_capacity()
+    return ch
+
+
+def test_affect_with_stat_mod_undoes_on_tick_expiry() -> None:
+    """A +2 STR / AFF_HASTE affect with duration=1 must fully unwind
+    after two ticks: the +2 must be subtracted from mod_stat[STR] and
+    the HASTE bit must be cleared from affected_by."""
+
+    ch = _build_char()
+    baseline_str = ch.mod_stat[int(Stat.STR)]
+    baseline_affected_by = ch.affected_by
+
+    affect = AffectData(
+        type=1,  # ROM spell SN — integer, NOT a string spell name
+        level=10,
+        duration=1,
+        location=APPLY_STR,
+        modifier=2,
+        bitvector=int(AffectFlag.HASTE),
+        where=TO_AFFECTS,
+    )
+
+    # Canonical apply: affect_modify(True) updates mod_stat AND
+    # affected_by, then append to ch.affected (ROM affect_to_char).
+    affect_modify(ch, affect, True)  # type: ignore[arg-type]  # duck-typed: AffectData vs Affect
+    ch.affected.append(affect)
+
+    assert ch.mod_stat[int(Stat.STR)] == baseline_str + 2
+    assert ch.affected_by & int(AffectFlag.HASTE)
+    assert affect in ch.affected
+
+    # Tick 1: duration 1 -> 0, affect stays in list.
+    tick_spell_effects(ch)
+    assert affect in ch.affected
+    assert affect.duration == 0
+
+    # Tick 2: duration == 0, ROM removes via affect_remove.
+    tick_spell_effects(ch)
+
+    # ROM contract — all three must hold:
+    assert affect not in ch.affected, "expired affect must be unlinked"
+    assert ch.affected_by & int(AffectFlag.HASTE) == 0, (
+        "expired affect's bitvector must clear from affected_by "
+        "(src/handler.c:1317 affect_remove -> affect_modify(FALSE))"
+    )
+    assert ch.mod_stat[int(Stat.STR)] == baseline_str, (
+        "expired affect's stat modifier must be subtracted "
+        "(src/handler.c:1317 affect_remove -> affect_modify(FALSE))"
+    )
+    assert ch.affected_by == baseline_affected_by
+
+
+def test_affect_check_preserves_bit_if_another_affect_provides_it() -> None:
+    """When two affects share a bitvector and only one expires, the
+    bit must remain set — ROM ``affect_check`` (src/handler.c:1182)
+    re-sets it after ``affect_modify(FALSE)`` clears it."""
+
+    ch = _build_char()
+
+    short = AffectData(
+        type=1,
+        level=10,
+        duration=1,
+        location=APPLY_STR,
+        modifier=2,
+        bitvector=int(AffectFlag.HASTE),
+        where=TO_AFFECTS,
+    )
+    long = AffectData(
+        type=2,
+        level=10,
+        duration=10,
+        location=APPLY_STR,
+        modifier=3,
+        bitvector=int(AffectFlag.HASTE),
+        where=TO_AFFECTS,
+    )
+
+    affect_modify(ch, short, True)  # type: ignore[arg-type]
+    ch.affected.append(short)
+    affect_modify(ch, long, True)  # type: ignore[arg-type]
+    ch.affected.append(long)
+
+    baseline_str_with_long_only = ch.mod_stat[int(Stat.STR)] - 2  # subtract short's +2
+
+    # Tick short to expiry.
+    tick_spell_effects(ch)
+    tick_spell_effects(ch)
+
+    assert short not in ch.affected
+    assert long in ch.affected
+    assert ch.affected_by & int(AffectFlag.HASTE), (
+        "HASTE bit must survive — `long` still provides it "
+        "(src/handler.c:1182 affect_check re-sets after clear)"
+    )
+    assert ch.mod_stat[int(Stat.STR)] == baseline_str_with_long_only, (
+        "only short's +2 must unwind; long's +3 must remain"
+    )