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

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

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.4]
+
+### Fixed
+- **`Character.add_object` did not set `obj.carried_by`** (`mud/models/character.py:542`): ROM `src/handler.c:1626 obj_to_char` sets `obj->carried_by = ch` atomically with the inventory append. The Python helper updated `inventory` + carry counters but left the canonical INV-013 carrier field as `None`, so every direct `add_object` caller silently produced an inventory item with no back-pointer to its carrier. Fix: `add_object` now sets `obj.location = self` (INV-013 property dispatch sets `carried_by` and clears `in_room` / `in_obj`).
+- **`do_mpoload` bypassed `Character.add_object` entirely** (`mud/mob_cmds.py:651-655`, ROM `src/mob_cmds.c:603-607 → src/handler.c:1626 obj_to_char`): the inventory-mode branch did `inventory.append(obj)`, missing both the INV-013 `carried_by` field AND the INV-011 carry counters. Every MOBprog `mob oload <vnum>` left the script-mob's `carry_weight` and `carry_number` unchanged, so encumbrance skewed every time a mob scripted an item load. Fix: route through `ch.add_object(obj)`.
+- Surfaced via the INV-012 follow-up scan of `do_mpoload`; existing `test_mob_cmds_oload.py` only checked `obj.level` and inventory membership, never asserting `carried_by` or carry counters. New `tests/integration/test_inv013_add_object_carrier.py` pins both behaviors (3 tests).
+
+## [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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.9.2
+Version: 2.9.4
 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.4}/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.4}/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.4}/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.4}/mud/mob_cmds.py

@@ -648,11 +648,19 @@ def do_mpoload(ch: Character, argument: str) -> None:
     if mode.startswith("r"):
         room.add_object(obj)
         return
+    # mirroring ROM src/mob_cmds.c:603-607 → src/handler.c:1626 obj_to_char.
+    # Route through Character.add_object so the INV-013 carrier field
+    # and INV-011 carry counters stay in lockstep with inventory.
+    add = getattr(ch, "add_object", None)
+    if callable(add):
+        add(obj)
+        return
     inventory = getattr(ch, "inventory", None)
     if inventory is None:
         inventory = []
         ch.inventory = inventory
     inventory.append(obj)
+    obj.location = ch
 
 
 def _resolve_transfer_location(ch: Character, token: str) -> Room | None:

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.4}/mud/models/character.py

@@ -540,7 +540,12 @@ class Character:
         return base_weight + silver // 10 + (gold * 2) // 5
 
     def add_object(self, obj: Object) -> None:
+        # mirroring ROM src/handler.c:1626 obj_to_char — the carrier
+        # field is set atomically with the inventory append. Using the
+        # INV-013 `obj.location` property dispatch sets `carried_by`
+        # and clears `in_room` / `in_obj` per the property contract.
         self.inventory.append(obj)
+        obj.location = self
         self.carry_number += _object_carry_number(obj)
         self._recalculate_carry_weight()
 

{rom24_quickmud_python-2.9.2 → rom24_quickmud_python-2.9.4}/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.4}/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.4}/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.4}/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.4}/pyproject.toml

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

@@ -703,7 +703,9 @@ tests/integration/test_inv010_room_people_coherence.py
 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_add_object_carrier.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.4/tests/integration/test_inv013_add_object_carrier.py

@@ -0,0 +1,140 @@
+"""INV-013/INV-011 follow-up: ``Character.add_object`` must set
+``obj.carried_by`` and update carry counters per ROM
+``src/handler.c:1626 obj_to_char``.
+
+ROM ``obj_to_char`` does three things atomically:
+
+    obj->next_content = ch->carrying;
+    ch->carrying = obj;
+    obj->carried_by = ch;
+    obj->in_room = NULL;
+    obj->in_obj = NULL;
+    ch->carry_number += get_obj_number(obj);
+    ch->carry_weight += get_obj_weight(obj);
+
+The Python ``Character.add_object`` previously updated
+``inventory`` + carry counters but never set ``obj.carried_by``, so
+the canonical INV-013 carrier field stayed ``None`` for every direct
+``add_object`` caller. Per the INV-013 property dispatch,
+``obj.location = self`` is the convergent way to set the field and
+clear the other two (``in_room``, ``in_obj``).
+
+Surfaced through the ``do_mpoload`` audit: the script command
+appended directly to ``ch.inventory`` instead of going through
+``add_object``, so it hit BOTH gaps — the carrier field stayed unset
+AND the carry counters drifted. Both regression tests live here so
+``Character.add_object`` and ``do_mpoload`` are pinned to ROM
+contracts together.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from mud.mob_cmds import do_mpoload
+from mud.models.character import Character
+from mud.models.obj import ObjIndex
+from mud.models.room import Room
+from mud.registry import obj_registry, room_registry
+from mud.spawning.obj_spawner import spawn_object
+
+_TEST_VNUM = 91510
+_ROOM_VNUM = 9511
+
+
+@pytest.fixture
+def add_room() -> Room:
+    room = room_registry.get(_ROOM_VNUM)
+    if room is None:
+        room = Room(vnum=_ROOM_VNUM, name="Add-Object Test Room")
+        room_registry[_ROOM_VNUM] = room
+    room.contents.clear()
+    room.people.clear()
+    return room
+
+
+@pytest.fixture(autouse=True)
+def _register_proto():
+    proto = ObjIndex(
+        vnum=_TEST_VNUM,
+        name="anvil",
+        short_descr="an anvil",
+        description="A heavy anvil.",
+        item_type=1,
+        level=5,
+        weight=20,
+        value=[0, 0, 0, 0, 0],
+    )
+    obj_registry[_TEST_VNUM] = proto
+    yield
+    obj_registry.pop(_TEST_VNUM, None)
+
+
+@pytest.fixture
+def carrier(add_room: Room) -> Character:
+    ch = Character(name="Carrier", is_npc=True)
+    ch.level = 30
+    ch.trust = 30
+    add_room.add_character(ch)
+    return ch
+
+
+def test_add_object_sets_carried_by(carrier: Character) -> None:
+    """``Character.add_object`` must set ``obj.carried_by`` per
+    ROM ``src/handler.c:1626 obj_to_char``.
+    """
+
+    obj = spawn_object(_TEST_VNUM)
+    assert obj is not None
+
+    carrier.add_object(obj)
+
+    assert obj in carrier.inventory
+    assert obj.carried_by is carrier, (
+        "Character.add_object appended to inventory without setting "
+        "obj.carried_by; ROM src/handler.c:1626 obj_to_char sets it "
+        "atomically and INV-013 makes carried_by the canonical "
+        "carrier field."
+    )
+    # INV-013: setting carried_by must clear the other two location
+    # fields atomically (property dispatch contract).
+    assert obj.in_room is None
+    assert obj.in_obj is None
+
+
+def test_mpoload_inventory_sets_carried_by(carrier: Character) -> None:
+    """``do_mpoload`` (inventory mode) must route through
+    ``Character.add_object`` so the carrier field is set.
+    """
+
+    do_mpoload(carrier, f"{_TEST_VNUM}")
+
+    assert len(carrier.inventory) == 1
+    obj = carrier.inventory[0]
+    assert obj.carried_by is carrier, (
+        "do_mpoload appended to ch.inventory directly without calling "
+        "ch.add_object(obj); obj.carried_by stayed None, violating "
+        "INV-013 and ROM src/mob_cmds.c:603-607 → src/handler.c:1626 "
+        "obj_to_char."
+    )
+
+
+def test_mpoload_inventory_updates_carry_counters(carrier: Character) -> None:
+    """``do_mpoload`` (inventory mode) must update ``carry_weight``
+    and ``carry_number`` per ROM ``obj_to_char`` (INV-011).
+    """
+
+    initial_weight = carrier.carry_weight
+    initial_number = carrier.carry_number
+
+    do_mpoload(carrier, f"{_TEST_VNUM}")
+
+    obj = carrier.inventory[0]
+    proto_weight = int(getattr(obj.prototype, "weight", 0) or 0)
+    assert carrier.carry_weight == initial_weight + proto_weight, (
+        f"carry_weight={carrier.carry_weight}; expected initial "
+        f"({initial_weight}) + obj.weight ({proto_weight}). do_mpoload "
+        "must route through Character.add_object so INV-011 carry "
+        "counters stay in lockstep with inventory contents."
+    )
+    assert carrier.carry_number == initial_number + 1

rom24_quickmud_python-2.9.4/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()