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

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

@@ -7,6 +7,17 @@ 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
+- **End-to-end decay-loop coverage for INV-012 / INV-013 / INV-014** (`tests/integration/test_decay_loop_inv012.py`): three new integration tests pin the registry/carrier/carry-counter contracts as they cross the `obj_update` → `_extract_obj` boundary. (1) A carried potion whose timer expires must be removed from `object_registry` (INV-014), removed from the carrier's inventory, and the `carry_weight` / `carry_number` counters must drop (INV-011). (2) ROM `src/handler.c:2063-2067 extract_obj` recurses through container contents — verified with an NPC corpse containing a pouch containing a ruby; all three leave the registry on the corpse's decay tick. (3) Downstream INV-014 consequence — a decayed obj is no longer findable via `locate object` (it walked the registry). Fills coverage gaps the pre-existing `test_obj_update_decays_corpse` and `test_obj_update_spills_floating_container` did not exercise.
+
 ## [2.9.5]
 
 ### Fixed

{rom24_quickmud_python-2.9.5/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.5
+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.5 → 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.5 → 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.5 → 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.5"
+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.5 → 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.5
+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.5 → rom24_quickmud_python-2.9.7}/rom24_quickmud_python.egg-info/SOURCES.txt

@@ -661,6 +661,7 @@ tests/integration/test_dam_message_pers.py
 tests/integration/test_db2_loader_parity.py
 tests/integration/test_db_canonical_round_trip.py
 tests/integration/test_death_and_corpses.py
+tests/integration/test_decay_loop_inv012.py
 tests/integration/test_do_affects.py
 tests/integration/test_do_consider_command.py
 tests/integration/test_do_equipment.py
@@ -706,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_decay_loop_inv012.py

@@ -0,0 +1,198 @@
+"""End-to-end decay loop coverage — INV-012 / INV-013 / INV-014.
+
+ROM ``src/update.c:obj_update`` walks ``object_list``, decrements
+timers, and on expiry calls ``src/handler.c:extract_obj`` which
+recursively extracts contents and removes the obj from
+``object_list``. Three contracts intersect here:
+
+- INV-014: every live obj is on ``object_registry``; extract removes.
+- INV-013: extracting a carried obj must release the carrier field.
+- INV-011: extracting a carried obj must update ``carry_weight`` and
+  ``carry_number``.
+
+The pre-existing ``test_obj_update_decays_corpse`` and
+``test_obj_update_spills_floating_container`` cover the room-carried
+and floating-container cases. These tests fill the remaining
+end-to-end gaps for the INV-012 newly-live registry: carried-obj
+decay and recursive nested-container decay.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mud.game_loop import obj_update
+from mud.models.character import Character, character_registry
+from mud.models.constants import LEVEL_IMMORTAL, ItemType
+from mud.models.obj import ObjIndex, object_registry
+from mud.models.object import create_object
+from mud.models.room import Room
+from mud.registry import room_registry
+from mud.skills.handlers import locate_object
+
+
+_ROOM_VNUM = 9601
+
+
+@pytest.fixture
+def decay_room() -> Room:
+    room = room_registry.get(_ROOM_VNUM)
+    if room is None:
+        room = Room(vnum=_ROOM_VNUM, name="Decay Test Room")
+        room_registry[_ROOM_VNUM] = room
+    room.contents.clear()
+    room.people.clear()
+    return room
+
+
+def test_decay_of_carried_obj_updates_carry_counters_and_registry(
+    decay_room: Room,
+) -> None:
+    """A potion in a character's inventory whose timer expires must:
+    extract from ``object_registry`` (INV-014), clear the carrier
+    field (INV-013), and decrement ``carry_weight`` / ``carry_number``
+    (INV-011). End-to-end check across all three invariants.
+    """
+
+    carrier = Character(name="Drinker", is_npc=False)
+    carrier.level = 30
+    decay_room.add_character(carrier)
+    character_registry.append(carrier)
+
+    proto = ObjIndex(
+        vnum=9602,
+        name="potion",
+        short_descr="a potion of healing",
+        item_type=int(ItemType.POTION),
+        weight=2,
+        value=[0, 0, 0, 0, 0],
+    )
+    potion = create_object(proto)
+    potion.timer = 1
+    potion.item_type = int(ItemType.POTION)
+    carrier.add_object(potion)
+
+    assert potion in object_registry
+    assert potion.carried_by is carrier
+    initial_weight = carrier.carry_weight
+    initial_number = carrier.carry_number
+    assert initial_weight >= 2  # potion weight contributed
+    assert initial_number >= 1
+
+    obj_update()
+
+    assert potion not in object_registry, (
+        "INV-014: decayed obj must be removed from object_registry by "
+        "_extract_obj (mud/game_loop.py)."
+    )
+    assert potion not in carrier.inventory
+    assert carrier.carry_weight < initial_weight, (
+        "INV-011: decay of carried obj must decrement carry_weight."
+    )
+    assert carrier.carry_number < initial_number, (
+        "INV-011: decay of carried obj must decrement carry_number."
+    )
+
+
+def test_npc_corpse_decay_recursively_extracts_contents(
+    decay_room: Room,
+) -> None:
+    """ROM ``extract_obj`` recurses through container contents
+    (``src/handler.c:2063-2067``). NPC corpses are NOT in the spill
+    branch of ``obj_update`` — when the corpse timer expires, every
+    item inside is destroyed with it. INV-014: all three objects
+    must leave ``object_registry``.
+
+    Contrast with float-container decay, where contents spill to the
+    room and survive (covered by
+    ``tests/test_game_loop.py::test_obj_update_spills_floating_container``).
+    """
+
+    corpse_proto = ObjIndex(
+        vnum=9610,
+        name="orc corpse",
+        short_descr="the corpse of an orc",
+        item_type=int(ItemType.CORPSE_NPC),
+    )
+    corpse = create_object(corpse_proto)
+    corpse.item_type = int(ItemType.CORPSE_NPC)
+    corpse.timer = 1
+
+    pouch_proto = ObjIndex(
+        vnum=9611,
+        name="pouch",
+        short_descr="a leather pouch",
+        item_type=int(ItemType.CONTAINER),
+    )
+    pouch = create_object(pouch_proto)
+    pouch.item_type = int(ItemType.CONTAINER)
+
+    gem_proto = ObjIndex(
+        vnum=9612,
+        name="ruby",
+        short_descr="a ruby",
+        item_type=int(ItemType.GEM),
+    )
+    gem = create_object(gem_proto)
+    gem.item_type = int(ItemType.GEM)
+
+    pouch.contained_items.append(gem)
+    gem.in_obj = pouch
+    corpse.contained_items.append(pouch)
+    pouch.in_obj = corpse
+    decay_room.add_object(corpse)
+
+    assert all(o in object_registry for o in (corpse, pouch, gem))
+
+    obj_update()
+
+    assert corpse not in object_registry, (
+        "INV-014: decayed corpse must be removed from registry."
+    )
+    assert pouch not in object_registry, (
+        "ROM extract_obj recurses through contents; INV-014 contract "
+        "requires the pouch nested inside the corpse to leave the "
+        "registry too."
+    )
+    assert gem not in object_registry, (
+        "Deeply nested items (gem in pouch in corpse) must also be "
+        "extracted by the recursion."
+    )
+
+
+def test_decayed_obj_invisible_to_locate(decay_room: Room) -> None:
+    """Downstream INV-014 consequence: after decay, ``locate object``
+    can no longer find the obj (it walks ``object_registry``).
+    """
+
+    seer = Character(
+        name="Seer",
+        level=LEVEL_IMMORTAL,
+        trust=LEVEL_IMMORTAL,
+        is_npc=False,
+    )
+    character_registry.append(seer)
+
+    proto = ObjIndex(
+        vnum=9620,
+        name="ephemeral wisp",
+        short_descr="an ephemeral wisp",
+        item_type=int(ItemType.FOOD),
+    )
+    wisp = create_object(proto)
+    wisp.item_type = int(ItemType.FOOD)
+    wisp.timer = 1
+    decay_room.add_object(wisp)
+
+    # Pre-decay: locate finds it.
+    seer.messages.clear()
+    assert locate_object(seer, "wisp") is True
+
+    obj_update()
+
+    # Post-decay: locate misses it.
+    seer.messages.clear()
+    assert locate_object(seer, "wisp") is False
+    assert seer.messages[-1] == "Nothing like that in heaven or earth."
+
+    character_registry.remove(seer)

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"
+    )