rom24-quickmud-python 2.9.20__py3-none-any.whl → 2.13.29__py3-none-any.whl

mud/account/__init__.py

@@ -7,35 +7,35 @@ their passwords directly, mirroring ROM src/merc.h PCData.pwd.
 from .account_manager import load_character, save_character
 from .account_service import (
     CreationSelection,
+    LoginFailureReason,
+    LoginResult,
     account_exists,
     character_exists,
+    clear_active_accounts,
     create_account,
     create_character,
     create_character_record,
-    clear_active_accounts,
+    finalize_creation_stats,
     get_creation_classes,
     get_creation_races,
     get_hometown_choices,
-    get_weapon_choices,
     get_race_archetype,
+    get_weapon_choices,
     is_account_active,
     is_valid_account_name,
     is_valid_character_name,
+    list_characters,
+    login,
     login_character,
+    login_with_host,
     lookup_creation_class,
     lookup_creation_race,
     lookup_hometown,
     lookup_weapon_choice,
-    LoginFailureReason,
-    LoginResult,
-    list_characters,
-    login,
-    login_with_host,
-    roll_creation_stats,
-    finalize_creation_stats,
-    sanitize_account_name,
     release_account,
     release_character,
+    roll_creation_stats,
+    sanitize_account_name,
 )
 
 __all__ = [

mud/account/account_manager.py

@@ -28,16 +28,16 @@ from mud.db.session import SessionLocal
 
 if TYPE_CHECKING:
     from sqlalchemy.orm import Session
-from mud.models.character import Character, character_registry, from_orm
-from mud.models.constants import ROOM_VNUM_LIMBO, ROOM_VNUM_TEMPLE
 from mud.db.serializers import (
     _normalize_int_list,
     _serialize_colour_table,
+    _serialize_groups,
     _serialize_object,
     _serialize_pet,
     _serialize_skill_map,
-    _serialize_groups,
 )
+from mud.models.character import Character, character_registry, from_orm
+from mud.models.constants import ROOM_VNUM_LIMBO, ROOM_VNUM_TEMPLE
 
 
 def load_character(char_name: str, _ignored: str | None = None) -> Character | None:
@@ -265,10 +265,12 @@ def save_character_to_db(session: Session, character: Character) -> None:
 
     # perm_stats JSON (already stored as string, keep existing column)
     from mud.models.character import _encode_perm_stats
+
     db_char.perm_stats = _encode_perm_stats(getattr(character, "perm_stat", []))
 
     # creation_groups / creation_skills (keep in sync)
     from mud.models.character import _encode_creation_groups, _encode_creation_skills
+
     db_char.creation_groups = _encode_creation_groups(getattr(character, "creation_groups", ()))
     db_char.creation_skills = _encode_creation_skills(getattr(character, "creation_skills", ()))
     db_char.creation_points = int(getattr(character, "creation_points", 0) or 0)
@@ -312,6 +314,7 @@ def save_character_to_db(session: Session, character: Character) -> None:
 def _dataclass_to_dict(obj: object) -> dict:
     """Recursively convert a dataclass instance to a plain dict for JSON storage."""
     import dataclasses
+
     if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
         result = {}
         for f in dataclasses.fields(obj):  # type: ignore[arg-type]
@@ -320,7 +323,9 @@ def _dataclass_to_dict(obj: object) -> dict:
                 result[f.name] = _dataclass_to_dict(val)
             elif isinstance(val, list):
                 result[f.name] = [
-                    _dataclass_to_dict(item) if (dataclasses.is_dataclass(item) and not isinstance(item, type)) else item
+                    _dataclass_to_dict(item)
+                    if (dataclasses.is_dataclass(item) and not isinstance(item, type))
+                    else item
                     for item in val
                 ]
             elif isinstance(val, dict):

mud/account/account_service.py

@@ -101,6 +101,7 @@ _WEAPON_CHOICES: Final[dict[str, tuple[str, ...]]] = {
     "warrior": ("sword", "mace"),
 }
 
+
 @lru_cache(maxsize=1)
 def _load_skill_data() -> dict[str, dict[str, object]]:
     """Return ROM skill metadata (type/ratings) keyed by lower-case name."""
@@ -152,7 +153,7 @@ def _skill_ratings(name: str) -> tuple[int, int, int, int] | None:
     metadata = ROM_SKILL_METADATA.get(normalized)
     if metadata is not None:
         ratings_meta = metadata.get("ratings")
-        if isinstance(ratings_meta, (list, tuple)) and len(ratings_meta) >= 4:
+        if isinstance(ratings_meta, list | tuple) and len(ratings_meta) >= 4:
             try:
                 return tuple(int(value) for value in ratings_meta[:4])
             except (TypeError, ValueError):
@@ -433,8 +434,13 @@ class CreationSelection:
         return base + 40
 
     def train_value(self) -> int:
-        if self.creation_points < 40:
-            return max(0, (40 - self.creation_points + 1) // 2)
+        # mirroring ROM src/nanny.c:776 — CON_READ_MOTD unconditionally sets
+        # ch->train = 3 for every level-0 character, overwriting the
+        # `ch->train = (40 - points + 1) / 2` formula from src/nanny.c:684.
+        # The formula never survives to CON_PLAYING (it is dead code in ROM),
+        # so a freshly created PC always starts with exactly 3 training
+        # sessions regardless of how many creation points were spent. (practice
+        # is likewise hardcoded to 5 at src/nanny.c:777.)
         return 3
 
     def group_names(self) -> tuple[str, ...]:
@@ -957,7 +963,9 @@ def list_characters(
     if not name:
         return []
     if require_act_flags is not None:
-        required_bits = int(require_act_flags) if not isinstance(require_act_flags, PlayerFlag) else int(require_act_flags)
+        required_bits = (
+            int(require_act_flags) if not isinstance(require_act_flags, PlayerFlag) else int(require_act_flags)
+        )
         act_flags = int(getattr(account, "act", 0) or 0)
         if act_flags & required_bits != required_bits:
             return []

mud/admin_logging/admin.py

@@ -80,7 +80,7 @@ def _duplicate_wiznet_chars(text: str) -> str:
     return "".join(duplicated)
 
 
-def _get_effective_trust(character: "Character") -> int:
+def _get_effective_trust(character: Character) -> int:
     """Mirror ROM's ``get_trust`` helper used for wiznet broadcasts."""
 
     trust = getattr(character, "trust", 0)
@@ -91,7 +91,7 @@ def log_admin_command(
     actor: str,
     command_line: str,
     *,
-    character: "Character" | None = None,
+    character: Character | None = None,
 ) -> None:
     """Append a single admin-command entry to log/admin.log.
 

mud/advancement.py

@@ -11,6 +11,7 @@ from mud.models.constants import LEVEL_HERO
 from mud.models.races import PcRaceType, list_playable_races
 from mud.models.titles import default_title_text
 from mud.utils import rng_mm
+from mud.utils.messaging import send_to_char_buffered
 from mud.wiznet import WiznetFlag, wiznet
 
 BASE_XP_PER_LEVEL = 1000
@@ -53,9 +54,7 @@ def exp_per_level(char: Character) -> int:
     return _creation_exp_floor(char, BASE_XP_PER_LEVEL)
 
 
-def exp_per_level_for_creation(
-    race: PcRaceType, class_type: ClassType, creation_points: int
-) -> int:
+def exp_per_level_for_creation(race: PcRaceType, class_type: ClassType, creation_points: int) -> int:
     """ROM-style experience curve based on creation points."""
 
     points = max(0, int(creation_points))
@@ -144,7 +143,7 @@ def advance_level(char: Character) -> None:
 
         set_title(char, default_title_text(char.ch_class, char.level, getattr(char, "sex", 0)))
 
-    if hasattr(char, "send_to_char") and not getattr(char, "is_npc", False):
+    if not getattr(char, "is_npc", False):
         hit_suffix = "" if hp == 1 else "s"
         practice_suffix = "" if practice_gain == 1 else "s"
         message = (
@@ -152,7 +151,11 @@ def advance_level(char: Character) -> None:
             f"{hp} hit point{hit_suffix}, {mana} mana, {move} move, and "
             f"{practice_gain} practice{practice_suffix}.{ROM_NEWLINE}"
         )
-        char.send_to_char(message)
+        # mirroring ROM src/update.c:113 advance_level — `send_to_char(buf, ch)`
+        # straight to the descriptor. advance_level fires from gain_exp during a
+        # combat-tick kill; route through the async-aware helper so a leveling PC
+        # sees it immediately, not at the next command (mailbox-strand bug).
+        send_to_char_buffered(char, message)
 
 
 def _creation_exp_floor(char: Character, fallback: int) -> int:
@@ -217,8 +220,10 @@ def gain_exp(char: Character, amount: int) -> None:
 
     # Level up while total exp meets threshold for next level.
     while char.level < LEVEL_HERO and char.exp >= exp_per_level(char) * (char.level + 1):
-        if hasattr(char, "send_to_char"):
-            char.send_to_char("{GYou raise a level!!  {x")
+        # mirroring ROM src/update.c:131 gain_exp — `send_to_char(...)` straight
+        # to the descriptor during the combat tick; async-aware delivery so the
+        # ding shows at kill time, not at the player's next command.
+        send_to_char_buffered(char, "{GYou raise a level!!  {x")
         char.level += 1
         log_game_event(f"{getattr(char, 'name', 'Someone')} gained level {char.level}")
         wiznet(
@@ -232,4 +237,5 @@ def gain_exp(char: Character, amount: int) -> None:
         advance_level(char)
         # Lazy import to avoid circular dependency
         from mud.account.account_manager import save_character
+
         save_character(char)

mud/affects/engine.py

@@ -56,9 +56,16 @@ def tick_spell_effects(character: Character) -> list[str]:
             duration = int(getattr(affect, "duration", 0) or 0)
             if duration > 0:
                 affect.duration = duration - 1
+                # ROM src/update.c:768 — `if (number_range(0,4) == 0 && paf->level > 0)`.
+                # C `&&` is left-to-right short-circuit and number_range advances MM
+                # state as a side effect, so the roll is consumed UNCONDITIONALLY for
+                # every duration>0 affect; `level > 0` is only tested afterwards. The
+                # operands must NOT be swapped (`level > 0 and number_range(...)` skips
+                # the roll at level 0, desyncing the global RNG stream — GL-026).
+                fades = rng_mm.number_range(0, 4) == 0
                 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
+                if fades and level > 0:
+                    affect.level = level - 1
                 spell_name = getattr(affect, "type", None)
                 if isinstance(spell_name, str) and spell_name in effects:
                     touched_names.add(spell_name)
@@ -114,9 +121,7 @@ def tick_spell_effects(character: Character) -> list[str]:
 
         for spell_name in touched_names:
             remaining = [
-                affect
-                for affect in getattr(character, "affected", [])
-                if getattr(affect, "type", None) == spell_name
+                affect for affect in getattr(character, "affected", []) if getattr(affect, "type", None) == spell_name
             ]
             if remaining:
                 primary = remaining[0]

mud/affects/saves.py

@@ -5,7 +5,6 @@ from mud.models.character import Character
 from mud.models.constants import AffectFlag, DamageType, DefenseBit
 from mud.utils import rng_mm
 
-
 ROM_NEWLINE = "\n\r"
 
 # Minimal fMana mapping from ROM const.c order: mage, cleric → True; thief, warrior → False

mud/ai/__init__.py

@@ -170,18 +170,22 @@ def _take_object(mob: Character, obj: Object) -> None:
         obj.location = None
     if hasattr(obj, "in_obj"):
         obj.in_obj = None
-    if hasattr(obj, "carried_by"):
-        obj.carried_by = mob
-
-    inventory = getattr(mob, "inventory", None)
-    if isinstance(inventory, list) and obj not in inventory:
-        inventory.append(obj)
-
-    weight = int(getattr(obj, "weight", 0) or 0)
-    if hasattr(mob, "carry_number"):
-        mob.carry_number = int(getattr(mob, "carry_number", 0) or 0) + 1
-    if hasattr(mob, "carry_weight"):
-        mob.carry_weight = int(getattr(mob, "carry_weight", 0) or 0) + weight
+    # obj.carried_by is set by add_object / add_to_inventory below
+
+    # INV-039 / class-13: route through head-insert chokepoint.
+    # Character.add_object / MobInstance.add_to_inventory handles carry_number
+    # and carry_weight internally — no manual counter update needed.
+    add_obj = getattr(mob, "add_object", None)
+    if callable(add_obj):
+        add_obj(obj)
+    else:
+        add_inv = getattr(mob, "add_to_inventory", None)
+        if callable(add_inv):
+            add_inv(obj)
+        else:
+            inventory = getattr(mob, "inventory", None)
+            if isinstance(inventory, list) and obj not in inventory:
+                inventory.insert(0, obj)
 
     room = getattr(mob, "room", None)
     if room is not None and hasattr(room, "broadcast"):

mud/ai/aggressive.py

@@ -6,7 +6,7 @@ from collections.abc import Iterable
 
 from mud.combat import multi_hit
 from mud.models.character import Character, character_registry
-from mud.models.constants import ActFlag, AffectFlag, LEVEL_IMMORTAL, Position, RoomFlag
+from mud.models.constants import LEVEL_IMMORTAL, ActFlag, AffectFlag, RoomFlag
 from mud.utils import rng_mm
 
 
@@ -17,24 +17,6 @@ def _has_flag(value: int, flag: ActFlag) -> bool:
         return False
 
 
-def _has_affect(ch: Character, flag: AffectFlag) -> bool:
-    checker = getattr(ch, "has_affect", None)
-    if callable(checker):
-        return bool(checker(flag))
-    affected = getattr(ch, "affected_by", 0)
-    try:
-        return bool(int(affected) & int(flag))
-    except Exception:
-        return False
-
-
-def _is_awake(ch: Character) -> bool:
-    checker = getattr(ch, "is_awake", None)
-    if callable(checker):
-        return bool(checker())
-    return int(getattr(ch, "position", 0)) > int(Position.SLEEPING)
-
-
 def _can_see(attacker: Character, target: Character | None) -> bool:
     if attacker is None or target is None:
         return False
@@ -62,7 +44,7 @@ def _eligible_victims(ch: Character, occupants: Iterable[Character]) -> Iterable
             continue
         if int(getattr(ch, "level", 0)) < int(getattr(candidate, "level", 0)) - 5:
             continue
-        if _has_flag(getattr(ch, "act", 0), ActFlag.WIMPY) and _is_awake(candidate):
+        if _has_flag(getattr(ch, "act", 0), ActFlag.WIMPY) and candidate.is_awake():
             continue
         if not _can_see(ch, candidate):
             continue
@@ -91,15 +73,15 @@ def aggressive_update() -> None:
                 continue
             if int(getattr(room, "room_flags", 0)) & int(RoomFlag.ROOM_SAFE):
                 continue
-            if _has_affect(mob, AffectFlag.CALM):
+            if mob.has_affect(AffectFlag.CALM):
                 continue
             if getattr(mob, "fighting", None) is not None:
                 continue
-            if _has_affect(mob, AffectFlag.CHARM):
+            if mob.has_affect(AffectFlag.CHARM):
                 continue
-            if not _is_awake(mob):
+            if not mob.is_awake():
                 continue
-            if _has_flag(getattr(mob, "act", 0), ActFlag.WIMPY) and _is_awake(watcher):
+            if _has_flag(getattr(mob, "act", 0), ActFlag.WIMPY) and watcher.is_awake():
                 continue
             if not _can_see(mob, watcher):
                 continue

mud/characters/conditions.py

@@ -1,20 +1,12 @@
 from __future__ import annotations
 
 from mud.models.character import Character
-from mud.models.constants import Condition, LEVEL_IMMORTAL
-
+from mud.models.constants import LEVEL_IMMORTAL, Condition
+from mud.utils.messaging import send_to_char_buffered as _send_to_char
 
 __all__ = ["gain_condition"]
 
 
-def _send_to_char(character: Character, message: str) -> None:
-    """Append a message to the character if a buffer is available."""
-
-    messages = getattr(character, "messages", None)
-    if isinstance(messages, list):
-        messages.append(message)
-
-
 def gain_condition(character: Character, condition: Condition, delta: int) -> None:
     """Adjust a player's condition slot, mirroring ROM gain_condition."""
 

mud/characters/follow.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from mud.models.constants import AffectFlag
+from mud.utils.messaging import push_message
 
 if TYPE_CHECKING:  # pragma: no cover - import for type checkers only
     from mud.models.character import Character
 
 
-def _display_name(character: "Character" | None) -> str:
+def _display_name(character: Character | None) -> str:
     if character is None:
         return "Someone"
     name = getattr(character, "name", None)
@@ -20,8 +21,10 @@ def _display_name(character: "Character" | None) -> str:
     return "Someone"
 
 
-def add_follower(follower: "Character", master: "Character") -> None:
+def add_follower(follower: Character, master: Character) -> None:
     """Attach ``follower`` to ``master`` mirroring ROM ``add_follower``."""
+    # mirroring ROM src/act_comm.c:1591-1607
+    from mud.world.vision import can_see_character
 
     if getattr(follower, "master", None) is master:
         return
@@ -31,17 +34,20 @@ def add_follower(follower: "Character", master: "Character") -> None:
     follower.master = master
     follower.leader = None
 
-    master_messages = getattr(master, "messages", None)
-    if isinstance(master_messages, list):
-        master_messages.append(f"{_display_name(follower)} now follows you.")
+    # ROM lines 1602-1603: TO_VICT gated on can_see(master, ch).
+    if can_see_character(master, follower):
+        # mirroring ROM src/act_comm.c:1602-1603 — act(..., TO_VICT)
+        # writes immediately to the descriptor; mailbox is fallback only.
+        push_message(master, f"{_display_name(follower)} now follows you.")
 
-    follower_messages = getattr(follower, "messages", None)
-    if isinstance(follower_messages, list):
-        follower_messages.append(f"You now follow {_display_name(master)}.")
+    # ROM line 1605: TO_CHAR is unconditional.
+    push_message(follower, f"You now follow {_display_name(master)}.")
 
 
-def stop_follower(follower: "Character") -> None:
+def stop_follower(follower: Character) -> None:
     """Detach ``follower`` from its master and clear charm effects."""
+    # mirroring ROM src/act_comm.c:1612-1636
+    from mud.world.vision import can_see_character
 
     master = getattr(follower, "master", None)
     if master is None:
@@ -52,13 +58,15 @@ def stop_follower(follower: "Character") -> None:
     elif follower.has_affect(AffectFlag.CHARM):
         follower.remove_affect(AffectFlag.CHARM)
 
-    master_messages = getattr(master, "messages", None)
-    if isinstance(master_messages, list):
-        master_messages.append(f"{_display_name(follower)} stops following you.")
-
-    follower_messages = getattr(follower, "messages", None)
-    if isinstance(follower_messages, list):
-        follower_messages.append(f"You stop following {_display_name(master)}.")
+    # ROM lines 1625-1629: both messages gated on
+    # can_see(ch->master, ch) && ch->in_room != NULL.
+    if can_see_character(master, follower) and getattr(follower, "room", None) is not None:
+        # ROM src/act_comm.c:1626-1627 — act(..., TO_VICT)/act(..., TO_CHAR) write
+        # immediately to the descriptor; push_message routes a connected PC to the
+        # async send and falls back to the mailbox only for disconnected chars
+        # (matching add_follower above — ACT_COMM-003 / INV-001 wrong-channel).
+        push_message(master, f"{_display_name(follower)} stops following you.")
+        push_message(follower, f"You stop following {_display_name(master)}.")
 
     if getattr(master, "pet", None) is follower:
         master.pet = None
@@ -67,7 +75,7 @@ def stop_follower(follower: "Character") -> None:
     follower.leader = None
 
 
-def die_follower(char: "Character") -> None:
+def die_follower(char: Character) -> None:
     """Detach a dying character from its group and followers.
 
     Mirrors ROM ``src/act_comm.c:1658-1680``:

mud/combat/assist.py

@@ -6,7 +6,6 @@ ROM Reference: src/fight.c check_assist (lines 105-181)
 
 from __future__ import annotations
 
-import asyncio
 from typing import TYPE_CHECKING
 
 from mud.characters import is_same_group
@@ -56,7 +55,7 @@ def check_assist(ch: Character, victim: Character) -> None:
     # ROM uses rch_next pattern to handle this
     for rch in list(people_in_room):  # Create a copy to avoid modification issues
         # Skip if not awake or already fighting
-        if not _is_awake(rch):
+        if not rch.is_awake():
             continue
 
         if getattr(rch, "fighting", None) is not None:
@@ -151,14 +150,6 @@ def check_assist(ch: Character, victim: Character) -> None:
                     multi_hit(rch, target, None)
 
 
-def _is_awake(char: Character) -> bool:
-    """Check if character is awake (ROM IS_AWAKE macro)."""
-    from mud.models.constants import Position
-
-    position = getattr(char, "position", Position.STANDING)
-    return position > Position.SLEEPING
-
-
 def _is_npc(char: Character) -> bool:
     """Check if character is NPC (ROM IS_NPC macro)."""
     return getattr(char, "is_npc", False)
@@ -190,22 +181,8 @@ def _emote(char: Character, message: str) -> None:
     people = getattr(room, "people", [])
     for person in people:
         if person != char:
-            _send_to_char(person, full_message)
-
-
-def _send_to_char(char: Character, message: str) -> None:
-    """Send a message to a character, mirroring ROM C write_to_buffer."""
-    # Direct delivery for connected characters
-    writer = getattr(char, "connection", None)
-    if writer is not None:
-        from mud.net.protocol import send_to_char as _send
-
-        asyncio.create_task(_send(char, message + "\n"))
-    # Queue fallback for tests
-    send = getattr(char, "send", None)
-    if callable(send):
-        send(message + "\n")
-    else:
-        messages = getattr(char, "messages", None)
-        if isinstance(messages, list):
-            messages.append(message + "\n")
+            _send_to_char(person, full_message + "\n")
+
+
+# DUPL-001b — canonical at mud/utils/messaging.py:send_to_char_buffered.
+from mud.utils.messaging import send_to_char_buffered as _send_to_char  # noqa: E402