rom24-quickmud-python 2.9.11__tar.gz → 2.9.13__tar.gz

{rom24_quickmud_python-2.9.11 → rom24_quickmud_python-2.9.13}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.13]
+
+### Added
+- **INV-017 TICK-ITERATION-SAFETY** filed as ✅ ENFORCED in `docs/parity/CROSS_FILE_INVARIANTS_TRACKER.md`. ROM `src/update.c:char_update` (lines 661-872) pre-caches `ch_next = ch->next` (line 680) so the outer loop survives any lethal damage applied inside the per-char tick — plague/poison/incap/mortal branches all call `damage(ch, ch, ...)` which routes to `raw_kill` and frees `ch`. The explicit comment at lines 788-792 ("MUST NOT refer to ch after damage taken, as it may be lethal damage (on NPC)") plus the post-loop `IS_VALID(ch)` guard at line 884 form the load-bearing contract. Python's `mud/game_loop.py:char_update` already enforces this by iterating `for character in list(character_registry):` (line 690) — the `list(...)` snapshot decouples iteration from `character_registry.remove()` calls made by `mud/combat/death.py:raw_kill`. Regression test pins it: a poisoned NPC at 1 hp dies during its poison tick; the subsequent NPC in the snapshot must still receive its tick (proves the loop did not break or skip after the registry mutation). `tests/integration/test_char_update_lethal_tick_iteration.py::test_lethal_poison_tick_does_not_skip_subsequent_npc`. Tracker now at 17 of ~20 budget.
+
+## [2.9.12]
+
+### Fixed
+- **`die_follower` left dangling leader pointers + skipped self-cleanup** (`mud/characters/follow.py:die_follower`): ROM `src/act_comm.c:1658-1680` does three things on a character's death — (1) detaches the dying ch from its own master (releasing `master->pet` if it pointed at ch), (2) clears `ch->leader`, (3) walks `char_list` and for every `fch` whose `master == ch` stops the follow AND for every `fch` whose `leader == ch` resets `fch->leader = fch` (becomes its own group leader, NOT NULL). The Python port previously only did step 3's first half (`master == ch` → `stop_follower`). Symptom: after a group leader died, `is_same_group` (`src/handler.c:2018-2027`, walks `leader` pointers) still equated two unrelated survivors because both still pointed at the extracted corpse — breaking group XP routing, autoassist target filtering, and `do_group` membership checks. Also, a dying ch retained its own master/leader pointers, leaving the corpse "still in" a group from the surviving leader's perspective. Fix mirrors ROM exactly. Two enforcement tests in `tests/integration/test_die_follower_leader_chain.py`: (1) leader dies → ex-members become own leaders and are no longer `is_same_group` with each other; (2) follower dies → `ch.master`, `ch.leader`, and `master.pet` all cleared.
+
 ## [2.9.11]
 
 ### Fixed

{rom24_quickmud_python-2.9.11/rom24_quickmud_python.egg-info → rom24_quickmud_python-2.9.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.11
+Version: 2.9.13
 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.11 → rom24_quickmud_python-2.9.13}/mud/characters/follow.py

@@ -68,17 +68,34 @@ def stop_follower(follower: "Character") -> None:
 
 
 def die_follower(char: "Character") -> None:
-    """Stop all followers when character dies.
-
-    ROM Reference: src/handler.c die_follower
-    Mirrors ROM behavior: when character dies, all their followers stop following.
+    """Detach a dying character from its group and followers.
+
+    Mirrors ROM ``src/act_comm.c:1658-1680``:
+
+    1. If ``ch`` is following someone, detach ``ch`` from its master
+       (releasing ``master->pet`` if it pointed at ``ch``).
+    2. Clear ``ch->leader``.
+    3. For every other character, if it follows ``ch`` (``master == ch``)
+       stop the follow; if it groups under ``ch`` (``leader == ch``), reset
+       its leader to itself so it becomes its own independent group leader
+       — NOT NULL, otherwise ``is_same_group`` would still equate two
+       former members via their dangling pointer at the extracted corpse.
     """
     from mud.models.character import character_registry
 
-    for follower in list(character_registry):
-        master = getattr(follower, "master", None)
-        if master is char:
-            stop_follower(follower)
+    if getattr(char, "master", None) is not None:
+        master = char.master
+        if getattr(master, "pet", None) is char:
+            master.pet = None
+        stop_follower(char)
+
+    char.leader = None
+
+    for fch in list(character_registry):
+        if getattr(fch, "master", None) is char:
+            stop_follower(fch)
+        if getattr(fch, "leader", None) is char:
+            fch.leader = fch
 
 
 __all__ = ["add_follower", "stop_follower", "die_follower"]

{rom24_quickmud_python-2.9.11 → rom24_quickmud_python-2.9.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rom24-quickmud-python"
-version = "2.9.11"
+version = "2.9.13"
 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.11 → rom24_quickmud_python-2.9.13/rom24_quickmud_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.11
+Version: 2.9.13
 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.11 → rom24_quickmud_python-2.9.13}/rom24_quickmud_python.egg-info/SOURCES.txt

@@ -647,6 +647,7 @@ tests/integration/test_bit_flag_value.py
 tests/integration/test_bit_is_stat.py
 tests/integration/test_boards_rom_parity.py
 tests/integration/test_channels.py
+tests/integration/test_char_update_lethal_tick_iteration.py
 tests/integration/test_character_advancement.py
 tests/integration/test_character_commands.py
 tests/integration/test_character_creation_runtime.py
@@ -662,6 +663,7 @@ 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_die_follower_leader_chain.py
 tests/integration/test_do_affects.py
 tests/integration/test_do_consider_command.py
 tests/integration/test_do_equipment.py

rom24_quickmud_python-2.9.13/tests/integration/test_char_update_lethal_tick_iteration.py

@@ -0,0 +1,106 @@
+"""char_update must survive lethal damage applied inside the per-char tick.
+
+ROM ``src/update.c:char_update`` pre-caches ``ch_next = ch->next`` at the top
+of the loop body, then calls ``damage(ch, ch, ...)`` for plague/poison/incap/
+mortal ticks.  Those damage calls may extract ``ch`` (raw_kill) when the NPC's
+hp drops to ROM's death threshold.  The pre-cache plus the explicit comment
+``MUST NOT refer to ch after damage taken`` (lines 788-792) means the outer
+loop is safe — it never dereferences a freed ``ch_next`` and continues to
+tick every subsequent character.
+
+Python's equivalent in ``mud/game_loop.py:char_update`` snapshots
+``list(character_registry)`` once and iterates the copy, which gives it the
+same guarantee against registry mutation mid-loop.  This test pins that
+contract: a poisoned NPC at 1 hp dies during its poison tick; the second NPC
+in the same registry slot (later in the snapshot) must still receive its
+tick.  If a future refactor switches to live iteration of
+``character_registry`` (which a ``for ch in character_registry`` over a list
+that ``raw_kill`` mutates would silently skip the next element on), this
+test fails.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mud.models.character import AffectData, Character, character_registry
+from mud.models.constants import AffectFlag, Position
+from mud.models.room import Room
+from mud.registry import room_registry
+
+
+@pytest.fixture(autouse=True)
+def _cleanup():
+    snapshot = list(character_registry)
+    character_registry.clear()
+    yield
+    character_registry.clear()
+    character_registry.extend(snapshot)
+    for vnum in (9100,):
+        room_registry.pop(vnum, None)
+
+
+def _make_room() -> Room:
+    room = Room(vnum=9100, name="Tick Test", description="", room_flags=0, sector_type=0)
+    room.people = []
+    room.contents = []
+    room_registry[9100] = room
+    return room
+
+
+def _make_npc(room: Room, name: str, *, hp: int = 50, poisoned: bool = False) -> Character:
+    mob = Character(
+        name=name,
+        short_descr=name,
+        level=5,
+        room=room,
+        is_npc=True,
+        hit=hp,
+        max_hit=50,
+        mana=50,
+        max_mana=50,
+        move=50,
+        max_move=50,
+        position=int(Position.STANDING),
+    )
+    if poisoned:
+        mob.affected_by = int(AffectFlag.POISON)
+        mob.affected = [
+            AffectData(
+                type="poison",
+                level=20,
+                duration=10,
+                location=0,
+                modifier=0,
+                bitvector=int(AffectFlag.POISON),
+            )
+        ]
+    room.people.append(mob)
+    character_registry.append(mob)
+    return mob
+
+
+def test_lethal_poison_tick_does_not_skip_subsequent_npc():
+    from mud.game_loop import char_update
+
+    room = _make_room()
+    dying = _make_npc(room, "Dying", hp=1, poisoned=True)
+    survivor = _make_npc(room, "Survivor", hp=10, poisoned=False)
+
+    # Survivor starts with move under cap so the regen path is observable
+    # after the snapshot iteration reaches them.
+    survivor.move = 0
+    original_position = int(survivor.position)
+
+    char_update()
+
+    # 1. Dying NPC was extracted by the poison tick's raw_kill path.
+    assert dying not in character_registry, "lethal poison tick must extract the NPC"
+
+    # 2. Survivor still in registry and got a tick (regen ran — move went up).
+    assert survivor in character_registry, "survivor must still be in registry"
+    assert survivor.move > 0, "survivor must have received a regen tick (proves loop continued)"
+
+    # 3. Iteration did not skip the survivor — its position is still STANDING
+    #    (no exception left it in a partial state).
+    assert int(survivor.position) == original_position

rom24_quickmud_python-2.9.13/tests/integration/test_die_follower_leader_chain.py

@@ -0,0 +1,74 @@
+"""die_follower must reset the leader chain — ROM src/act_comm.c:1658-1680.
+
+When a character dies, ROM walks ``char_list`` and for every ``fch`` whose
+``leader == ch`` (the deceased), sets ``fch->leader = fch`` so the former
+group members become their own independent group leaders.  Python had been
+leaving those leader pointers dangling at the dead character, which breaks
+``is_same_group`` (src/handler.c:2018) — it compares ``leader`` pointers, so
+two unrelated survivors would still test as "same group" because both still
+pointed at the same extracted corpse.
+
+ROM ``die_follower`` also detaches ``ch`` from its own master (releasing the
+master's pet pointer) and clears ``ch->leader``.  Python's variant only
+handled "stop everyone following ch" and missed both self-cleanup steps.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mud.characters.follow import add_follower, die_follower
+from mud.commands.group_commands import is_same_group
+from mud.models.character import Character, character_registry
+
+
+@pytest.fixture(autouse=True)
+def _isolated_registry():
+    snapshot = list(character_registry)
+    character_registry.clear()
+    yield
+    character_registry.clear()
+    character_registry.extend(snapshot)
+
+
+def _make_char(name: str) -> Character:
+    ch = Character(name=name)
+    ch.is_npc = False
+    ch.messages = []
+    character_registry.append(ch)
+    return ch
+
+
+def test_die_follower_resets_leader_to_self_for_each_ex_member():
+    leader = _make_char("Leader")
+    member_a = _make_char("MemberA")
+    member_b = _make_char("MemberB")
+
+    member_a.leader = leader
+    member_b.leader = leader
+    leader.leader = leader
+
+    assert is_same_group(member_a, member_b)
+
+    die_follower(leader)
+
+    assert member_a.leader is member_a, "ex-member must become own leader"
+    assert member_b.leader is member_b, "ex-member must become own leader"
+    assert not is_same_group(member_a, member_b), (
+        "ex-members of a dead leader's group are no longer in the same group"
+    )
+
+
+def test_die_follower_detaches_ch_from_its_own_master():
+    master = _make_char("Master")
+    ch = _make_char("Ch")
+
+    add_follower(ch, master)
+    master.pet = ch
+    assert ch.master is master
+
+    die_follower(ch)
+
+    assert ch.master is None, "die_follower must clear ch.master"
+    assert ch.leader is None, "die_follower must clear ch.leader"
+    assert master.pet is None, "die_follower must clear master.pet if it was ch"