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

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

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.15]
+
+### Fixed
+- **`group_gain` over-counted level-1 NPC contributions to `total_levels`** (`mud/groups/xp.py:104-105`): ROM `src/fight.c:1751` accumulates `group_levels += IS_NPC(gch) ? gch->level / 2 : gch->level;` — raw C integer division, so a level-1 NPC group member (e.g. a charmed pet) contributes 0, not 1. Python had `total_levels += max(1, level // 2)`, flooring NPC contributions at 1. Symptom: a level-10 PC grouped with a level-1 charmed pet killed a victim and received ~10% less XP than ROM would award, because the share-formula denominator (`max(1, total_levels - 1)`, `mud/groups/xp.py:253-254`) was inflated by 1. Fix: drop the `max(1, ...)` floor. Two enforcement tests in `tests/integration/test_group_xp_npc_level_floor.py`: (1) level-1 NPC pet contributes 0; (2) level-3 NPC pet contributes 1 (sanity check that the original behavior at level ≥ 2 is preserved).
+
+## [2.9.14]
+
+### Fixed
+- **INV-018 WEAR-OFF-MESSAGE-FOR-RAW-AFFECT — raw `AffectData` expiries silent in Python** (`mud/affects/engine.py:tick_spell_effects`, new helper `_lookup_raw_affect_wear_off`): ROM `src/update.c:777-781` emits `skill_table[paf->type].msg_off` to the character whenever any positive-typed affect's duration reaches 0 — keyed off the spell SN against the skill_table, not off the `AFFECT_DATA` struct itself. Python's `tick_spell_effects` only emitted a wear-off message when the expiring affect's name appeared in the `spell_effects` dict (the `apply_spell_effect` shadow-mirror path). Raw `AffectData` entries — written straight to `character.affected` via `affect_to_char` without a parallel `apply_spell_effect` call — wore off silently. The production trigger is plague spread at `mud/game_loop.py:614-624`, which builds an `AffectData(type="plague", …)` from constants and calls `vch.affect_to_char(new_af)`; the victim's plague tick then expires silently instead of emitting the skill_table msg_off line (`"Your sores vanish."` per `data/skills.json`). Same applies to any future call path that bypasses `apply_spell_effect`. Fix mirrors the precedent at `mud/game_loop.py:1121-1131 _broadcast_object_wear_off` (object affects use the same hybrid pattern): prefer an explicit `wear_off_message` attribute on the affect, then fall back to `skill_registry.get(affect.type).messages["wear_off"]`. Two enforcement tests in `tests/integration/test_inv018_wear_off_message_for_raw_affect.py`: (1) dynamic `wear_off_message` attribute on the affect must surface; (2) absent that attribute, the registry fallback must fire with the ROM-canonical msg_off string from `data/skills.json`. Tracker now at 18 of ~20 budget; INV-001 … INV-018 all ✅ ENFORCED.
+
 ## [2.9.13]
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.13
+Version: 2.9.15
 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.13 → rom24_quickmud_python-2.9.15}/mud/affects/engine.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from mud.handler import affect_remove
 from mud.models.character import Character
+from mud.skills.registry import skill_registry
 from mud.utils import rng_mm
 
 ROM_NEWLINE = "\n\r"
@@ -9,6 +10,35 @@ ROM_NEWLINE = "\n\r"
 __all__ = ["tick_spell_effects"]
 
 
+def _lookup_raw_affect_wear_off(affect) -> str | None:
+    """Mirror ROM ``src/update.c:777-781`` — emit ``skill_table[paf->type].msg_off``
+    on raw AffectData expiry.
+
+    Prefer an explicit ``wear_off_message`` attribute on the affect itself
+    (matches the precedent at ``mud/game_loop.py:1121-1131`` for object
+    affects), then fall back to ``skill_registry`` keyed by ``affect.type``
+    (the spell SN / name). Returns ``None`` if no message can be resolved —
+    a silent expiry is then identical to ROM's behavior when the skill has
+    no ``msg_off`` defined.
+    """
+    explicit = getattr(affect, "wear_off_message", None)
+    if isinstance(explicit, str) and explicit:
+        return explicit
+
+    spell_name = getattr(affect, "type", None)
+    if not isinstance(spell_name, str) or not spell_name:
+        return None
+    try:
+        skill = skill_registry.get(spell_name)
+    except KeyError:
+        return None
+    messages = getattr(skill, "messages", None) or {}
+    candidate = messages.get("wear_off")
+    if isinstance(candidate, str) and candidate:
+        return candidate
+    return None
+
+
 def tick_spell_effects(character: Character) -> list[str]:
     """Reduce active spell durations and collect wear-off messages."""
 
@@ -67,11 +97,20 @@ def tick_spell_effects(character: Character) -> list[str]:
                 else:
                     affect_remove(character, affect)
 
-            if isinstance(spell_name, str) and spell_name in effects:
+            if spell_effects_managed:
                 touched_names.add(spell_name)
                 wear_off = getattr(effects[spell_name], "wear_off_message", None)
                 if should_emit and wear_off:
                     messages.append(f"{wear_off}{ROM_NEWLINE}")
+            else:
+                # ROM src/update.c:777-781 — emit skill_table[paf->type].msg_off
+                # for any raw AffectData expiry (e.g. plague-by-spread from
+                # mud/game_loop.py:614-624, food-borne poison transfers).
+                # INV-018 enforcement point.
+                if should_emit:
+                    raw_wear_off = _lookup_raw_affect_wear_off(affect)
+                    if raw_wear_off:
+                        messages.append(f"{raw_wear_off}{ROM_NEWLINE}")
 
         for spell_name in touched_names:
             remaining = [

{rom24_quickmud_python-2.9.13 → rom24_quickmud_python-2.9.15}/mud/groups/xp.py

@@ -102,7 +102,9 @@ def group_gain(ch: Character, victim: Character) -> None:
         if level <= 0:
             continue
         if getattr(gch, "is_npc", False):
-            total_levels += max(1, level // 2)
+            # mirroring ROM src/fight.c:1751 — `gch->level / 2` is raw C
+            # integer division, so a level-1 NPC contributes 0, not 1.
+            total_levels += level // 2
         else:
             total_levels += level
 

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

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

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

@@ -692,6 +692,7 @@ tests/integration/test_furniture_occupancy.py
 tests/integration/test_get_room_messages.py
 tests/integration/test_give_command.py
 tests/integration/test_group_combat.py
+tests/integration/test_group_xp_npc_level_floor.py
 tests/integration/test_healer_command_parity.py
 tests/integration/test_hedit_parity.py
 tests/integration/test_hpcnt_once_per_pulse.py
@@ -712,6 +713,7 @@ 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_inv016_position_transition_broadcast.py
+tests/integration/test_inv018_wear_off_message_for_raw_affect.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.15/tests/integration/test_group_xp_npc_level_floor.py

@@ -0,0 +1,165 @@
+"""`group_gain` must not floor NPC level contributions at 1.
+
+ROM ``src/fight.c:1751`` accumulates ``group_levels``:
+
+    group_levels += IS_NPC (gch) ? gch->level / 2 : gch->level;
+
+For a level-1 NPC group member (e.g. a charmed pet, an NPC follower the
+player has grouped with), ROM contributes ``1 / 2 == 0`` to the denominator.
+Python's ``mud/groups/xp.py:104-105`` was:
+
+    if getattr(gch, "is_npc", False):
+        total_levels += max(1, level // 2)
+
+The ``max(1, ...)`` floor inflates the denominator by 1 at NPC level 1,
+making the PC's share-formula divisor larger than ROM's and reducing the
+XP awarded to the PC.  Symptom: a level-10 PC grouped with a level-1
+charmed pet kills a victim and receives ~10% less XP than ROM would
+award.
+
+This test pins the ROM-faithful arithmetic by exercising ``xp_compute``
+through ``group_gain`` end-to-end, asserting the awarded XP matches the
+ROM denominator (``max(1, total_levels - 1)`` where ``total_levels``
+omits the level-1 NPC's contribution).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mud.groups.xp import group_gain, xp_compute
+from mud.models.character import Character, character_registry
+from mud.models.constants import Position
+from mud.models.room import Room
+from mud.registry import room_registry
+from mud.utils import rng_mm
+
+
+@pytest.fixture(autouse=True)
+def _cleanup():
+    snapshot = list(character_registry)
+    character_registry.clear()
+    yield
+    character_registry.clear()
+    character_registry.extend(snapshot)
+    room_registry.pop(9200, None)
+
+
+def _make_room() -> Room:
+    room = Room(vnum=9200, name="Group XP", description="", room_flags=0, sector_type=0)
+    room.people = []
+    room.contents = []
+    room_registry[9200] = room
+    return room
+
+
+def _make_pc(room: Room, level: int) -> Character:
+    pc = Character(
+        name="Leader",
+        level=level,
+        room=room,
+        is_npc=False,
+        hit=100,
+        max_hit=100,
+        mana=100,
+        max_mana=100,
+        move=100,
+        max_move=100,
+        position=int(Position.STANDING),
+        exp=0,
+        alignment=0,
+    )
+    pc.leader = pc  # own group leader
+    pc.played = 0
+    pc.logon = 0
+    pc.messages = []
+    room.people.append(pc)
+    character_registry.append(pc)
+    return pc
+
+
+def _make_npc_pet(room: Room, level: int, master: Character) -> Character:
+    pet = Character(
+        name="Pet",
+        short_descr="a pet",
+        level=level,
+        room=room,
+        is_npc=True,
+        hit=20,
+        max_hit=20,
+        position=int(Position.STANDING),
+        alignment=0,
+    )
+    pet.master = master
+    pet.leader = master
+    room.people.append(pet)
+    character_registry.append(pet)
+    return pet
+
+
+def _make_victim(room: Room, level: int) -> Character:
+    victim = Character(
+        name="Victim",
+        short_descr="a victim",
+        level=level,
+        room=room,
+        is_npc=True,
+        hit=0,
+        max_hit=20,
+        position=int(Position.DEAD),
+        alignment=0,
+    )
+    room.people.append(victim)
+    character_registry.append(victim)
+    return victim
+
+
+def test_npc_level_one_contributes_zero_to_group_levels():
+    """Level-1 NPC pet must contribute 0 (ROM `gch->level / 2 == 0`),
+    not 1 (Python's pre-fix `max(1, level // 2)`)."""
+    room = _make_room()
+    pc = _make_pc(room, level=10)
+    pet = _make_npc_pet(room, level=1, master=pc)
+    victim = _make_victim(room, level=10)
+
+    # Expected: xp_compute called with total_levels = 10 (PC only).
+    # Python pre-fix: xp_compute called with total_levels = 11.
+    # We probe via the shared xp_compute formula at the share-divide step.
+    rng_mm.seed_mm(99)
+    rom_xp = xp_compute(pc, victim, total_levels=10)
+    rng_mm.seed_mm(99)
+    bug_xp = xp_compute(pc, victim, total_levels=11)
+    assert rom_xp != bug_xp, "test sanity: the two denominators must yield different XP"
+
+    # group_gain must use ROM's denominator.
+    rng_mm.seed_mm(99)
+    baseline_exp = 100_000  # well above exp_per_level floor
+    pc.exp = baseline_exp
+    pc.alignment = 0  # reset (xp_compute may mutate via alignment-change)
+    group_gain(pc, victim)
+    awarded = pc.exp - baseline_exp
+    assert awarded == rom_xp, (
+        f"group_gain awarded {awarded} but ROM would award {rom_xp} "
+        f"(Python pre-fix would award {bug_xp} via inflated denominator)"
+    )
+
+
+def test_npc_level_three_contributes_one_unchanged():
+    """Sanity: at NPC level 3, ROM (`3 / 2 == 1`) and Python (`max(1, 3 // 2) == 1`)
+    agree.  This test must keep passing after the floor is removed."""
+    room = _make_room()
+    pc = _make_pc(room, level=10)
+    pet = _make_npc_pet(room, level=3, master=pc)
+    victim = _make_victim(room, level=10)
+
+    # Expected: total_levels = 10 (PC) + 1 (level-3 NPC halved) = 11.
+    rng_mm.seed_mm(99)
+    expected = xp_compute(pc, victim, total_levels=11)
+
+    rng_mm.seed_mm(99)
+    baseline_exp = 100_000
+    pc.exp = baseline_exp
+    pc.alignment = 0
+    group_gain(pc, victim)
+    awarded = pc.exp - baseline_exp
+    assert awarded == expected

rom24_quickmud_python-2.9.15/tests/integration/test_inv018_wear_off_message_for_raw_affect.py

@@ -0,0 +1,132 @@
+"""Raw AffectData entries (no spell_effects shadow) must emit msg_off on expiry.
+
+ROM ``src/update.c:777-781`` emits ``skill_table[paf->type].msg_off`` to the
+character when a positive-typed affect expires — regardless of which apply
+path created the affect.  Every AFF_ entry in ``ch->affected`` gets the
+wear-off line based on its skill SN, including ones landed via:
+
+  - ``affect_to_char`` from plague spread
+    (``src/update.c:828-840`` → ``mud/game_loop.py:614-624`` — bare
+    ``AffectData`` built from constants, no ``apply_spell_effect`` shadow);
+  - ``spell_poison`` poisoning food/drink that transfers to ch;
+  - any future call path that bypasses ``apply_spell_effect``.
+
+Python's ``mud/affects/engine.py:tick_spell_effects`` only yields a wear-off
+message when the expiring affect's name appears in the ``spell_effects``
+dict (line 70: ``isinstance(spell_name, str) and spell_name in effects``).
+Raw AffectData entries — written directly to ``character.affected`` without
+a parallel ``apply_spell_effect`` call — wear off silently.
+
+ROM keys the message off ``skill_table[paf->type].msg_off`` (a per-skill
+lookup), not off the affect struct.  Python's faithful equivalent is the
+``skill_registry`` ``messages["wear_off"]`` field, mirroring the precedent
+at ``mud/game_loop.py:1121-1131`` (``_broadcast_object_wear_off``) which
+already does this hybrid lookup for object affects: prefer the affect's
+own attribute, fall back to the skill registry by spell name.
+
+Two tests pin the two paths:
+
+1. Dynamic ``wear_off_message`` attribute set on the affect must surface.
+2. Skill-registry fallback fires when the affect has no dynamic attribute
+   set (the actual production trigger from plague-spread).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from mud.affects.engine import tick_spell_effects
+from mud.models.character import AffectData, Character, character_registry
+from mud.models.constants import AffectFlag
+from mud.skills.registry import skill_registry
+
+
+@pytest.fixture(autouse=True)
+def _isolated_registry():
+    snapshot = list(character_registry)
+    character_registry.clear()
+    yield
+    character_registry.clear()
+    character_registry.extend(snapshot)
+
+
+@pytest.fixture
+def loaded_skills():
+    """Load data/skills.json into the global skill_registry for the test."""
+    skills_path = Path(__file__).resolve().parents[2] / "data" / "skills.json"
+    skill_registry.load(skills_path)
+    return skill_registry
+
+
+def _make_plague_affect(duration: int) -> AffectData:
+    return AffectData(
+        type="plague",
+        level=20,
+        duration=duration,
+        location=0,
+        modifier=0,
+        bitvector=int(AffectFlag.PLAGUE),
+    )
+
+
+def _tick_until_expiry(ch: Character) -> list[str]:
+    """Tick spell effects until expiry message lands (or 5 ticks max)."""
+    collected: list[str] = []
+    for _ in range(5):
+        msgs = tick_spell_effects(ch)
+        collected.extend(msgs)
+        if msgs:
+            return collected
+        # affect duration was decremented; the next tick is the expiry pass
+    return collected
+
+
+def test_raw_affect_emits_dynamic_wear_off_message_on_expiry():
+    """If the AffectData carries its own wear_off_message attribute, the
+    tick must surface it on expiry — mirrors the object-affect precedent
+    at game_loop.py:1121-1131."""
+    ch = Character(name="Victim", is_npc=False)
+    ch.messages = []
+    character_registry.append(ch)
+
+    affect = _make_plague_affect(duration=1)
+    sentinel = "SENTINEL_DYNAMIC_PREFERRED_OVER_REGISTRY"
+    affect.wear_off_message = sentinel
+    ch.affected = [affect]
+    ch.affected_by = int(AffectFlag.PLAGUE)
+
+    msgs = _tick_until_expiry(ch)
+
+    assert any(sentinel in m for m in msgs), (
+        f"raw AffectData with dynamic wear_off_message must surface it on "
+        f"expiry; got {msgs!r}"
+    )
+
+
+def test_raw_affect_falls_back_to_skill_registry_wear_off(loaded_skills):
+    """The production trigger: plague-spread creates an AffectData with no
+    wear_off_message attribute. ROM looks up skill_table[paf->type].msg_off
+    directly; Python must fall back to skill_registry by spell name."""
+    plague_skill = loaded_skills.get("plague")
+    rom_wear_off = (plague_skill.messages or {}).get("wear_off")
+    assert rom_wear_off, "test setup requires skills.json to define plague.messages.wear_off"
+
+    ch = Character(name="Victim", is_npc=False)
+    ch.messages = []
+    character_registry.append(ch)
+
+    affect = _make_plague_affect(duration=1)
+    # NOTE: deliberately NO wear_off_message attribute set — mirrors the
+    # plague-spread path at mud/game_loop.py:614-624 which never sets one.
+    ch.affected = [affect]
+    ch.affected_by = int(AffectFlag.PLAGUE)
+
+    msgs = _tick_until_expiry(ch)
+
+    assert any(rom_wear_off in m for m in msgs), (
+        f"raw AffectData with no dynamic wear_off_message must fall back "
+        f"to skill_registry messages['wear_off'] for type {affect.type!r}; "
+        f"expected substring {rom_wear_off!r}, got {msgs!r}"
+    )