rom24-quickmud-python 2.9.2__tar.gz → 2.9.3__tar.gz

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.3]
+
+### Added
+- **`INV-014` — OBJECT-REGISTRY-MEMBERSHIP locked in** (`docs/parity/CROSS_FILE_INVARIANTS_TRACKER.md`, `tests/integration/test_inv014_object_registry_membership.py`): ROM `src/db.c:create_object` appends every freshly built `OBJ_DATA` to the global `object_list` unconditionally — every world-scan consumer (`src/magic.c:3737 spell_locate_object`, decay sweep, save) walks that list. Previously only `mud/spawning/obj_spawner.py:spawn_object` appended to `mud.models.obj.object_registry`; six other production sites built `Object` instances without registering, leaving freshly-created corpses, gore objects, money piles, shop clones, and DB-restored inventory invisible to `locate object`. Added `mud.models.object.create_object(prototype, *, instance_id=None)` as the canonical factory (appends and returns); routed every production construction site through it. `mud/skills/handlers.py:_iterate_world_objects` now walks `object_registry` first, computing the holder per ROM `src/magic.c:3747` (outermost `in_obj` chain → `carried_by` → `in_room` → `None` rendered as "somewhere"); a legacy room/character walk remains as a compat backstop for unit tests. Eight enforcement tests cover every construction path plus the homeless-object locate symptom.
+
+### Fixed
+- **`spell_locate_object` could not find homeless objects** (`mud/skills/handlers.py:_iterate_world_objects`): an object spawned but not yet placed (`in_room=None, carried_by=None, in_obj=None`) was skipped entirely, while ROM `src/magic.c:3756-3762` reports it as "one is in somewhere" (the `in_room == NULL` branch). Iterator now walks `object_registry` so registered-but-unplaced objects surface at parity with ROM.
+- **Six production sites built `Object` instances without registering** (handler.py, combat/death.py ×2, rom_api.py, commands/shop.py fallback, models/conversion.py): `create_money`, `_fallback_gore`, `_fallback_corpse`, `recursive_clone`, `_clone_inventory_object` (when `spawn_object` returned `None`), and `load_objects_for_character` all bypassed `object_registry`. ROM `create_object` always appends. All six now route through `create_object` (or `spawn_object` where applicable).
+
 ## [2.9.2]
 
 ### Added

{rom24_quickmud_python-2.9.2/rom24_quickmud_python.egg-info → rom24_quickmud_python-2.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.2
+Version: 2.9.3
 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.2 → rom24_quickmud_python-2.9.3}/mud/combat/death.py

@@ -29,7 +29,7 @@ from mud.characters.follow import stop_follower
 from mud.models.clans import get_clan_hall_vnum
 from mud.models.races import get_race_by_index
 from mud.models.obj import ObjIndex
-from mud.models.object import Object
+from mud.models.object import Object, create_object
 from mud.models.social import expand_placeholders
 from mud.spawning.obj_spawner import spawn_object
 from mud.utils import rng_mm
@@ -74,7 +74,7 @@ def _fallback_gore(
         description=description_template,
     )
     proto.item_type = int(item_type)
-    obj = Object(instance_id=None, prototype=proto)
+    obj = create_object(proto)
     obj.item_type = int(item_type)
     return obj
 
@@ -341,7 +341,7 @@ def _fallback_corpse(vnum: int, *, item_type: ItemType) -> Object:
 
     proto = ObjIndex(vnum=vnum, short_descr="the corpse of %s", description="The corpse of %s is lying here.")
     proto.item_type = int(item_type)
-    corpse = Object(instance_id=None, prototype=proto)
+    corpse = create_object(proto)
     corpse.item_type = int(item_type)
     return corpse
 

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/mud/commands/shop.py

@@ -20,7 +20,7 @@ from mud.models.constants import (
     ITEM_SELL_EXTRACT,
     ITEM_VIS_DEATH,
 )
-from mud.models.object import Object
+from mud.models.object import Object, create_object
 from mud.registry import room_registry, shop_registry
 from mud.skills import check_improve
 from mud.spawning.obj_spawner import spawn_object
@@ -354,7 +354,7 @@ def _clone_inventory_object(template: Object) -> Object | None:
 
     clone = spawn_object(getattr(proto, "vnum", 0))
     if clone is None:
-        clone = Object(instance_id=None, prototype=proto)
+        clone = create_object(proto)
 
     # Mirror runtime overrides from the template copy so shop customisations persist.
     clone.value = list(getattr(template, "value", clone.value))

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/mud/handler.py

@@ -892,7 +892,7 @@ def create_money(gold: int, silver: int) -> Object:
         ItemType,
     )
     from mud.models.obj import ObjIndex
-    from mud.models.object import Object
+    from mud.models.object import Object, create_object
 
     # ROM C handler.c:2432-2437 (validate input)
     if gold < 0 or silver < 0 or (gold == 0 and silver == 0):
@@ -957,7 +957,7 @@ def create_money(gold: int, silver: int) -> Object:
         wear_flags=int(WearFlag.TAKE),
         weight=weight,
     )
-    obj = Object(instance_id=None, prototype=proto)
+    obj = create_object(proto)
     obj.item_type = int(ItemType.MONEY)
     obj.short_descr = short_descr
     obj.cost = cost

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/mud/models/conversion.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from mud.db.models import Character as DBCharacter
 from mud.db.models import ObjectInstance as DBObjectInstance
-from mud.models.object import Object
+from mud.models.object import Object, create_object
 from mud.registry import obj_registry
 
 
@@ -14,7 +14,7 @@ def load_objects_for_character(db_char: DBCharacter) -> tuple[list[Object], dict
         proto = obj_registry.get(inst.prototype_vnum)
         if not proto:
             continue
-        obj = Object(instance_id=inst.id, prototype=proto)
+        obj = create_object(proto, instance_id=inst.id)
         if inst.location and inst.location.startswith("equipment:"):
             slot = inst.location.split(":", 1)[1]
             equipment[slot] = obj

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/mud/models/object.py

@@ -146,3 +146,23 @@ class Object:
             self.in_room = value  # type: ignore[assignment]
             self.carried_by = None
             self.in_obj = None
+
+
+def create_object(prototype: ObjIndex, *, instance_id: int | None = None) -> Object:
+    """Build a new ``Object`` and register it on ``object_registry``.
+
+    INV-014 OBJECT-REGISTRY-MEMBERSHIP: ROM ``src/db.c:create_object``
+    appends every freshly built ``OBJ_DATA`` to the global
+    ``object_list``. ``mud.models.obj.object_registry`` is the canonical
+    Python equivalent; world-scan consumers (``spell_locate_object`` and
+    any future iteration over every live object) rely on it being
+    complete. Every Python ``Object(...)`` construction site that does
+    not already go through ``mud.spawning.obj_spawner.spawn_object``
+    must call this helper.
+    """
+
+    from mud.models.obj import object_registry
+
+    obj = Object(instance_id=instance_id, prototype=prototype)
+    object_registry.append(obj)
+    return obj

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/mud/rom_api.py

@@ -658,7 +658,7 @@ def recursive_clone(obj: Object, clone_to: Object | None = None) -> Object:
         Cloned object with all contents
     """
     from mud.models.obj import ObjIndex
-    from mud.models.object import Object
+    from mud.models.object import Object, create_object
 
     if not obj.prototype:
         proto = ObjIndex(
@@ -678,7 +678,7 @@ def recursive_clone(obj: Object, clone_to: Object | None = None) -> Object:
     else:
         proto = obj.prototype
 
-    new_obj = Object(instance_id=None, prototype=proto)
+    new_obj = create_object(proto)
 
     for content in obj.contained_items:
         recursive_clone(content, new_obj)

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/mud/skills/handlers.py

@@ -857,16 +857,52 @@ def _object_name_matches(obj: Object, search: str) -> bool:
 
 
 def _iterate_world_objects():
-    """Yield (object, holder) pairs mirroring ROM ``object_list`` traversal."""
+    """Yield ``(object, holder)`` pairs mirroring ROM ``object_list``.
+
+    INV-014 OBJECT-REGISTRY-MEMBERSHIP: ``object_registry`` is the
+    canonical Python equivalent of ROM ``object_list``. The primary
+    iteration walks it directly so that registered-but-unplaced objects
+    (e.g. transiently between ``extract`` and re-placement, or freshly
+    spawned before being put in a room) are surfaced exactly as ROM
+    ``spell_locate_object`` (src/magic.c:3737) sees them.
+
+    For each registered obj the holder is computed per ROM
+    src/magic.c:3747: walk the ``in_obj`` chain to the outermost
+    container, then prefer ``carried_by`` over ``in_room`` (``None``
+    if neither is set, rendered as "somewhere").
+
+    A secondary walk of ``room_registry`` / ``character_registry``
+    backstops legacy unit tests that build ``Object`` instances directly
+    without going through ``create_object`` / ``spawn_object``; the seen
+    set dedupes by identity so registered objects are not yielded twice.
+    """
+
+    from mud.models.obj import object_registry
 
     seen: set[int] = set()
 
-    def _walk(obj: Object, holder: object):
+    def _yield(obj: Object, holder: object):
         ident = id(obj)
         if ident in seen:
             return
         seen.add(ident)
         yield obj, holder
+
+    for obj in list(object_registry):
+        outer = obj
+        while getattr(outer, "in_obj", None) is not None:
+            outer = outer.in_obj
+        carried_by = getattr(outer, "carried_by", None)
+        if carried_by is not None:
+            yield from _yield(obj, carried_by)
+            continue
+        in_room = getattr(outer, "in_room", None)
+        yield from _yield(obj, in_room)
+
+    def _walk(obj: Object, holder: object):
+        if id(obj) in seen:
+            return
+        yield from _yield(obj, holder)
         children: list[Object] = []
         contained = getattr(obj, "contained_items", None)
         if isinstance(contained, list):

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.3}/pyproject.toml

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

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

@@ -704,6 +704,7 @@ tests/integration/test_inv011_carry_weight_coherence.py
 tests/integration/test_inv012_end_to_end.py
 tests/integration/test_inv012_object_list_canonical.py
 tests/integration/test_inv013_object_location_coherence.py
+tests/integration/test_inv014_object_registry_membership.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.3/tests/integration/test_inv014_object_registry_membership.py

@@ -0,0 +1,169 @@
+"""INV-014 OBJECT-REGISTRY-MEMBERSHIP enforcement.
+
+ROM ``src/db.c:create_object`` appends every freshly built OBJ_DATA to
+the global ``object_list``. ROM ``src/magic.c:3737 spell_locate_object``
+walks that list. After INV-012 consolidated the dual ``Object``/
+``ObjectData`` runtime into one class, ``mud.models.obj.object_registry``
+became the canonical Python equivalent of ``object_list`` — populated
+by ``spawn_object`` and drained by ``mud.game_loop._extract_obj``.
+
+Production sites that constructed ``Object`` instances WITHOUT appending
+to the registry left those objects invisible to any
+``object_registry``-driven world scan. The symptom shipped against
+``spell_locate_object``: a freshly-created corpse, gore object, money
+pile, shop clone, or DB-restored inventory was not findable by
+``locate object`` despite being live in the world.
+
+These tests pin every known construction path to the registry contract.
+Add a test here when introducing a new ``Object(...)`` construction
+site.
+"""
+
+from __future__ import annotations
+
+from mud.combat.death import _fallback_corpse, _fallback_gore
+from mud.commands.shop import _clone_inventory_object
+from mud.db.models import Character as DBCharacter
+from mud.db.models import ObjectInstance as DBObjectInstance
+from mud.handler import create_money
+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 Object
+from mud.models.conversion import load_objects_for_character
+from mud.registry import obj_registry, room_registry
+from mud.rom_api import recursive_clone
+from mud.skills.handlers import locate_object
+from mud.spawning.obj_spawner import spawn_object
+
+
+def _registry_contains(obj: Object) -> bool:
+    """Identity-based membership check.
+
+    ``Object`` is a dataclass with default ``__eq__``; two distinct
+    instances sharing the same prototype and default field values compare
+    equal, so ``obj in object_registry`` can falsely succeed when an
+    *unrelated* like-shaped object happens to be in the registry. Use
+    ``id`` to verify the actual instance was registered.
+    """
+
+    return any(o is obj for o in object_registry)
+
+
+def test_inv014_spawn_object_registers() -> None:
+    """``spawn_object`` is the original ROM-faithful ``create_object`` mirror."""
+
+    proto = ObjIndex(vnum=4001, name="anvil", short_descr="an anvil")
+    obj_registry[4001] = proto
+    try:
+        obj = spawn_object(4001)
+    finally:
+        obj_registry.pop(4001, None)
+
+    assert obj is not None
+    assert _registry_contains(obj)
+
+
+def test_inv014_create_money_registers() -> None:
+    """ROM ``create_money`` (``src/handler.c``) emits an OBJ_DATA via ``create_object``."""
+
+    obj = create_money(gold=100, silver=0)
+    assert _registry_contains(obj)
+
+
+def test_inv014_recursive_clone_registers() -> None:
+    """ROM ``act_obj.c:do_clone`` builds clones through ``create_object``."""
+
+    proto = ObjIndex(vnum=4100, name="staff", short_descr="a staff")
+    template = Object(instance_id=None, prototype=proto)
+    object_registry.append(template)
+
+    clone = recursive_clone(template)
+    assert _registry_contains(clone)
+    assert clone is not template
+
+
+def test_inv014_fallback_corpse_registers() -> None:
+    """``make_corpse`` fallback path still goes through ``create_object`` in ROM."""
+
+    corpse = _fallback_corpse(0, item_type=ItemType.CORPSE_NPC)
+    assert _registry_contains(corpse)
+
+
+def test_inv014_fallback_gore_registers() -> None:
+    """Gore fallback in ``death_cry`` constructs an OBJ_DATA — must register."""
+
+    gore = _fallback_gore(
+        0,
+        short_template="a bloody hunk",
+        description_template="A bloody hunk lies here.",
+        item_type=ItemType.FOOD,
+    )
+    assert _registry_contains(gore)
+
+
+def test_inv014_clone_inventory_object_registers() -> None:
+    """Shop stocking clones a template — ROM ``act_obj.c:do_buy`` calls ``create_object``."""
+
+    proto = ObjIndex(vnum=4200, name="potion", short_descr="a potion")
+    template = Object(instance_id=None, prototype=proto)
+    object_registry.append(template)
+
+    clone = _clone_inventory_object(template)
+    assert clone is not None
+    assert _registry_contains(clone)
+
+
+def test_inv014_load_objects_for_character_registers() -> None:
+    """Restoring a character's inventory from DB must put each obj on ``object_list``."""
+
+    proto = ObjIndex(vnum=4300, name="ring", short_descr="a ring")
+    obj_registry[4300] = proto
+    db_char = DBCharacter(name="Restored", level=1, hp=10, room_vnum=3001)
+    db_char.objects = [DBObjectInstance(prototype_vnum=4300, location="inventory")]
+
+    try:
+        inventory, _equipment = load_objects_for_character(db_char)
+    finally:
+        obj_registry.pop(4300, None)
+
+    assert len(inventory) == 1
+    assert _registry_contains(inventory[0])
+
+
+def test_inv014_locate_object_finds_homeless_object() -> None:
+    """ROM ``spell_locate_object`` iterates ``object_list``; an unplaced
+    object (``in_room == NULL``, ``carried_by == NULL``, ``in_obj == NULL``)
+    is reported as "one is in somewhere" rather than skipped.
+    """
+
+    caster = Character(
+        name="Diviner",
+        level=LEVEL_IMMORTAL,
+        trust=LEVEL_IMMORTAL,
+        is_npc=False,
+    )
+    character_registry.append(caster)
+
+    proto = ObjIndex(vnum=4400, name="orphan widget", short_descr="an orphan widget")
+    obj_registry[4400] = proto
+    try:
+        widget = spawn_object(4400)
+    finally:
+        obj_registry.pop(4400, None)
+    assert widget is not None
+    # Spawned but never placed — in_room/carried_by/in_obj all None.
+    assert widget.in_room is None
+    assert widget.carried_by is None
+    assert widget.in_obj is None
+
+    caster.messages.clear()
+    assert locate_object(caster, "widget") is True
+    # ROM's "in_room == NULL" branch prints "one is in somewhere\n\r"
+    # uppercased to "One is in somewhere".
+    assert any("somewhere" in msg for msg in caster.messages)
+
+    # Cleanup — autouse fixtures handle object_registry; character_registry
+    # is not auto-cleared in unit tests, so be explicit.
+    character_registry.remove(caster)
+    room_registry.clear()