rom24-quickmud-python 2.14.268__tar.gz → 2.14.298__tar.gz

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/CHANGELOG.md

@@ -7,6 +7,246 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **Differential-harness scenarios `position_transitions`, `look_direction`,
+  `scan_directions`.** `position_transitions` locks the no-object arms of
+  do_stand/rest/sit/sleep/wake (POS_* state machine + message strings) against the
+  C oracle — converges first pass. `look_direction` locks `look <dir>`
+  exit-description + door open/closed rendering; it surfaced LOOK-012 (below) as a
+  real divergence and now guards it. `scan_directions` locks multi-depth `do_scan`
+  visibility + `distance[]` strings; it surfaced FINDING-042 (aura tags in scan).
+  `exits_listing` locks `do_exits`/autoexits closed-exit hiding + room-name
+  rendering across an open/close cycle — converges first pass, no divergence.
+  `where_command` locks `do_where` arg-search PERS + char_list-order match; it
+  surfaced FINDING-044 (wrong duplicate returned). `drink_liquid_messages`
+  (act_obj.c) locks `do_drink` liquid-name rendering + thirst-quenched message —
+  converges. `emote_command` (act_comm.c) locks `do_emote` incl. the "Moron!"
+  non-alpha-first-char quirk — converges. `look_at_character` locks
+  `show_char_to_char_1` (description + health + self-look pronoun); it surfaced
+  FINDING-045 (uncapitalized health line).
+
+### Changed
+
+- **Doc hygiene: reconciled stale OLC/JSON audit function-inventory rows.** The
+  Phase-1 summary tables in HEDIT / OLC_MPCODE / OLC_SAVE / JSON_LOADER audit
+  docs still marked ported functions `❌ MISSING` / `⚠️ PARTIAL`, contradicting
+  their own resolved detailed gap tables and the authoritative subsystem tracker.
+  Flipped to `✅ FIXED` / `N/A` after verifying each against the actual code and
+  ROM source (same stale-summary-header pattern fixed earlier for CONST/BAN/BIT).
+
+### Fixed
+
+- **PUT-005 — `put all <container>` with nothing eligible now silent (was a
+  non-ROM "You have nothing to put.").** ROM's put-all loop
+  (`src/act_obj.c:451-491`) has no such message.
+- **BASH-001 — `bash` delivered no flavor line to the attacker and dropped
+  message color.** ROM `do_bash` (`src/fight.c:2460-2482`) calls `damage(…, FALSE)`
+  on both branches — the dam_message is suppressed and the three `{5…{x` flavor
+  `act()` lines are the only output. The port sent only uncolored TO_VICT/TO_NOTVICT
+  and returned the (wrongly-emitted) dam_message, so the basher never saw "You
+  slam into X, and send X flying!" / "You fall flat on your face!" and broadcasts
+  were uncolored. Now renders all three lines via `act_format` with color, returns
+  the TO_CHAR flavor line (single-delivery via `apply_damage(show=False)`).
+- **TRIP-001 — `trip` without the skill dropped a space.** ROM
+  (`src/fight.c:2654`) sends "Tripping?  What's that?" with two spaces; the port
+  had one.
+- **KICK-001 — `kick` guard order: level gate now precedes the "not fighting"
+  check.** ROM `do_kick` (`src/fight.c:3109-3124`) checks the PC class-level gate
+  before `fighting == NULL`, so a sub-level PC not in combat sees "You better
+  leave the martial arts to fighters."; the port checked "not fighting" first and
+  showed the wrong message.
+- **LOOK-017 — room list omitted a standing PC's title.** ROM
+  `show_char_to_char_0` (`src/act_info.c:285-288`) appends `pcdata->title` after
+  the name for a standing PC (when the observer isn't brief and isn't on
+  furniture), so a titled PC lists as "Bob the Great is here." The port showed
+  just "Bob is here."
+- **LOOK-016 — `look <character>` never showed the target's worn equipment.**
+  The "X is using:" block was dead code: `_show_equipment` read a phantom
+  `char.equipped` attribute where the real one is `char.equipment`, so it always
+  saw an empty dict. Now mirrors ROM `show_char_to_char_1` (`src/act_info.c:483-499`):
+  ascending wear-slot order, visibility-gated, with `where_name` markers and
+  `format_obj_to_char` status tags (Glowing/Humming/aura). Equipment-key
+  convention bug (AGENTS.md school-light class) via a wrong attribute name.
+- **HEALER-007 — `heal` price-list header not first-letter-capitalized.** ROM
+  prints the header via `act("$N says 'I offer the following spells:'", ...)`,
+  and `act_new` capitalizes the rendered first letter (`src/healer.c:67`,
+  `src/comm.c:2379`). A healer with a lowercase-initial short_descr rendered
+  "a healer says ..." instead of ROM's "A healer says ...". Wrapped the header in
+  `capitalize_act_line`, matching the sibling "not enough gold" branch.
+- **PASSWORD-002 — `password` command message byte-fidelity.** The syntax line
+  dropped ROM's trailing period (`src/act_info.c:2889` → "Syntax: password <old>
+  <new>.") and the wrong-password penalty line had one space where ROM has two
+  (`src/act_info.c:2896` → "Wrong password.  Wait 10 seconds.").
+- **LOCK-002 — `lock`/`unlock` on a closed keyless container reported "It can't
+  be [un]locked." instead of ROM's "You lack the key."** ROM's container arms
+  (`src/act_move.c:637,773`) gate "can't be locked" on `value[2] < 0`; key vnum 0
+  (keyless) falls through to `has_key` → "You lack the key." The port used
+  `<= 0`, so 14 stock closed keyless containers gave the wrong message. The portal
+  sibling arm already uses `< 0`. (The unreachable door-branch twin is filed as
+  latent LOCK-003.)
+- **LOCK-001 — `lock`/`unlock` on an open non-closeable container reported "You
+  can't do that." instead of ROM's "It's not closed."** ROM's `do_lock`/`do_unlock`
+  container branches (`src/act_move.c:627-656,761-791`) have no `CONT_CLOSEABLE`
+  check — their first guard is `CONT_CLOSED`. The port inserted a spurious
+  closeable check (unlike `do_open`/`do_close`, which correctly have one — MOVE-008),
+  so 98 stock open non-closeable containers (belt pouches, packs, key rings) gave
+  the wrong message. Removed the guard to restore ROM's `CLOSED → key → has_key →
+  LOCKED` order.
+- **WEAR-015 — wear-flag dispatch order: armor slots now take precedence over
+  HOLD.** ROM `wear_obj` checks wear flags in bit order, so every armor/shield
+  slot (all bits below HOLD's `1<<14`) is dispatched before the HOLD branch. An
+  object flagged both an armor slot and HOLD is worn on the armor slot, not held.
+  Python checked the HOLD flag first and wrongly held such items. Guarded the
+  HOLD branch with a precedence mask. Unreachable in stock data (no stock object
+  combines the flags) but required for parity with custom areas the engine can
+  load.
+
+- **WEAR-014 — alignment "zap" now drops the item to the room (ROM equip_char).**
+  When an evil PC wears an ITEM_ANTI_EVIL object (or good+ANTI_GOOD /
+  neutral+ANTI_NEUTRAL), ROM (`src/handler.c:1765-1777`) emits a `$p`-named
+  TO_CHAR + TO_ROOM message and drops the item to the floor. Python returned a
+  generic "the item" message, emitted no room broadcast, and left the item in
+  inventory — an observable state divergence. Now the item is dropped to the
+  room with the object's short_descr and a room message. (Minor residual: ROM
+  prints the "You wear ..." line before the zap; Python emits only the zap line
+  — the item's resting state now matches.)
+
+- **WEAR-013 — two-handed-weapon wield block message punctuation.** ROM
+  `wear_obj` (`src/act_obj.c:1635`) ends the "shield worn, can't wield a
+  two-hander" message with a period: `"You need two hands free for that
+  weapon."`. Python ended it with `!`. Restored the period (the sibling
+  shield-branch `"...weapon!"` at :1606 correctly keeps its exclamation).
+
+- **RECALL-003 — `recall` command NPC gate now emits ROM's message and keys on
+  ACT_PET.** ROM `do_recall` (`src/act_move.c:1569-1573`) sends "Only players can
+  recall." for a non-pet NPC and gates on the `ACT_PET` flag. The dispatched
+  `do_recall` command returned `""` silently (with a comment wrongly claiming
+  "ROM returns silently") and gated on `master`, so the block message never
+  showed and a charmed non-pet mob could wrongly recall. (The `recall` *spell*
+  handler was already correct; only the command diverged.) Now returns the ROM
+  message and checks `ActFlag.PET`.
+
+- **INVEN-001 — `inventory` now shows object status tags and dedups correctly.**
+  ROM `show_list_to_char` (`src/act_info.c:166`) formats each carried item via
+  `format_obj_to_char`, prepending `(Invis)/(Red Aura)/(Blue Aura)/(Magical)/
+  (Glowing)/(Humming)`, and uses that prefixed string as the combine/dedup key.
+  Python built the string from bare `obj.short_descr`, so status prefixes were
+  dropped and — worse — a glowing item and a plain identical item wrongly
+  collapsed into one `( 2)` line for NPC/`combine` viewers. Both display paths
+  now route through `format_obj_to_char`. Same root cause as EQUIP-002.
+
+- **EQUIP-002 — `equipment` now shows object status tags.** ROM `do_equipment`
+  (`src/act_info.c:2279`) renders each worn item via `format_obj_to_char`, which
+  prepends `(Invis)/(Red Aura)/(Blue Aura)/(Magical)/(Glowing)/(Humming)` before
+  the short description. Python built the name from bare `obj.short_descr`, so a
+  glowing/humming/invisible-to-a-detecting-viewer worn item lost its status
+  prefix. A faithful `format_obj_to_char` already existed (`mud/utils/act.py`)
+  but wasn't wired in; `do_equipment` now routes through it.
+
+- **INTERP-035 — sleeping "snore" social exception now keys on the resolved
+  social.** ROM `check_social` (`src/interp.c:623`) allows a social while
+  sleeping via `!str_cmp(social_table[cmd].name, "snore")` — comparing the
+  *resolved* social's name. Python compared the *typed* argument, so a prefix
+  like `snor` (which resolves to the snore social, per INTERP-021 prefix lookup)
+  was wrongly blocked with "In your dreams, or what?" while asleep. Now compares
+  the resolved `social.name`. Refinement of INTERP-019.
+
+- **COMPARE-002 — `compare X Y` missing-second-item now uses ROM's exact message.**
+  ROM `do_compare` (`src/act_info.c:2338-2341`) emits `"You do not have that
+  item."` when the second item isn't carried — the identical string as the
+  missing-first-item branch. Python returned a distinct `"You do not have that
+  second item."`, a message ROM never produces. Now matches ROM.
+
+- **LOOK-015 — `look in <drink container>` fill band now matches ROM truncation.**
+  ROM `do_look` (`src/act_info.c:1141-1145`) picks the fill-level wording with
+  `value[1] < value[0]/4` ("less than half-") and `value[1] < 3*value[0]/4`
+  ("about half-"), else "more than half-". Python had rewritten this as
+  `value[1]*100//value[0]` compared to 25/75 — algebraically equal over reals,
+  but C truncates each expression independently so the labels diverge at
+  boundary amounts (e.g. a 10-unit container holding 2 shows "about half-" in
+  ROM but "less than half-" under the percent form; holding 7 shows "more than
+  half-" vs "about half-"). Now mirrors ROM's exact integer comparisons.
+
+- **SCORE-002 — `score` carry-weight line now includes coin burden.** ROM
+  `do_score` (`src/act_info.c:1517`) prints `get_carry_weight (ch) / 10`, and
+  `get_carry_weight` (`src/merc.h:2118`) adds coin weight
+  (`silver/10 + gold*2/5`) to the raw item weight — so a player carrying coins
+  shows a non-zero pounds figure. Python computed the pounds from bare
+  `ch.carry_weight`, so coins were invisible on the score sheet even though the
+  codebase already had two faithful `get_carry_weight` helpers. `do_score` now
+  calls `get_carry_weight(ch)`. Found by source-reading the `do_score` render
+  against ROM (same "audited function, field-render skipped the ROM accessor"
+  shape as LOOK-012/013/014).
+
+- **LOOK-014 — look-at-character health line now capitalized (FINDING-045).**
+  ROM `show_char_to_char_1` (`src/act_info.c:480`) does `buf[0] = UPPER(buf[0])`
+  on the health line, so `look <mob>` shows `"The beastly fido is in excellent
+  condition."`. Python `_look_char` didn't capitalize, rendering `"the beastly
+  fido ..."` (PCs unaffected — names are already capitalized). Now mirrors ROM.
+  Surfaced by the new `look_at_character` diff_harness scenario.
+
+- **`where <name>` now returns ROM's char_list-order match (FINDING-044).** ROM
+  `do_where` (`src/act_info.c:2445`) walks `char_list` head-first (newest-first,
+  because `create_mobile` head-inserts) and returns the first match. Python
+  iterated `character_registry` forward (oldest-first, since `spawn_mob`
+  appends), so with two same-named mobs in an area (e.g. Midgaard's two fidos)
+  `where fido` reported the wrong one. Now iterates `reversed(character_registry)`.
+  Surfaced by the new `where_command` diff_harness scenario.
+
+- **LOOK-013 — room-occupant fight line no longer leaks aura tags (FINDING-043).**
+  ROM `show_char_to_char_0` (`src/act_info.c:412`) renders a victim's fighting
+  target with bare `PERS`, no aura block. Python `_room_occupant_line` used
+  `describe_character`, so a room occupant fighting a sanctuary'd target showed
+  `"... fighting (White Aura) Target."` instead of `"... fighting Target."`. Now
+  uses `pers()`. Found by the call-site sweep that fixing FINDING-042 triggered
+  (same aura/PERS class); this was the last mis-rendered `describe_character` site.
+
+- **`scan` no longer prepends aura tags to characters (FINDING-042).** ROM
+  `scan_char` (`src/scan.c:133`) lists each visible character with bare
+  `PERS(victim, ch)` — name only, no `(Pink Aura)`/`(White Aura)` block. Python's
+  `do_scan` rendered via `describe_character`, so any aura'd target in scan range
+  (e.g. a sanctuary'd healer) showed a spurious aura tag. Now uses `pers()`.
+  Surfaced by the new `scan_directions` diff_harness scenario.
+
+- **LOOK-012 — `look <direction>` reported every door as "closed".** ROM
+  `do_look` (`src/act_info.c:1298-1309`) says "The <door> is open." for an open
+  keyword'd exit and "... is closed." for a closed one. `mud/world/look.py:_look_direction`
+  hardcoded the `EX_ISDOOR`/`EX_CLOSED` bits **swapped** (`ISDOOR=2, CLOSED=1`
+  vs ROM's `ISDOOR=1, CLOSED=2`), and since every door carries the ISDOOR bit,
+  the check was always true — so `look <dir>` always said "closed," even for open
+  doors. Now imports the canonical constants (AGENTS.md never-hardcode-bit-values
+  rule). Surfaced by the new `look_direction` diff_harness scenario. (FINDING-041)
+
+- **FIGHT-093 — `damage()` 1200-point loophole cap + weapon-extract cheat
+  penalty.** ROM `src/fight.c:697-713` clamps any physical hit (`dt >= TYPE_HIT`)
+  dealing more than 1200 raw damage back to 1200 (before the >35/>80 reduction)
+  and, for non-immortal attackers, sends "You really shouldn't cheat." and
+  extracts the wielded weapon. `mud/combat/engine.py:apply_damage` now mirrors
+  this. Spell hits (dt below TYPE_HIT) are exempt, matching ROM.
+- **MOVE-009 — `do_flee` now broadcasts "$n leaves"/"$n has arrived".** ROM
+  flees via `move_char` (`src/fight.c:3002`), which announces the fleer leaving
+  the old room and arriving in the new (`src/act_move.c:196-202`, suppressed when
+  sneaking/wizinvis). The Python inline flee move omitted both; bystanders now
+  see the fleer come and go. Remaining charmed-follower cascade filed as MOVE-010.
+- **MAGIC-046 (remainder) — `MobInstance.iter_carrying`.** `heat_metal` and any
+  mechanic mirroring ROM's `victim->carrying` walk now iterate a mob's items in
+  ROM LIFO order via a first-class `MobInstance.iter_carrying()`, instead of the
+  generic inventory+equipment fallback. Behaviorally identical (mobs already keep
+  worn+carried gear in one head-inserted list) but explicit and robust.
+- **MAGIC-050 — `dispel_magic` fixed spell-list order + per-effect room
+  messages.** Past the opening save, `dispel_magic` now walks ROM's hardcoded
+  spell list (`src/magic.c:2089-2251`) instead of the `spell_effects` dict,
+  broadcasting the TO_ROOM wear-off lines ("$n is no longer blinded.", fly →
+  "$n falls to the ground!", sanctuary aura, …), stripping a bare AFF_SANCTUARY
+  bit, and sending "Ok."/"Spell failed." to the caster — matching RNG draw order.
+- **LOOK-011 — room listings now show all 12 status tags.** ROM
+  `show_char_to_char_0` (`src/act_info.c:253-276`) prepends `[AFK]` `(Invis)`
+  `(Wizi)` `(Hide)` `(Charmed)` `(Translucent)` `(Pink Aura)` `(Red Aura)`
+  `(Golden Aura)` `(White Aura)` `(KILLER)` `(THIEF)` to each room occupant; the
+  port rendered only the two auras. All ten missing tags are now shown in ROM
+  order (Red/Golden gated on the observer's detect-evil/good + target alignment).
+
 ## [2.14.268] - 2026-07-05
 
 ### Changed (CI)

{rom24_quickmud_python-2.14.268/rom24_quickmud_python.egg-info → rom24_quickmud_python-2.14.298}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.14.268
+Version: 2.14.298
 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.14.268 → rom24_quickmud_python-2.14.298}/mud/combat/engine.py

@@ -688,6 +688,25 @@ def apply_damage(
     if victim.position == Position.DEAD:
         return "Already dead."
 
+    # FIGHT-093 — "Stop up any residual loopholes." (ROM src/fight.c:697-713).
+    # A physical hit (dt >= TYPE_HIT) dealing more than 1200 raw damage is clamped
+    # to 1200; a non-immortal attacker is penalized with "You really shouldn't
+    # cheat." and has their wielded weapon extracted from the game (extract_obj).
+    # This runs before the >35/>80 reduction, exactly as in ROM.
+    if damage > 1200 and _should_check_weapon_defenses(dt):
+        damage = 1200
+        is_imm = getattr(attacker, "is_immortal", None)
+        attacker_immortal = bool(is_imm()) if callable(is_imm) else False
+        if not attacker_immortal:
+            # mirroring ROM src/fight.c:707-711 — get_eq_char(ch, WEAR_WIELD) then
+            # send "You really shouldn't cheat." and extract_obj on the weapon.
+            weapon = get_wielded_weapon(attacker)
+            _push_message(attacker, "You really shouldn't cheat.")
+            if weapon is not None:
+                from mud.game_loop import _extract_obj
+
+                _extract_obj(weapon)
+
     # mirroring ROM src/fight.c:717-720 — damage soft-cap applied before all other
     # modifiers; reduces raw spikes to prevent instant-kill from single high-damage hits.
     if damage > 35:

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/character.py

@@ -38,7 +38,8 @@ def do_password(ch: Character, args: str) -> str:
     parts = args.split(None, 1)
 
     if len(parts) < 2:
-        return "Syntax: password <old> <new>"
+        # PASSWORD-002: ROM src/act_info.c:2889 — trailing period.
+        return "Syntax: password <old> <new>."
 
     old_password = parts[0]
     new_password = parts[1]
@@ -57,7 +58,8 @@ def do_password(ch: Character, args: str) -> str:
         # The macro is UMAX(ch->wait, 40); a plain `= 40` would lower a higher
         # existing wait. Use the canonical UMAX helper.
         apply_wait_state(ch, 40)
-        return "Wrong password. Wait 10 seconds."
+        # PASSWORD-002: ROM src/act_info.c:2896 — TWO spaces after "password.".
+        return "Wrong password.  Wait 10 seconds."
 
     # Gap 1 (P1): Check minimum length (ROM src/act_info.c:2897-2904)
     if len(new_password) < 5:

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/combat.py

@@ -11,6 +11,7 @@ from mud.models.character import Character
 from mud.models.constants import (
     AC_BASH,
     EX_CLOSED,
+    LEVEL_HERO,
     LEVEL_IMMORTAL,
     ActFlag,
     AffectFlag,
@@ -45,6 +46,9 @@ _FLEE_MOVEMENT_LOSS: dict[Sector, int] = {
     Sector.DESERT: 6,
 }
 
+# mirroring ROM src/act_move.c dir_name[] — indexed by door number (0..5).
+_FLEE_DIR_NAMES: tuple[str, ...] = ("north", "east", "south", "west", "up", "down")
+
 
 def _kill_safety_message(attacker: Character, victim: Character) -> str | None:
     # FIGHT-074: pure mirror of ROM's is_safe() (src/fight.c:1059) — which contains
@@ -171,10 +175,10 @@ def do_kill(char: Character, args: str) -> str:
 
 
 def do_kick(char: Character, args: str) -> str:
-    opponent = getattr(char, "fighting", None)
-    if opponent is None:
-        return "You aren't fighting anyone."
-
+    # KICK-001: ROM do_kick (src/fight.c:3109-3124) checks the PC level gate and
+    # NPC OFF_KICK gate BEFORE the `fighting == NULL` check, so a sub-level PC who
+    # is not fighting sees "You better leave the martial arts to fighters.", not
+    # "You aren't fighting anyone." The `fighting is None` check is relocated below.
     try:
         skill = skill_registry.get("kick")
     except KeyError:
@@ -204,6 +208,12 @@ def do_kick(char: Character, args: str) -> str:
         if required_level is not None and getattr(char, "level", 0) < required_level:
             return "You better leave the martial arts to fighters."
 
+    # KICK-001: ROM src/fight.c:3121-3124 — `fighting == NULL` check comes AFTER
+    # the level/OFF_KICK gates.
+    opponent = getattr(char, "fighting", None)
+    if opponent is None:
+        return "You aren't fighting anyone."
+
     if skill is not None:
         if int(getattr(char, "wait", 0) or 0) > 0:
             # INV-001 SINGLE-DELIVERY: return-channel only; a mailbox append would
@@ -815,8 +825,20 @@ def do_flee(char: Character, args: str) -> str:
                 continue  # too exhausted — mirrors move_char returning without moving
             flee_move_cost = cost
 
+        # MOVE-009: ROM src/fight.c:3002 flees via move_char(ch, door, FALSE),
+        # which broadcasts "$n leaves $T." to the fled-from room and "$n has
+        # arrived." to the destination (src/act_move.c:196-202) — suppressed for
+        # a sneaking or wizinvis fleer. The inline flee move omitted both.
+        show_movement = not (
+            char.has_affect(AffectFlag.SNEAK) or int(getattr(char, "invis_level", 0) or 0) >= LEVEL_HERO
+        )
+        dir_name = _FLEE_DIR_NAMES[door] if door < len(_FLEE_DIR_NAMES) else ""
+        if show_movement:
+            act_to_room(was_in, "$n leaves $T.", char, arg2=dir_name, exclude=char)
         was_in.remove_character(char)
         new_room.add_character(char)
+        if show_movement:
+            act_to_room(new_room, "$n has arrived.", char, exclude=char)
         now_in = new_room
         break
 
@@ -1202,7 +1224,8 @@ def do_trip(char: Character, args: str, *, victim: Character | None = None) -> s
     else:
         skill_level = _character_skill_percent(char, "trip")
         if skill_level == 0:
-            return "Tripping? What's that?"
+            # TRIP-001: ROM src/fight.c:2654 — TWO spaces after "Tripping?".
+            return "Tripping?  What's that?"
 
     # Find target (skip when an explicit victim is supplied via delegation).
     if victim is not None:

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/compare.py

@@ -38,7 +38,10 @@ def do_compare(char: Character, args: str) -> str:
         # Compare two items
         obj2 = get_obj_carry(char, parts[1])
         if obj2 is None:
-            return "You do not have that second item."
+            # COMPARE-002: ROM src/act_info.c:2338-2341 emits the SAME string as
+            # the missing-first-item branch (:2317) — not a distinct "second item"
+            # variant. The faithful port must reuse "You do not have that item.".
+            return "You do not have that item."
     else:
         # Compare against equipped item of same type
         obj2 = _find_equipped_match(char, obj1)

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/doors.py

@@ -378,11 +378,14 @@ def do_lock(char: Character, args: str) -> str:
 
         # Container (ROM C lines 627-656)
         if item_type == ItemType.CONTAINER:
-            if not (values[1] & ContainerFlag.CLOSEABLE):
-                return "You can't do that."
+            # LOCK-001: ROM do_lock's container arm has NO CONT_CLOSEABLE check
+            # (only do_open/do_close do — MOVE-008). Its first guard is CONT_CLOSED.
             if not (values[1] & ContainerFlag.CLOSED):
                 return "It's not closed."
-            if values[2] <= 0:  # No key defined
+            # LOCK-002: ROM src/act_move.c:637 gates on `value[2] < 0`. Key vnum 0
+            # (a keyless container) falls through to has_key → "You lack the key.",
+            # matching the portal sibling arm above (which already uses `< 0`).
+            if values[2] < 0:
                 return "It can't be locked."
             if not _has_key(char, values[2]):
                 return "You lack the key."
@@ -483,11 +486,12 @@ def do_unlock(char: Character, args: str) -> str:
 
         # Container (ROM C lines 761-791)
         if item_type == ItemType.CONTAINER:
-            if not (values[1] & ContainerFlag.CLOSEABLE):
-                return "You can't do that."
+            # LOCK-001: ROM do_unlock's container arm has NO CONT_CLOSEABLE check
+            # (only do_open/do_close do — MOVE-008). Its first guard is CONT_CLOSED.
             if not (values[1] & ContainerFlag.CLOSED):
                 return "It's not closed."
-            if values[2] <= 0:  # No key defined
+            # LOCK-002: ROM src/act_move.c:773 gates on `value[2] < 0` (see do_lock).
+            if values[2] < 0:
                 return "It can't be unlocked."
             if not _has_key(char, values[2]):
                 return "You lack the key."

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/equipment.py

@@ -18,6 +18,25 @@ if TYPE_CHECKING:
     from mud.models.object import Object
 
 
+# WEAR-015: wear-location flags checked BEFORE the HOLD branch in ROM `wear_obj`
+# (every bit below HOLD's 1<<14 except WIELD, which Python dispatches by
+# item_type). An object carrying any of these takes the armor/shield slot, not HOLD.
+_PRE_HOLD_WEAR_MASK = (
+    WearFlag.WEAR_FINGER
+    | WearFlag.WEAR_NECK
+    | WearFlag.WEAR_BODY
+    | WearFlag.WEAR_HEAD
+    | WearFlag.WEAR_LEGS
+    | WearFlag.WEAR_FEET
+    | WearFlag.WEAR_HANDS
+    | WearFlag.WEAR_ARMS
+    | WearFlag.WEAR_SHIELD
+    | WearFlag.WEAR_ABOUT
+    | WearFlag.WEAR_WAIST
+    | WearFlag.WEAR_WRIST
+)
+
+
 # ROM str_app wield column for STR 0..25.
 # Source: src/const.c:728 str_app[26], fourth field (wield).
 # Max wieldable weight = _STR_WIELD[STR] * 10 (ROM src/act_obj.c:1624-1625).
@@ -141,6 +160,35 @@ def _can_wear_alignment(ch: Character, obj: Object) -> tuple[bool, str | None]:
     return True, None
 
 
+def _zap_align(ch: Character, obj: Object) -> str:
+    """ROM `equip_char` alignment zap — WEAR-014 (src/handler.c:1765-1777).
+
+    When an evil PC dons an ITEM_ANTI_EVIL object (or good+ANTI_GOOD /
+    neutral+ANTI_NEUTRAL), ROM does NOT keep the item in inventory. `equip_char`
+    emits a TO_CHAR + TO_ROOM message using `$p` (the object's short_descr) and
+    drops the item to the floor (`obj_from_char` + `obj_to_room`). The prior
+    Python returned a generic "the item" message, emitted no room line, and left
+    the item CARRIED — a state divergence a player could observe (the item stays
+    in inventory instead of lying on the ground).
+
+    Residual: ROM prints the "You wear $p ..." line *before* the zap (the zap
+    lives in equip_char, called after the wear message). Python checks alignment
+    up-front, so it emits only the zap line — a minor cosmetic ordering residual;
+    the observable state (item on the floor) now matches ROM.
+    """
+    from mud.commands.obj_manipulation import _obj_from_char
+
+    obj_name = getattr(obj, "short_descr", None) or getattr(obj, "name", None) or "it"
+    room = getattr(ch, "room", None)
+    _obj_from_char(ch, obj)  # ROM obj_from_char (src/handler.c:1771)
+    if room is not None:
+        room.add_object(obj)  # ROM obj_to_room (src/handler.c:1772)
+        # ROM src/handler.c:1770 — act("$n is zapped by $p and drops it.", TO_ROOM)
+        act_to_room(room, "$n is zapped by $p and drops it.", ch, arg1=obj, exclude=ch)
+    # ROM src/handler.c:1769 — act("You are zapped by $p and drop it.", TO_CHAR)
+    return f"You are zapped by {obj_name} and drop it."
+
+
 def do_wear(ch: Character, args: str) -> str:
     """
     Wear equipment (armor, clothing, jewelry).
@@ -232,9 +280,9 @@ def _wear_obj(ch: Character, obj: Object, fReplace: bool = True) -> str:
                 return f"You can't remove {existing_name}."
 
         # Alignment zap (mirrors the HOLD/wear paths' _can_wear_alignment block).
-        can_wear, error_msg = _can_wear_alignment(ch, obj)
+        can_wear, _ = _can_wear_alignment(ch, obj)
         if not can_wear:
-            return error_msg or "You cannot hold that item."
+            return _zap_align(ch, obj)  # WEAR-014: drop to room per ROM equip_char
 
         if not equipment:
             ch.equipment = {}
@@ -258,8 +306,14 @@ def _wear_obj(ch: Character, obj: Object, fReplace: bool = True) -> str:
     # then performs the two-hand-weapon check. Implemented below after the
     # generic slot-remove (search "WEAR-009 SHIELD post-check").
 
-    # Check if item has HOLD flag - if so, use hold logic (ROM lines 1670-1677)
-    if wear_flags & WearFlag.HOLD:
+    # Check if item has HOLD flag - if so, use hold logic (ROM lines 1670-1677).
+    # WEAR-015: ROM `wear_obj` dispatches wear flags in bit order, so every
+    # armor/shield slot (WEAR_FINGER..WEAR_WRIST, WEAR_SHIELD — all bits below
+    # HOLD's 1<<14) is checked BEFORE the HOLD branch. Only fall to HOLD when the
+    # object has NO earlier wear-location flag; otherwise let `_get_wear_location`
+    # place it in the armor slot (matching ROM's precedence). WIELD (1<<13) is
+    # item_type-dispatched separately above, so it's excluded from this mask.
+    if (wear_flags & WearFlag.HOLD) and not (wear_flags & _PRE_HOLD_WEAR_MASK):
         # Check if hold slot is occupied
         equipment = getattr(ch, "equipment", {})
         hold_loc = int(WearLocation.HOLD)
@@ -274,9 +328,9 @@ def _wear_obj(ch: Character, obj: Object, fReplace: bool = True) -> str:
                 return f"You can't remove {existing_name}."
 
         # Check alignment restrictions
-        can_hold, error_msg = _can_wear_alignment(ch, obj)
+        can_hold, _ = _can_wear_alignment(ch, obj)
         if not can_hold:
-            return error_msg or "You cannot hold that item."
+            return _zap_align(ch, obj)  # WEAR-014: drop to room per ROM equip_char
 
         # Hold the item
         if not equipment:
@@ -348,11 +402,11 @@ def _wear_obj(ch: Character, obj: Object, fReplace: bool = True) -> str:
                     return "Your hands are tied up with your weapon!"
 
     # Check alignment restrictions (ROM src/handler.c:1765-1777)
-    can_wear, error_msg = _can_wear_alignment(ch, obj)
+    can_wear, _ = _can_wear_alignment(ch, obj)
     if not can_wear:
-        # In ROM, the zap happens in equip_char and item drops to room
-        # For now, just prevent wearing with error message
-        return error_msg or "You cannot wear that item."
+        # WEAR-014: ROM's zap (equip_char) drops the item to the room and emits
+        # a $p-substituted TO_CHAR + TO_ROOM message — not a generic in-inventory error.
+        return _zap_align(ch, obj)
 
     # Wear the item
     if not equipment:
@@ -423,9 +477,9 @@ def _dispatch_wield(ch: Character, obj: Object, fReplace: bool = True) -> str:
         if weight > _str_wield_max(str_stat):
             return "It is too heavy for you to wield."
 
-    can_wield, error_msg = _can_wear_alignment(ch, obj)
+    can_wield, _ = _can_wear_alignment(ch, obj)
     if not can_wield:
-        return error_msg or "You cannot wield that weapon."
+        return _zap_align(ch, obj)  # WEAR-014: drop to room per ROM equip_char
 
     # ROM src/act_obj.c:1631-1636 — two-hand vs shield check skipped for NPCs
     # and for characters of SIZE_LARGE or greater.
@@ -435,7 +489,9 @@ def _dispatch_wield(ch: Character, obj: Object, fReplace: bool = True) -> str:
         if weapon_flags[4] & WeaponFlag.TWO_HANDS:
             shield_loc = int(WearLocation.SHIELD)
             if shield_loc in equipment and equipment[shield_loc] is not None:
-                return "You need two hands free for that weapon!"
+                # WEAR-013: ROM src/act_obj.c:1635 ends this with a PERIOD, not a
+                # "!" (unlike the shield-branch "...weapon!" at :1606).
+                return "You need two hands free for that weapon."
 
     if not equipment:
         ch.equipment = {}

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/healer.py

@@ -240,7 +240,12 @@ def do_heal(char: Character, args: str = "") -> str:
 
     arg = (args or "").strip().lower()
     if not arg:
-        lines = [f"{_healer_name(healer)} says 'I offer the following spells:'"]
+        # HEALER-007: ROM src/healer.c:67 — act("$N says 'I offer the following
+        # spells:'", ...); act_new (src/comm.c:2379) capitalizes buf[0], so a
+        # lowercase-initial short_descr renders "A healer says ...". Match the
+        # sibling "not enough gold" branch (capitalize_act_line, INV-029/ACT-CAP).
+        header = capitalize_act_line(f"{_healer_name(healer)} says 'I offer the following spells:'")
+        lines = [header]
         lines.extend(service.display_line for service in _SERVICES)
         lines.append(" Type heal <type> to be healed.")
         return "\n".join(lines)

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/info.py

@@ -353,8 +353,13 @@ def do_where(char: Character, args: str) -> str:
 
         found = False
 
-        # ROM C iterates char_list for all characters (NPCs + players)
-        for victim in character_registry:
+        # ROM C iterates char_list from the head and returns the FIRST match
+        # (src/act_info.c:2445, with `break`). ROM head-inserts new chars into
+        # char_list (`create_mobile`, src/db.c:2256-2257), so a head-first walk is
+        # newest-first. Python `character_registry` is append-ordered (oldest
+        # first), so we iterate it reversed to reproduce ROM's newest-first match
+        # when several same-named mobs share an area (FINDING-044).
+        for victim in reversed(character_registry):
             victim_room = getattr(victim, "room", None)
             if not victim_room:
                 continue

{rom24_quickmud_python-2.14.268 → rom24_quickmud_python-2.14.298}/mud/commands/inspection.py

@@ -4,7 +4,7 @@ from mud.models.character import Character
 from mud.models.constants import Direction
 from mud.utils.act import act_to_room
 from mud.world.look import dir_names, look
-from mud.world.vision import can_see_character, describe_character
+from mud.world.vision import can_see_character, pers
 
 
 def do_scan(char: Character, args: str = "") -> str:
@@ -61,7 +61,11 @@ def do_scan(char: Character, args: str = "") -> str:
                 continue
             if not can_see_character(char, p):
                 continue
-            who = describe_character(char, p)
+            # ROM scan_char (src/scan.c:133) uses PERS(victim, ch) — the bare
+            # short_descr/name, NOT show_char_to_char aura tags. describe_character
+            # injects (Pink/White Aura) prefixes, which ROM's scan never shows
+            # (FINDING-042).
+            who = pers(p, char)
             if depth == 0:
                 lines.append(f"{who}, {distance[0]}")
             else: