rom24-quickmud-python 2.8.21__py3-none-any.whl → 2.9.2__py3-none-any.whl

mud/account/account_manager.py

@@ -57,10 +57,16 @@ def load_character(char_name: str, _ignored: str | None = None) -> Character | N
             return None
         char = from_orm(db_char)
         if char is not None:
-            # Use identity check to avoid triggering dataclass __eq__ on deep
-            # object graphs (inventory/equipment items cause recursion with list `in`)
-            if not any(c is char for c in character_registry):
-                character_registry.append(char)  # INV-003
+            # INV-009 REGISTRY-DISCONNECT-CLEANUP / dedup-by-name:
+            # ROM only ever has one player object by a given name in
+            # char_list. Drop any prior Character with the same name
+            # (e.g. the level=0 bare-row load during nanny name/password
+            # phase) before appending the freshly-loaded one. This
+            # complements INV-003 and prevents in-session duplicates
+            # surfacing through the promote-from-bare-row path.
+            for prior in [c for c in character_registry if getattr(c, "name", None) == char.name]:
+                character_registry.remove(prior)
+            character_registry.append(char)  # INV-003
         return char
     except Exception as e:
         print(f"[ERROR] Failed to load character {char_name} from DB: {e}")

mud/affects/engine.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from mud.models.character import Character
+from mud.utils import rng_mm
 
 ROM_NEWLINE = "\n\r"
 
@@ -24,6 +25,9 @@ def tick_spell_effects(character: Character) -> list[str]:
             duration = int(getattr(affect, "duration", 0) or 0)
             if duration > 0:
                 affect.duration = duration - 1
+                level = int(getattr(affect, "level", 0) or 0)
+                if level > 0 and rng_mm.number_range(0, 4) == 0:
+                    affect.level = level - 1  # mirroring ROM src/update.c:765-768
                 spell_name = getattr(affect, "type", None)
                 if isinstance(spell_name, str) and spell_name in effects:
                     touched_names.add(spell_name)

mud/ai/__init__.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 from collections.abc import Iterable
 
+import mud.mobprog as mobprog
 from mud.models.character import Character, character_registry
 from mud.models.constants import (
+    EX_CLOSED,
     ActFlag,
     AffectFlag,
     Direction,
@@ -13,18 +15,14 @@ from mud.models.constants import (
     Position,
     RoomFlag,
     WearFlag,
-    EX_CLOSED,
 )
-from mud.models.obj import ObjectData
+from mud.models.object import Object
 from mud.models.room import Exit, Room
-from mud.registry import room_registry
 from mud.utils import rng_mm
 from mud.world.movement import move_character
 
 from .aggressive import aggressive_update
 
-import mud.mobprog as mobprog
-
 __all__ = ["aggressive_update", "mobile_update"]
 
 
@@ -114,7 +112,7 @@ def _broadcast_room(room: Room, message: str, exclude: object | None = None) ->
             messages.append(message)
 
 
-def _can_loot(mob: Character, obj: ObjectData) -> bool:
+def _can_loot(mob: Character, obj: Object) -> bool:
     if getattr(mob, "is_admin", False):
         return True
     is_immortal = getattr(mob, "is_immortal", None)
@@ -150,7 +148,7 @@ def _can_loot(mob: Character, obj: ObjectData) -> bool:
     return False
 
 
-def _room_contents(room: Room | None) -> Iterable[ObjectData]:
+def _room_contents(room: Room | None) -> Iterable[Object]:
     if room is None:
         return []
     contents = getattr(room, "contents", None)
@@ -159,7 +157,7 @@ def _room_contents(room: Room | None) -> Iterable[ObjectData]:
     return []
 
 
-def _take_object(mob: Character, obj: ObjectData) -> None:
+def _take_object(mob: Character, obj: Object) -> None:
     room = getattr(obj, "in_room", None) or getattr(obj, "location", None) or getattr(mob, "room", None)
     if room is not None:
         contents = getattr(room, "contents", None)
@@ -201,7 +199,7 @@ def _maybe_scavenge(mob: Character, room: Room) -> None:
     if rng_mm.number_bits(6) != 0:
         return
 
-    best_obj: ObjectData | None = None
+    best_obj: Object | None = None
     best_cost = 1
     for obj in contents:
         wear_flags = int(getattr(obj, "wear_flags", 0) or 0)
@@ -300,8 +298,8 @@ def mobile_update() -> None:
             if gold * 100 + silver < wealth:
                 gold += wealth * rng_mm.number_range(1, 20) // 5_000_000
                 silver += wealth * rng_mm.number_range(1, 20) // 50_000
-                setattr(mob, "gold", gold)
-                setattr(mob, "silver", silver)
+                mob.gold = gold
+                mob.silver = silver
 
         default_pos_raw = getattr(mob, "default_pos", getattr(mob, "position", Position.STANDING))
         try:

mud/combat/death.py

@@ -438,7 +438,9 @@ def make_corpse(victim: Character) -> Object | None:
         money_obj = create_money(gold, silver)
         if money_obj:
             corpse.contained_items.append(money_obj)
-            money_obj.location = None  # Inside corpse, not in room
+            # ROM src/handler.c:1968 obj_to_obj — money lives inside corpse,
+            # so in_obj=corpse, in_room=None, carried_by=None.
+            money_obj.location = corpse
 
     victim.gold = 0
     victim.silver = 0

mud/combat/engine.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-from types import SimpleNamespace
 
 from mud import mobprog
 from mud.account.account_manager import save_character
@@ -38,9 +37,8 @@ from mud.models.constants import (
     WearFlag,
     attack_damage_type,
 )
-from mud.models.weapon_table import weapon_skill_name_for_type
 from mud.models.social import expand_placeholders
-from mud.net.protocol import broadcast_room as _broadcast_room
+from mud.models.weapon_table import weapon_skill_name_for_type
 from mud.skills import check_improve
 from mud.utils import rng_mm
 from mud.wiznet import WiznetFlag, wiznet
@@ -227,19 +225,35 @@ def _push_message(character: Character | None, message: str) -> None:
         mailbox.append(message)
 
 
-def _dispatch_damage_messages(
+def _broadcast_damage_messages(
     attacker: Character,
     victim: Character,
     messages: DamageMessages | None,
 ) -> None:
+    """Render `dam_message` templates per-recipient through ROM PERS.
+
+    Mirrors ROM `src/fight.c:2218-2228` — three `act()` calls
+    (TO_NOTVICT/TO_CHAR/TO_VICT) each evaluate `PERS(ch, looker)`
+    and `PERS(victim, looker)` independently for each observer.
+    Python previously emitted pre-rendered strings keyed on
+    `attacker.name`/`victim.name`, leaking identities to every
+    recipient regardless of `can_see` (DAMMSG-001/002/003).
+    """
+    from mud.combat.messages import render_for as _render
+
     if messages is None:
         return
 
     if messages.attacker:
-        _push_message(attacker, messages.attacker)
+        # TO_CHAR — render with observer=attacker (attacker sees own
+        # actor as "You" in template; $N renders victim through
+        # PERS(victim, attacker)).
+        _push_message(attacker, _render(messages.attacker, attacker, victim, attacker) or "")
 
     if not messages.self_inflicted and messages.victim:
-        _push_message(victim, messages.victim)
+        # TO_VICT — render with observer=victim (victim sees $n
+        # attacker through PERS(attacker, victim)).
+        _push_message(victim, _render(messages.victim, attacker, victim, victim) or "")
 
     if not messages.room:
         return
@@ -248,14 +262,17 @@ def _dispatch_damage_messages(
     if room is None:
         return
 
-    if messages.self_inflicted:
-        _broadcast_room(room, messages.room, exclude=victim)
-        return
-
-    for occupant in getattr(room, "people", []):
+    # TO_NOTVICT — iterate room.people and PERS-render per recipient
+    # so each observer sees attacker/victim per their own visibility.
+    for occupant in list(getattr(room, "people", [])):
         if occupant is attacker or occupant is victim:
             continue
-        _push_message(occupant, messages.room)
+        _push_message(occupant, _render(messages.room, attacker, victim, occupant) or "")
+
+
+# Back-compat alias — the old name is referenced in older session
+# notes and some test files. Both names invoke the same logic.
+_dispatch_damage_messages = _broadcast_damage_messages
 
 
 def get_weapon_skill(attacker: Character, weapon_sn: str | None) -> int:
@@ -310,13 +327,6 @@ def multi_hit(attacker: Character, victim: Character, dt: str | int | None = Non
     """
     results: list[str] = []
 
-    # ROM src/fight.c:192-196 decrements wait/daze for descriptor-less characters
-    # PULSE_VIOLENCE is typically 3 in ROM
-    PULSE_VIOLENCE = 3
-    if not hasattr(attacker, "desc") or attacker.desc is None:
-        attacker.wait = max(0, getattr(attacker, "wait", 0) - PULSE_VIOLENCE)
-        attacker.daze = max(0, getattr(attacker, "daze", 0) - PULSE_VIOLENCE)
-
     # Position check - no attacks if position too low
     if attacker.position < Position.RESTING:
         return results
@@ -582,7 +592,8 @@ def apply_damage(
 
     if damage <= 0:
         if message_bundle and message_bundle.attacker:
-            return message_bundle.attacker
+            from mud.combat.messages import render_for as _render
+            return _render(message_bundle.attacker, attacker, victim, attacker) or ""
         return "Your attack has no effect."
 
     # Apply damage
@@ -624,7 +635,8 @@ def apply_damage(
         return message
 
     if message_bundle and message_bundle.attacker:
-        return message_bundle.attacker
+        from mud.combat.messages import render_for as _render
+        return _render(message_bundle.attacker, attacker, victim, attacker) or ""
     return ""
 
 
@@ -698,36 +710,91 @@ def is_awake(character: Character) -> bool:
     return character.position > Position.SLEEPING
 
 
+def _broadcast_pos_change(victim: Character, template: str, **extra: object) -> None:
+    """Render `$n`-style room broadcasts per-listener via ROM PERS.
+
+    Mirrors ROM's `act(..., TO_ROOM)` macro, which evaluates
+    ``PERS(victim, looker)`` once per recipient (see src/comm.c:act_new
+    around the `$n` case). Each room observer gets its own substituted
+    message, so an invisible victim renders as "someone" to anyone
+    without DETECT_INVIS — matches the channel-arc fix pattern
+    (mud/world/vision.py:pers).
+
+    `template` must contain a `{name}` placeholder for the
+    PERS-rendered victim name; any additional substitutions (e.g.
+    `{weapon}` for ROM `$p`) come from `**extra`. Weapons are not
+    `can_see`-gated, so they pass through verbatim.
+    """
+    from mud.net.protocol import send_to_char as _send
+    from mud.world.vision import pers
+
+    room = getattr(victim, "room", None)
+    if room is None:
+        return
+    for listener in list(getattr(room, "people", [])):
+        if listener is victim:
+            continue
+        message = template.format(name=pers(victim, listener), **extra)
+        writer = getattr(listener, "connection", None)
+        if writer is not None:
+            asyncio.create_task(_send(listener, message))
+        if hasattr(listener, "messages"):
+            listener.messages.append(message)
+
+
 def _position_change_message(victim: Character, old_pos: Position) -> str:
     """Generate position change message following ROM logic."""
     if victim.position == Position.MORTAL:
+        # mirroring ROM src/fight.c:837-838 — `act("$n is mortally
+        # wounded, and will die soon, if not aided.", victim, NULL,
+        # NULL, TO_ROOM)`. The act() macro renders `$n` per-listener
+        # through PERS(victim, looker), so an invisible victim
+        # appears as "someone" to room observers without
+        # DETECT_INVIS (FIGHT-004). Each recipient gets its own
+        # substituted string — `_broadcast_room` with a baked
+        # f-string would leak the victim's name.
         if hasattr(victim, "room") and victim.room is not None:
-            _broadcast_room(
-                victim.room,
-                f"{victim.name} is mortally wounded, and will die soon, if not aided.",
-                exclude=victim,
+            _broadcast_pos_change(
+                victim,
+                "{name} is mortally wounded, and will die soon, if not aided.",
             )
         return "You are mortally wounded, and will die soon, if not aided."
     elif victim.position == Position.INCAP:
+        # mirroring ROM src/fight.c:845-846 — `act("$n is incapacitated
+        # and will slowly die, if not aided.", victim, NULL, NULL,
+        # TO_ROOM)`. PERS substitution per-listener (FIGHT-005).
         if hasattr(victim, "room") and victim.room is not None:
-            _broadcast_room(
-                victim.room,
-                f"{victim.name} is incapacitated and will slowly die, if not aided.",
-                exclude=victim,
+            _broadcast_pos_change(
+                victim,
+                "{name} is incapacitated and will slowly die, if not aided.",
             )
         return "You are incapacitated and will slowly die, if not aided."
     elif victim.position == Position.STUNNED:
+        # mirroring ROM src/fight.c:853-854 — `act("$n is stunned, but
+        # will probably recover.", victim, NULL, NULL, TO_ROOM)`. PERS
+        # substitution per-listener (FIGHT-006).
         if hasattr(victim, "room") and victim.room is not None:
-            _broadcast_room(
-                victim.room,
-                f"{victim.name} is stunned, but will probably recover.",
-                exclude=victim,
+            _broadcast_pos_change(
+                victim,
+                "{name} is stunned, but will probably recover.",
             )
         return "You are stunned, but will probably recover."
     elif victim.position == Position.DEAD:
+        # mirroring ROM src/fight.c:860 — `act("{R$n is DEAD!!{x",
+        # victim, 0, 0, TO_ROOM)`. PERS substitution per-listener
+        # (FIGHT-007), wrapped in ROM red colour codes ({R...{x) the
+        # ANSI translation layer consumes on websocket send, and ROM
+        # uses exactly two exclamation marks (not three).
         if hasattr(victim, "room") and victim.room is not None:
-            _broadcast_room(victim.room, f"{victim.name} is DEAD!!!", exclude=victim)
-        return "You have been KILLED!!"
+            _broadcast_pos_change(victim, "{{R{name} is DEAD!!{{x")
+        # mirroring ROM src/fight.c:861 — `send_to_char("{RYou have
+        # been KILLED!!{x\n\r\n\r", victim)`. ROM's two trailing
+        # \n\r pairs render as the death notice + one blank line.
+        # Python's protocol layer auto-appends one \r\n to every
+        # message, so the embedded trailing \n here gives the blank
+        # line on the wire (FIGHT-008). Red colour wrap {R...{x is
+        # consumed by mud/net/ansi.py on websocket send.
+        return "{RYou have been KILLED!!{x\n"
     return ""
 
 
@@ -898,10 +965,18 @@ def _auto_sacrifice(attacker: Character, corpse) -> None:
         _push_message(attacker, f"Mota gives you {silver_reward} silver coins for your sacrifice.")
 
     corpse_name = getattr(corpse, "short_descr", None) or getattr(corpse, "name", "") or "corpse"
-    _broadcast_room(
-        room,
-        expand_placeholders("$n sacrifices $N to Mota.", attacker, SimpleNamespace(name=corpse_name)),
-        exclude=attacker,
+    # mirroring ROM src/act_obj.c:1856 dispatched from
+    # src/fight.c:961-970 — `act("$n sacrifices $p to Mota.", ch,
+    # obj, NULL, TO_ROOM)`. PERS substitution on $n (attacker)
+    # per-listener (FIGHT-014). The helper's first arg is named
+    # `victim` for historical reasons but the function just
+    # PERS-renders that character for each room observer — works
+    # equally for an attacker. Corpse name passes through verbatim
+    # ($p is not can_see-gated).
+    _broadcast_pos_change(
+        attacker,
+        "{name} sacrifices {corpse} to Mota.",
+        corpse=corpse_name,
     )
     wiznet(
         "$N sends up $p as a burnt offering.",
@@ -1493,10 +1568,15 @@ def process_weapon_special_attacks(attacker: Character, victim: Character) -> li
         if not saves_spell(level // 2, victim, DamageType.POISON):
             _push_message(victim, "You feel poison coursing through your veins.")
             if room is not None:
-                _broadcast_room(
-                    room,
-                    f"{victim.name} is poisoned by the venom on {weapon_name}.",
-                    exclude=victim,
+                # mirroring ROM src/fight.c:614-615 — `act("$n is
+                # poisoned by the venom on $p.", victim, wield, NULL,
+                # TO_ROOM)`. PERS substitution on $n per-listener
+                # (FIGHT-009). Weapon name passes verbatim ($p is not
+                # can_see-gated).
+                _broadcast_pos_change(
+                    victim,
+                    "{name} is poisoned by the venom on {weapon}.",
+                    weapon=weapon_name,
                 )
             if hasattr(victim, "add_affect"):
                 victim.add_affect(AffectFlag.POISON)
@@ -1507,7 +1587,14 @@ def process_weapon_special_attacks(attacker: Character, victim: Character) -> li
         dam = rng_mm.number_range(1, weapon_level // 5 + 1)
         _push_message(victim, f"You feel {weapon_name} drawing your life away.")
         if room is not None:
-            _broadcast_room(room, f"{weapon_name} draws life from {victim.name}.", exclude=victim)
+            # mirroring ROM src/fight.c:643 — `act("$p draws life
+            # from $n.", victim, wield, NULL, TO_ROOM)`. PERS on $n
+            # per-listener (FIGHT-010).
+            _broadcast_pos_change(
+                victim,
+                "{weapon} draws life from {name}.",
+                weapon=weapon_name,
+            )
 
         # Apply vampiric damage (additional negative damage) without extra messages
         apply_damage(attacker, victim, dam, DamageType.NEGATIVE, show=False)
@@ -1528,7 +1615,14 @@ def process_weapon_special_attacks(attacker: Character, victim: Character) -> li
         dam = rng_mm.number_range(1, weapon_level // 4 + 1)
         _push_message(victim, f"{weapon_name} sears your flesh.")
         if room is not None:
-            _broadcast_room(room, f"{victim.name} is burned by {weapon_name}.", exclude=victim)
+            # mirroring ROM src/fight.c:654 — `act("$n is burned by
+            # $p.", victim, wield, NULL, TO_ROOM)`. PERS on $n
+            # per-listener (FIGHT-011).
+            _broadcast_pos_change(
+                victim,
+                "{name} is burned by {weapon}.",
+                weapon=weapon_name,
+            )
         fire_effect(victim, weapon_level // 2, dam, SpellTarget.CHAR)
         apply_damage(attacker, victim, dam, DamageType.FIRE, show=False)
         messages.append(f"{weapon_name} sears your flesh.")
@@ -1538,7 +1632,17 @@ def process_weapon_special_attacks(attacker: Character, victim: Character) -> li
         dam = rng_mm.number_range(1, weapon_level // 6 + 2)
         _push_message(victim, "The cold touch surrounds you with ice.")
         if room is not None:
-            _broadcast_room(room, f"{victim.name} is frozen by {weapon_name}.", exclude=victim)
+            # mirroring ROM src/fight.c:663 — `act("$p freezes $n.",
+            # victim, wield, NULL, TO_ROOM)`. ROM places the weapon
+            # ($p) first and the victim ($n) as the object of
+            # "freezes" — Python previously emitted "X is frozen by Y"
+            # which inverts the subject/object (FIGHT-012). Fix both
+            # the PERS gap and the wording in one pass.
+            _broadcast_pos_change(
+                victim,
+                "{weapon} freezes {name}.",
+                weapon=weapon_name,
+            )
         cold_effect(victim, weapon_level // 2, dam, SpellTarget.CHAR)
         apply_damage(attacker, victim, dam, DamageType.COLD, show=False)
         messages.append("The cold touch surrounds you with ice.")
@@ -1548,10 +1652,13 @@ def process_weapon_special_attacks(attacker: Character, victim: Character) -> li
         dam = rng_mm.number_range(1, weapon_level // 5 + 2)
         _push_message(victim, "You are shocked by the weapon.")
         if room is not None:
-            _broadcast_room(
-                room,
-                f"{victim.name} is struck by lightning from {weapon_name}.",
-                exclude=victim,
+            # mirroring ROM src/fight.c:673-674 — `act("$n is struck
+            # by lightning from $p.", victim, wield, NULL, TO_ROOM)`.
+            # PERS on $n per-listener (FIGHT-013).
+            _broadcast_pos_change(
+                victim,
+                "{name} is struck by lightning from {weapon}.",
+                weapon=weapon_name,
             )
         shock_effect(victim, weapon_level // 2, dam, SpellTarget.CHAR)
         apply_damage(attacker, victim, dam, DamageType.LIGHTNING, show=False)

mud/combat/messages.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 
 from mud.math.c_compat import c_div
 from mud.models.constants import ATTACK_TABLE, DamageType, Sex
+from mud.world.vision import pers
 
 TYPE_HIT = 1000
 MAX_DAMAGE_MESSAGE = len(ATTACK_TABLE)
@@ -13,7 +14,19 @@ MAX_DAMAGE_MESSAGE = len(ATTACK_TABLE)
 
 @dataclass(frozen=True)
 class DamageMessages:
-    """Container for ROM-style attacker/victim/room combat strings."""
+    """Container for ROM-style attacker/victim/room combat templates.
+
+    Each field is a `.format()`-ready template containing `{attacker}`
+    and/or `{victim}` placeholders. Use `render_for(template,
+    attacker, victim, observer)` to substitute ROM `PERS()`-rendered
+    names per recipient — mirrors ROM's `act()` macro which evaluates
+    `PERS(ch, looker)` and `PERS(victim, looker)` independently for
+    each observer (DAMMSG-001/002/003).
+
+    ROM colour codes `{3...{x` / `{2...{x` / `{4...{x` are escaped as
+    `{{3}}` etc. in the template literals so `str.format()` leaves
+    them intact for the ANSI translation layer.
+    """
 
     attacker: str | None
     victim: str | None
@@ -21,6 +34,28 @@ class DamageMessages:
     self_inflicted: bool = False
 
 
+def render_for(
+    template: str | None,
+    attacker: object,
+    victim: object,
+    observer: object | None,
+) -> str | None:
+    """Substitute `{attacker}` / `{victim}` placeholders through PERS.
+
+    Mirrors ROM's `act()` macro — `$n` resolves through `PERS(ch,
+    looker)` and `$N` through `PERS(victim, looker)`. The observer
+    is the recipient of the message; for TO_NOTVICT this is iterated
+    per room occupant, for TO_CHAR this is the attacker, for TO_VICT
+    this is the victim.
+    """
+    if template is None:
+        return None
+    return template.format(
+        attacker=pers(attacker, observer),
+        victim=pers(victim, observer),
+    )
+
+
 # Severity tiers mirror src/fight.c:dam_message percent thresholds.
 _DAMAGE_TIERS: tuple[tuple[int, str, str], ...] = (
     (5, "scratch", "scratches"),
@@ -45,13 +80,6 @@ _DAMAGE_TIERS: tuple[tuple[int, str, str], ...] = (
 )
 
 
-def _safe_name(character: object) -> str:
-    name = getattr(character, "name", None)
-    if not name:
-        return "Someone"
-    return str(name)
-
-
 def _reflexive_pronoun(character: object) -> str:
     try:
         sex = Sex(getattr(character, "sex", Sex.NONE))
@@ -127,56 +155,64 @@ def dam_message(
     vs, vp, percent = _severity_terms(max(0, int(damage)), victim)
     punct = "." if percent <= 45 else "!"
 
-    attacker_name = _safe_name(attacker)
-    victim_name = _safe_name(victim)
     attack = _resolve_attack_noun(dt)
     self_inflicted = attacker is victim
 
     if attack is None and immune:
         attack = "attack"
 
+    # Templates use `{{attacker}}` / `{{victim}}` placeholders that
+    # `render_for()` substitutes per-recipient through ROM PERS().
+    # ROM colour codes (`{3...{x` etc.) are doubled so str.format()
+    # leaves them intact (DAMMSG-001/002/003).
     if int(percent) <= 0 and not immune:
         # Mirror ROM miss output
         if self_inflicted:
-            room_msg = f"{{3{attacker_name} {vp} {_reflexive_pronoun(attacker)}{punct}{{x"
-            attacker_msg = f"{{2You {vs} yourself{punct}{{x"
+            room_msg = "{{3{attacker} " + vp + " " + _reflexive_pronoun(attacker) + punct + "{{x"
+            attacker_msg = "{{2You " + vs + " yourself" + punct + "{{x"
             return DamageMessages(attacker_msg, None, room_msg, True)
-        room_msg = f"{{3{attacker_name} {vp} {victim_name}{punct}{{x"
-        attacker_msg = f"{{2You {vs} {victim_name}{punct}{{x"
-        victim_msg = f"{{4{attacker_name} {vp} you{punct}{{x"
+        room_msg = "{{3{attacker} " + vp + " {victim}" + punct + "{{x"
+        attacker_msg = "{{2You " + vs + " {victim}" + punct + "{{x"
+        victim_msg = "{{4{attacker} " + vp + " you" + punct + "{{x"
         return DamageMessages(attacker_msg, victim_msg, room_msg, False)
 
     if immune:
         if self_inflicted:
             poss = _possessive_pronoun(attacker)
-            room_msg = f"{{3{attacker_name} is unaffected by {poss} own {attack}.{{x"
-            attacker_msg = "{2Luckily, you are immune to that.{x"
+            room_msg = "{{3{attacker} is unaffected by " + poss + " own " + attack + ".{{x"
+            attacker_msg = "{{2Luckily, you are immune to that.{{x"
             return DamageMessages(attacker_msg, None, room_msg, True)
-        room_msg = f"{{3{victim_name} is unaffected by {attacker_name}'s {attack}!{{x"
-        attacker_msg = f"{{2{victim_name} is unaffected by your {attack}!{{x"
-        victim_msg = f"{{4{attacker_name}'s {attack} is powerless against you.{{x"
+        room_msg = "{{3{victim} is unaffected by {attacker}'s " + attack + "!{{x"
+        attacker_msg = "{{2{victim} is unaffected by your " + attack + "!{{x"
+        victim_msg = "{{4{attacker}'s " + attack + " is powerless against you.{{x"
         return DamageMessages(attacker_msg, victim_msg, room_msg, False)
 
     if attack is None:
         if self_inflicted:
-            room_msg = f"{{3{attacker_name} {vp} {_reflexive_pronoun(attacker)}{punct}{{x"
-            attacker_msg = f"{{2You {vs} yourself{punct}{{x"
+            room_msg = "{{3{attacker} " + vp + " " + _reflexive_pronoun(attacker) + punct + "{{x"
+            attacker_msg = "{{2You " + vs + " yourself" + punct + "{{x"
             return DamageMessages(attacker_msg, None, room_msg, True)
-        room_msg = f"{{3{attacker_name} {vp} {victim_name}{punct}{{x"
-        attacker_msg = f"{{2You {vs} {victim_name}{punct}{{x"
-        victim_msg = f"{{4{attacker_name} {vp} you{punct}{{x"
+        room_msg = "{{3{attacker} " + vp + " {victim}" + punct + "{{x"
+        attacker_msg = "{{2You " + vs + " {victim}" + punct + "{{x"
+        victim_msg = "{{4{attacker} " + vp + " you" + punct + "{{x"
         return DamageMessages(attacker_msg, victim_msg, room_msg, False)
 
     if self_inflicted:
         poss = _possessive_pronoun(attacker)
-        room_msg = f"{{3{attacker_name}'s {attack} {vp} {_reflexive_pronoun(attacker)}{punct}{{x"
-        attacker_msg = f"{{2Your {attack} {vp} you{punct}{{x"
+        room_msg = "{{3{attacker}'s " + attack + " " + vp + " " + _reflexive_pronoun(attacker) + punct + "{{x"
+        attacker_msg = "{{2Your " + attack + " " + vp + " you" + punct + "{{x"
         return DamageMessages(attacker_msg, None, room_msg, True)
 
-    room_msg = f"{{3{attacker_name}'s {attack} {vp} {victim_name}{punct}{{x"
-    attacker_msg = f"{{2Your {attack} {vp} {victim_name}{punct}{{x"
-    victim_msg = f"{{4{attacker_name}'s {attack} {vp} you{punct}{{x"
+    room_msg = "{{3{attacker}'s " + attack + " " + vp + " {victim}" + punct + "{{x"
+    attacker_msg = "{{2Your " + attack + " " + vp + " {victim}" + punct + "{{x"
+    victim_msg = "{{4{attacker}'s " + attack + " " + vp + " you" + punct + "{{x"
     return DamageMessages(attacker_msg, victim_msg, room_msg, False)
 
 
-__all__: tuple[str, ...] = ("DamageMessages", "TYPE_HIT", "MAX_DAMAGE_MESSAGE", "dam_message")
+__all__: tuple[str, ...] = (
+    "DamageMessages",
+    "TYPE_HIT",
+    "MAX_DAMAGE_MESSAGE",
+    "dam_message",
+    "render_for",
+)

mud/commands/advancement.py

@@ -307,20 +307,26 @@ def do_train(char: Character, args: str) -> str:
         # Show available training options (ROM C lines 1713-1745)
         options = ["You can train:"]
 
-        # Check which stats can be trained (ROM C lines 1716-1725)
-        # get_max_train returns race_max + 4 (ROM C src/handler.c:3027)
-        # For now, use 18 + 4 = 22 as max (ROM standard)
+        # Check which stats can be trained (ROM C src/act_move.c:1716-1725).
+        # ROM reads `ch->perm_stat[STAT_*]`; QuickMUD stores the same list at
+        # `char.perm_stat`. There are no `perm_str`/`perm_int`/… attributes.
+        # get_max_train returns race_max + 4 (ROM src/handler.c:3027);
+        # the ROM standard is 18 base + 4 = 22.
         max_stat = 22
+        perm_stat = getattr(char, "perm_stat", []) or []
 
-        if char.perm_str < max_stat:
+        def _stat(idx: int) -> int:
+            return perm_stat[idx] if idx < len(perm_stat) else 0
+
+        if _stat(0) < max_stat:  # STAT_STR
             options.append(" str")
-        if char.perm_int < max_stat:
+        if _stat(1) < max_stat:  # STAT_INT
             options.append(" int")
-        if char.perm_wis < max_stat:
+        if _stat(2) < max_stat:  # STAT_WIS
             options.append(" wis")
-        if char.perm_dex < max_stat:
+        if _stat(3) < max_stat:  # STAT_DEX
             options.append(" dex")
-        if char.perm_con < max_stat:
+        if _stat(4) < max_stat:  # STAT_CON
             options.append(" con")
         options.append(" hp mana")