rom24-quickmud-python 2.14.211__py3-none-any.whl → 2.14.268__py3-none-any.whl

mud/admin_logging/admin.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -100,7 +100,7 @@ def log_admin_command(
     """
 
     Path("log").mkdir(exist_ok=True)
-    timestamp = datetime.now(UTC).isoformat().replace("+00:00", "Z")
+    timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
     sanitized = _sanitize_command_line(command_line)
     if character is not None:
         try:
@@ -132,7 +132,7 @@ def rotate_admin_log(today: datetime | None = None) -> Path:
     active = log_dir / "admin.log"
     if not active.exists():
         return active
-    dt = today or datetime.now(UTC)
+    dt = today or datetime.now(timezone.utc)
     dated = log_dir / f"admin-{dt.strftime('%Y%m%d')}.log"
     # Avoid clobbering: if dated file exists, append current log and remove active
     if dated.exists():

mud/combat/engine.py

@@ -40,10 +40,11 @@ from mud.models.constants import (
 )
 from mud.models.weapon_table import weapon_skill_name_for_type
 from mud.skills import check_improve
+from mud.skills.skill_lookup import get_skill
 from mud.utils import rng_mm
 from mud.utils.act import capitalize_act_line
 from mud.wiznet import WiznetFlag, wiznet
-from mud.world.vision import can_see_object, pers
+from mud.world.vision import can_see_character, can_see_object, pers
 
 HAND_TO_HAND_SKILL = "hand to hand"
 
@@ -519,6 +520,35 @@ def _mob_offensive_skill(attacker: Character, roll: int, off_flags: int, act_fla
     # commented out).
 
 
+def _compute_victim_ac(attacker: Character, victim: Character, ac_idx: int, victim_pos: int) -> int:
+    """ROM ``one_hit`` effective victim AC (src/fight.c:480-503).
+
+    ROM divides GET_AC by 10 **first**, then applies the ``< -15`` rescale and
+    the visibility/position modifiers **on the /10 scale** — not on the raw
+    (×10) armor value. FIGHT-081: the pre-fix Python applied the modifiers and
+    the rescale to the raw AC and divided by 10 last, making the -4/+4/+6
+    modifiers ~10× too weak and mis-firing the rescale for nearly every armored
+    character. The visibility -4 gates on ``!can_see(ch, victim)`` (broader than
+    the victim's INVISIBLE affect: also blind/dark/hide, and withheld from a
+    detect-invis attacker), mirroring ROM src/fight.c:496.
+    """
+
+    # mirroring ROM src/fight.c:480-491 — GET_AC(victim, ac) / 10 (c_div: AC is signed).
+    victim_ac = c_div(get_ac(victim, ac_idx), 10)
+    # mirroring ROM src/fight.c:493-494 — rescale of very-negative AC, on the /10 scale.
+    if victim_ac < -15:
+        victim_ac = c_div(victim_ac + 15, 5) - 15
+    # mirroring ROM src/fight.c:496-497 — !can_see(ch, victim), not the INVISIBLE affect.
+    if not can_see_character(attacker, victim):
+        victim_ac -= 4
+    # mirroring ROM src/fight.c:499-503 — position penalties on the /10 scale.
+    if victim_pos < Position.FIGHTING:
+        victim_ac += 4
+    if victim_pos < Position.RESTING:
+        victim_ac += 6
+    return victim_ac
+
+
 def attack_round(attacker: Character, victim: Character, dt: str | int | None = None) -> str:
     """Resolve a single attack round.
 
@@ -548,19 +578,10 @@ def attack_round(attacker: Character, victim: Character, dt: str | int | None =
     dam_type_lookup = attack_damage_type(attack_index)
     dam_type = int(dam_type_lookup) if dam_type_lookup is not None else int(DamageType.BASH)
     ac_idx = ac_index_for_dam_type(dam_type)
-    # ROM src/merc.h:2104-2106 GET_AC adds dex_app[DEX].defensive when IS_AWAKE.
-    victim_ac = get_ac(victim, ac_idx)
-    # Visibility and position modifiers (ROM-inspired)
-    if getattr(victim, "has_affect", None) and victim.has_affect(AffectFlag.INVISIBLE):
-        victim_ac -= 4
-    if _victim_pos_before < Position.FIGHTING:
-        victim_ac += 4
-    if _victim_pos_before < Position.RESTING:
-        victim_ac += 6
-
-    # ROM AC clamping for very negative values
-    if victim_ac < -15:
-        victim_ac = c_div(victim_ac + 15, 5) - 15
+    # FIGHT-081: ROM one_hit (src/fight.c:480-503) divides GET_AC by 10 first,
+    # then rescales/modifies on the /10 scale. victim_ac is already the value
+    # used directly in the hit test — no further division.
+    victim_ac = _compute_victim_ac(attacker, victim, ac_idx, _victim_pos_before)
 
     # FIGHT-019: ROM one_hit has a single attack-roll model — the THAC0 /
     # number_bits(5) roll (src/fight.c:508-516). The legacy percent model
@@ -593,9 +614,16 @@ def attack_round(attacker: Character, victim: Character, dt: str | int | None =
         )
     else:
         th = compute_thac0(attacker.level, attacker.ch_class, hitroll=get_hitroll(attacker), skill=skill_total)
-    vac = c_div(victim_ac, 10)
+    # FIGHT-086 / HANDLER-008: ROM one_hit (src/fight.c:474-475) — backstab
+    # near-auto-hit below skill 100: thac0 -= 10 * (100 - get_skill(ch, gsn_backstab)).
+    # get_skill clamps to 0..100, so 100-skill is non-negative here. No c_div — no
+    # division. Migrated from the _backstab_skill partial mirror onto unified get_skill.
+    if _normalize_dt(dt) == "backstab":
+        th -= 10 * (100 - get_skill(attacker, "backstab"))
+    # FIGHT-081: victim_ac is already on the /10 scale (see _compute_victim_ac); no
+    # further division — ROM src/fight.c:510 uses victim_ac directly.
     # ROM src/fight.c:510 — miss on nat 0, or (not 19 and diceroll < thac0 - victim_ac).
-    if diceroll == 0 or (diceroll != 19 and diceroll < (th - vac)):
+    if diceroll == 0 or (diceroll != 19 and diceroll < (th - victim_ac)):
         # Miss — ROM C calls damage(ch, victim, 0, dt, dam_type, TRUE).
         return apply_damage(attacker, victim, 0, int(dam_type), dt=attack_dt)
 
@@ -712,6 +740,19 @@ def apply_damage(
         if check_shield_block(attacker, victim):
             return capitalize_act_line(f"{pers(victim, attacker)} blocks your attack with a shield.")
 
+    # FIGHT-092 — "Inviso attacks ... not." ROM src/fight.c:763-769: a connecting
+    # hit reveals an invisible attacker. Strip the invis/mass_invis spell affects
+    # and the AFF_INVISIBLE bit, then broadcast "$n fades into existence." to the
+    # room. Placed past the parry/dodge/shield-block early-returns (mirroring ROM,
+    # where parry/dodge resolve in one_hit before damage() is entered) and before
+    # the RIV/immune modifiers, so it fires even on a 0-damage (immune) hit.
+    if attacker.has_affect(AffectFlag.INVISIBLE):
+        if hasattr(attacker, "remove_spell_effect"):
+            attacker.remove_spell_effect("invis")
+            attacker.remove_spell_effect("mass invis")
+        attacker.affected_by = int(getattr(attacker, "affected_by", 0) or 0) & ~int(AffectFlag.INVISIBLE)
+        _broadcast_pos_change(attacker, "{name} fades into existence.")
+
     # Apply damage type resistance/vulnerability modifiers (ROM fight.c:804-816)
     # This must happen AFTER defense checks but BEFORE damage application
     if dam_type is not None:
@@ -1547,7 +1588,10 @@ def check_shield_block(attacker: Character, victim: Character) -> bool:
     if not _has_shield_equipped(victim):
         return False
 
-    shield_skill = _get_skill_percent(victim, "shield block", "shield_block_skill")
+    # HANDLER-008: unified get_skill — NPCs get ROM's 10+2*level shield-block
+    # formula (src/handler.c:373-432); the old dict lookup returned 0 for mobs, so
+    # NPCs could never shield-block. PCs gate to 0 below the class skill level.
+    shield_skill = get_skill(victim, "shield block")
     chance = c_div(shield_skill, 5) + 3
 
     # Level difference modifier
@@ -1580,7 +1624,9 @@ def check_parry(attacker: Character, victim: Character) -> bool:
     if not is_awake(victim):
         return False
 
-    parry_skill = _get_skill_percent(victim, "parry", "parry_skill")
+    # HANDLER-008: unified get_skill — NPCs with OFF_PARRY get ROM's level*2
+    # (src/handler.c:373-432); PCs gate to 0 below the parry class level.
+    parry_skill = get_skill(victim, "parry")
     chance = c_div(parry_skill, 2)
 
     has_weapon = getattr(victim, "has_weapon_equipped", False)
@@ -1590,8 +1636,11 @@ def check_parry(attacker: Character, victim: Character) -> bool:
         else:
             return False  # PCs need weapons to parry
 
-    # Visibility modifier
-    if not getattr(victim, "can_see", lambda x: True)(attacker):
+    # Visibility modifier — FIGHT-084: ROM src/fight.c:1311 is `!can_see(ch, victim)`
+    # (attacker→victim), NOT victim→attacker. The pre-fix `victim.can_see(attacker)`
+    # was both the wrong direction and inert (no can_see method → `lambda x: True`
+    # fallback never halved). check_dodge is the opposite direction (ROM :1363).
+    if not can_see_character(attacker, victim):
         chance = c_div(chance, 2)
 
     # Level difference modifier
@@ -1623,11 +1672,17 @@ def check_dodge(attacker: Character, victim: Character) -> bool:
     if not is_awake(victim):
         return False
 
-    dodge_skill = _get_skill_percent(victim, "dodge", "dodge_skill")
+    # HANDLER-008: unified get_skill — NPCs with OFF_DODGE get ROM's level*2
+    # (src/handler.c:373-432); PCs gate to 0 below the dodge class level.
+    dodge_skill = get_skill(victim, "dodge")
     chance = c_div(dodge_skill, 2)
 
-    # Visibility modifier
-    if not getattr(victim, "can_see", lambda x: True)(attacker):
+    # Visibility modifier — ROM src/fight.c:1363: if (!can_see(victim, ch)) chance /= 2.
+    # Direction is victim→attacker (defender's view of the attacker); can_see is not
+    # symmetric. FIGHT-089 (twin of the FIGHT-084 check_parry fix): the old
+    # getattr(victim, "can_see", lambda x: True) fallback was inert — runtime entities
+    # have no can_see method, so the halving never fired.
+    if not can_see_character(victim, attacker):
         chance = c_div(chance, 2)
 
     # Level difference modifier

mud/commands/advancement.py

@@ -165,7 +165,12 @@ def do_practice(char: Character, args: str) -> str:
     if required_level is not None:
         if required_level >= LEVEL_IMMORTAL:
             return "You can't practice that."
-        if current <= 0 and char.level < required_level:
+        # PRACTICE-002: ROM src/act_info.c:2744-2757 gates on
+        # `ch->level < skill_table[sn].skill_level[class]` UNCONDITIONALLY (part of
+        # the "You can't practice that." OR) — a below-level character cannot
+        # practice a skill even when it is already known at >=1%. The old
+        # `current <= 0 and` qualifier let a known-but-too-high skill be practiced.
+        if char.level < required_level:
             return "You can't practice that."
 
     rating = _rating_for_class(skill, char.ch_class)

mud/commands/affects.py

@@ -147,8 +147,11 @@ def do_affects(char: Character, args: str) -> str:
         # Deduplication: check if same spell as previous affect
         if paf_last and paf.type == paf_last.type:
             if char.level >= 20:
-                # Level 20+: Show duplicate affects with indentation (22 spaces + ": ")
-                buf = " " * 22 + ": "
+                # AFFECTS-001: ROM src/act_info.c:1726 emits exactly 22 spaces (no
+                # colon) for a duplicate affect; the ": modifies …" detail block
+                # below supplies the single colon (matching "Spell: %-15s" width).
+                # The old `+ ": "` produced a double colon (": :").
+                buf = " " * 22
             else:
                 # Level <20: Skip duplicate spells entirely
                 continue

mud/commands/combat.py

@@ -25,6 +25,7 @@ from mud.models.constants import (
 )
 from mud.skills import skill_registry
 from mud.skills.say_spell import broadcast_spell_words
+from mud.skills.skill_lookup import get_skill
 from mud.utils import rng_mm
 from mud.utils.act import act_format, act_to_room
 from mud.world.vision import can_see_character
@@ -216,11 +217,10 @@ def do_kick(char: Character, args: str) -> str:
         cooldowns["kick"] = skill.cooldown
         char.cooldowns = cooldowns
     roll = rng_mm.number_percent()
-    try:
-        learned = getattr(char, "skills", {}).get("kick", 0)
-        chance = max(0, min(100, int(learned)))
-    except (TypeError, ValueError):
-        chance = 0
+    # FIGHT-091 / HANDLER-008: ROM do_kick rolls get_skill(ch, gsn_kick)
+    # (src/fight.c:3125) — NPC 10+3*level, PC class-gated learned, both
+    # daze/drunk-adjusted. Migrated from the inline NPC-formula workaround.
+    chance = get_skill(char, "kick")
     success = chance > roll
 
     message = skill_handlers.kick(char, opponent, success=success, roll=roll)
@@ -284,7 +284,10 @@ def do_rescue(char: Character, args: str) -> str:
     char.cooldowns = cooldowns
 
     roll = rng_mm.number_percent()
-    learned = _character_skill_percent(char, "rescue")
+    # HANDLER-008: ROM do_rescue rolls get_skill(ch, gsn_rescue) (src/fight.c:3082) —
+    # PC class-gated learned, NPC 40+level (was 0 via the dict → NPC rescue never
+    # worked), daze/drunk-adjusted.
+    learned = get_skill(char, "rescue")
     success = roll <= learned
 
     if not success:
@@ -1173,29 +1176,38 @@ def do_dirt(char: Character, args: str) -> str:
     return result
 
 
-def do_trip(char: Character, args: str) -> str:
+def do_trip(char: Character, args: str, *, victim: Character | None = None) -> str:
     """
     Trip opponent to knock them down.
 
     ROM Reference: src/fight.c do_trip (lines 2641-2760)
+
+    FIGHT-090: this is the single canonical trip implementation. The ``victim``
+    keyword lets the skill-registry ``trip`` handler (``skill_handlers.trip``)
+    delegate here with an explicit target instead of maintaining a divergent copy.
     """
     target_name = (args or "").strip()
 
-    # Check if character has the skill. ROM src/fight.c do_trip: NPCs gate on
-    # OFF_TRIP (no skills dict), PCs on the learned percent. For an NPC ROM's
-    # get_skill returns a nonzero value; mirror the do_kick/do_berserk NPC
-    # pattern and treat the skill as fully learned (100).
+    # Check if character has the skill. ROM src/fight.c:2649 do_trip: NPCs gate on
+    # OFF_TRIP (no skills dict), PCs on the learned percent. HANDLER-008: ROM's
+    # `chance = get_skill(ch, gsn_trip)` gives an OFF_TRIP NPC `10 + 3*level`
+    # (src/handler.c:373-432), NOT 100 — the old hardcode let a low-level mob trip
+    # far too often. The OFF_TRIP gate stays (get_skill's NPC dispatch returns 0
+    # without the flag, but the explicit gate mirrors ROM's IS_SET check + the ""
+    # silent return for descriptor-less mobs).
     if getattr(char, "is_npc", False):
         if not _npc_off_flags(char) & OffFlag.TRIP:
             return ""
-        skill_level = 100
+        skill_level = get_skill(char, "trip")
     else:
         skill_level = _character_skill_percent(char, "trip")
         if skill_level == 0:
             return "Tripping? What's that?"
 
-    # Find target
-    if not target_name:
+    # Find target (skip when an explicit victim is supplied via delegation).
+    if victim is not None:
+        pass
+    elif not target_name:
         victim = getattr(char, "fighting", None)
         if victim is None:
             return "But you aren't fighting anyone!"
@@ -1221,19 +1233,38 @@ def do_trip(char: Character, args: str) -> str:
     ):
         return "Kill stealing is not permitted."
 
-    # Can't trip flying targets
+    # Can't trip flying targets — ROM src/fight.c:2686 act("$S feet aren't on the
+    # ground.", ch, NULL, victim, TO_CHAR); $S = victim's possessive pronoun.
+    # FIGHT-090: was a baked "Their" here (the PERS render was only on
+    # skill_handlers.trip via TRIP-001); merged in so do_trip is canonical.
     victim_affected = getattr(victim, "affected_by", 0)
     if victim_affected & AffectFlag.FLYING:
-        return "Their feet aren't on the ground."
+        return act_format("$S feet aren't on the ground.", recipient=char, actor=char, arg2=victim)
 
-    # Can't trip someone already down
+    # Can't trip someone already down — ROM src/fight.c:2689 act("$N is already
+    # down.", …, TO_CHAR); $N = PERS(victim). FIGHT-090 (was baked "They are").
     victim_pos = getattr(victim, "position", Position.STANDING)
     if victim_pos < Position.FIGHTING:
-        return "They are already down."
+        return act_format("$N is already down.", recipient=char, actor=char, arg2=victim)
+
+    # FIGHT-082: ROM src/fight.c:2700/2742/2750 — do_trip WAIT_STATE uses the
+    # skill's RAW beats (skill_table[gsn_trip].beats == 24), not PULSE_VIOLENCE,
+    # with no HASTE/SLOW adjustment (read skill.beats directly, per CAST-010; the
+    # _compute_skill_lag haste/slow scaling is FIGHT-085's separate concern and
+    # must stay out of ROM WAIT_STATE sites).
+    _trip_skill = skill_registry.get("trip")
+    trip_beats = int(getattr(_trip_skill, "beats", 0) or 0)
 
     if victim is char:
-        skill_registry._apply_wait_state(char, get_pulse_violence() * 2)
-        return "You fall flat on your face!"
+        # ROM src/fight.c:2697-2703 (do_trip self-trip): colored TO_CHAR + a room
+        # broadcast ($n PERS-masked, $s possessive). FIGHT-090: the room line +
+        # {5..{x colour were on skill_handlers.trip (FIGHT-039) but not here — merged
+        # in so this path is the complete canonical implementation.
+        skill_registry._apply_wait_state(char, 2 * trip_beats)
+        self_room = getattr(char, "room", None)
+        if self_room is not None:
+            act_to_room(self_room, "{5$n trips over $s own feet!{x", char, exclude=char)
+        return "{5You fall flat on your face!{x"
 
     # FIGHT-071: ROM src/fight.c:2705-2709 — do_trip's charm gate, checked LAST
     # (after flying/position/self), with act("$N is your beloved master.", …).
@@ -1258,6 +1289,13 @@ def do_trip(char: Character, args: str) -> str:
     victim_dex = victim.get_curr_stat(Stat.DEX) or 0
     chance += char_dex - victim_dex * 3 // 2
 
+    # Speed modifier — ROM src/fight.c:2722-2726: attacker OFF_FAST/AFF_HASTE
+    # adds +10, victim OFF_FAST/AFF_HASTE subtracts 20.
+    if (_npc_off_flags(char) & OffFlag.FAST) or char.has_affect(AffectFlag.HASTE):
+        chance += 10
+    if (_npc_off_flags(victim) & OffFlag.FAST) or victim.has_affect(AffectFlag.HASTE):
+        chance -= 20
+
     # Level modifier
     char_level = skill_handlers._coerce_int(getattr(char, "level", 1))
     victim_level = skill_handlers._coerce_int(getattr(victim, "level", 1))
@@ -1265,19 +1303,44 @@ def do_trip(char: Character, args: str) -> str:
 
     # Roll
     if rng_mm.number_percent() < chance:
-        # Success
+        # Success — ROM src/fight.c:2735-2745.
+        # FIGHT-088: ROM emits three act() lines before the damage() call. TO_VICT is
+        # pushed to the victim, TO_NOTVICT broadcasts to the room ($M = victim's
+        # objective pronoun), TO_CHAR is this command's return value. Replaces a
+        # single baked f-string with no $N/$M render and no room broadcast.
+        from mud.utils.messaging import send_to_char_buffered as _send
+
+        _send(victim, act_format("{5$n trips you and you go down!{x", recipient=victim, actor=char, arg2=victim))
+        room = getattr(char, "room", None)
+        if room is not None:
+            act_to_room(room, "{5$n trips $N, sending $M to the ground.{x", char, arg2=victim, exclude=victim)
+
+        # DAZE_STATE(victim, 2 * PULSE_VIOLENCE) — the victim is DAZED, not WAIT'd.
+        victim.daze = max(int(getattr(victim, "daze", 0) or 0), 2 * get_pulse_violence())
+        # WAIT_STATE(ch, skill_table[gsn_trip].beats) — raw beats, not PULSE_VIOLENCE.
+        skill_registry._apply_wait_state(char, trip_beats)
         victim.position = Position.RESTING
-        skill_registry._apply_wait_state(char, get_pulse_violence())
-        skill_registry._apply_wait_state(victim, get_pulse_violence() * 2)
 
-        # Damage
-        damage_amt = rng_mm.number_range(2, 2 + 2 * victim_size + skill_level // 20)
-        apply_damage(char, victim, damage_amt, DamageType.BASH)
+        # Damage — ROM :2744 number_range(2, 2 + 2 * victim->size); no skill-level term.
+        # dt=gsn_trip so the dam_message renders the trip verb (ROM passes gsn_trip).
+        damage_amt = rng_mm.number_range(2, 2 + 2 * victim_size)
+        apply_damage(char, victim, damage_amt, DamageType.BASH, dt="trip")
 
-        message = f"You trip {getattr(victim, 'name', 'them')} and they go down!"
+        # ROM src/fight.c:2739 — check_improve(ch, gsn_trip, TRUE, 1). FIGHT-090:
+        # do_trip was missing check_improve entirely (it was only on the duplicate
+        # skill_handlers.trip); merged in so trip improvement works via the command.
+        skill_registry._check_improve(char, _trip_skill, "trip", True)
+        message = act_format("{5You trip $N and $N goes down!{x", recipient=char, actor=char, arg2=victim)
     else:
-        skill_registry._apply_wait_state(char, get_pulse_violence())
-        message = "You try to trip them but miss."
+        # FIGHT-088: ROM :2749 — the failure branch calls damage(ch, victim, 0,
+        # gsn_trip, DAM_BASH, TRUE) BEFORE the wait, delivering the miss dam_message
+        # and starting the fight (set_fighting). apply_damage returns the attacker's
+        # TO_CHAR line unpushed (single-delivery), so returning it is correct.
+        message = apply_damage(char, victim, 0, DamageType.BASH, dt="trip")
+        # ROM :2750 — WAIT_STATE(ch, skill_table[gsn_trip].beats * 2 / 3), after damage.
+        skill_registry._apply_wait_state(char, trip_beats * 2 // 3)
+        # ROM src/fight.c:2752 — check_improve(ch, gsn_trip, FALSE, 1). FIGHT-090.
+        skill_registry._check_improve(char, _trip_skill, "trip", False)
 
     check_killer(char, victim)  # mirroring ROM src/fight.c:2753 — unconditional
     return message

mud/commands/consumption.py

@@ -12,6 +12,7 @@ from mud.math.c_compat import c_div
 from mud.models.constants import AffectFlag, ItemType
 from mud.utils.act import act_to_room
 from mud.utils.rng_mm import number_fuzzy
+from mud.world.obj_find import get_obj_carry
 
 if TYPE_CHECKING:
     from mud.models.character import Character
@@ -36,8 +37,9 @@ def do_eat(ch: Character, args: str) -> str:
     if not args:
         return "Eat what?"
 
-    # Find object in inventory
-    obj = _find_obj_inventory(ch, args)
+    # Find object in inventory — ROM src/act_obj.c:1296 uses get_obj_carry, which
+    # parses the `N.name` count prefix and matches keywords (EAT-008).
+    obj = get_obj_carry(ch, args)
     if not obj:
         return "You do not have that item."
 
@@ -321,32 +323,6 @@ def do_drink(ch: Character, args: str) -> str:
     return "\n".join(messages)
 
 
-def _find_obj_inventory(ch: Character, name: str) -> Object | None:
-    """Find an object in character's inventory by name.
-
-    ROM Reference: src/handler.c get_obj_carry — searches `ch->carrying`.
-    QuickMUD stores the carrying list on `Character.inventory` (see
-    `mud/models/character.py:396`).
-    """
-    inventory = ch.inventory
-    if not inventory or not name:
-        return None
-
-    name_lower = name.lower()
-    for obj in inventory:
-        # Check short description
-        short_descr = getattr(obj, "short_descr", "")
-        if name_lower in short_descr.lower():
-            return obj
-
-        # Check name
-        obj_name = getattr(obj, "name", "")
-        if name_lower in obj_name.lower():
-            return obj
-
-    return None
-
-
 def _destroy_object(ch: Character, obj: Object) -> None:
     """Remove an object from character's inventory and destroy it.
 

mud/commands/doors.py

@@ -163,10 +163,13 @@ def do_open(char: Character, args: str) -> str:
 
         # Container
         if item_type == ItemType.CONTAINER:
-            if not (values[1] & ContainerFlag.CLOSEABLE):
-                return "You can't do that."
+            # MOVE-008: ROM do_open (src/act_move.c) checks CONT_CLOSED before
+            # CONT_CLOSEABLE, so an already-open non-closeable container reports
+            # "It's already open.", not "You can't do that."
             if not (values[1] & ContainerFlag.CLOSED):
                 return "It's already open."
+            if not (values[1] & ContainerFlag.CLOSEABLE):
+                return "You can't do that."
             if values[1] & ContainerFlag.LOCKED:
                 return "It's locked."
 
@@ -258,10 +261,13 @@ def do_close(char: Character, args: str) -> str:
 
         # Container
         if item_type == ItemType.CONTAINER:
-            if not (values[1] & ContainerFlag.CLOSEABLE):
-                return "You can't do that."
+            # MOVE-008: ROM do_close (src/act_move.c) checks CONT_CLOSED before
+            # CONT_CLOSEABLE, so an already-closed non-closeable container reports
+            # "It's already closed.", not "You can't do that."
             if values[1] & ContainerFlag.CLOSED:
                 return "It's already closed."
+            if not (values[1] & ContainerFlag.CLOSEABLE):
+                return "You can't do that."
 
             obj.value[1] = values[1] | ContainerFlag.CLOSED
             obj_name = getattr(obj, "short_descr", None) or getattr(obj, "name", "it")
@@ -655,9 +661,13 @@ def do_pick(char: Character, args: str) -> str:
     exit_info = getattr(pexit, "exit_info", 0)
     key_vnum = getattr(pexit, "key", 0)
 
-    # Immortal check (ROM C lines 958, 963, 973)
-    trust = getattr(char, "trust", 0)
-    is_immortal = trust >= 51  # LEVEL_HERO threshold
+    # Immortal check (ROM C lines 958, 963, 973): !IS_IMMORTAL(ch), where
+    # IS_IMMORTAL = get_trust(ch) >= LEVEL_IMMORTAL (=52, src/merc.h:149,2091)
+    # and get_trust falls back to ch->level when ch->trust is unset. The prior
+    # `trust >= 51` was wrong twice: 51 is LEVEL_HERO (a mortal), and reading raw
+    # `char.trust` skipped the level fallback (a level-52 immortal with trust 0
+    # was wrongly refused). Character.is_immortal() encodes both correctly.
+    is_immortal = char.is_immortal()
 
     if not (exit_info & EX_CLOSED) and not is_immortal:
         return "It's not closed."

mud/commands/equipment.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING
 from mud.handler import equip_char, unequip_char
 from mud.models.constants import ExtraFlag, ItemType, Position, WearFlag, WearLocation
 from mud.utils.act import act_to_room
+from mud.world.obj_find import get_obj_carry
 
 if TYPE_CHECKING:
     from mud.models.character import Character
@@ -155,8 +156,10 @@ def do_wear(ch: Character, args: str) -> str:
     if args.lower() == "all":
         return _wear_all(ch)
 
-    # Find object in inventory
-    obj = _find_obj_inventory(ch, args)
+    # Find object in inventory — ROM src/act_obj.c:1726 uses get_obj_carry, which
+    # parses the `N.name` count prefix and matches keywords (WEAR-010). wield/hold
+    # delegate to do_wear, so this covers all three.
+    obj = get_obj_carry(ch, args)
     if not obj:
         return "You do not have that item."
 
@@ -660,24 +663,3 @@ def _get_wear_location(obj: Object, wear_flags: int, ch: Character | None = None
         return WearLocation.FLOAT
 
     return None
-
-
-def _find_obj_inventory(ch: Character, name: str) -> Object | None:
-    """Find an object in character's inventory by name."""
-    inventory = getattr(ch, "inventory", [])
-    if not inventory or not name:
-        return None
-
-    name_lower = name.lower()
-    for obj in inventory:
-        # Check short description
-        short_descr = getattr(obj, "short_descr", "")
-        if name_lower in short_descr.lower():
-            return obj
-
-        # Check name
-        obj_name = getattr(obj, "name", "")
-        if name_lower in obj_name.lower():
-            return obj
-
-    return None