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

mud/account/__init__.py

@@ -32,6 +32,7 @@ from .account_service import (
     lookup_creation_race,
     lookup_hometown,
     lookup_weapon_choice,
+    mark_character_active,
     release_account,
     release_character,
     roll_creation_stats,
@@ -67,6 +68,7 @@ __all__ = [
     "sanitize_account_name",
     "clear_active_accounts",
     "is_account_active",
+    "mark_character_active",
     "release_account",
     "release_character",
     "LoginFailureReason",

mud/account/account_manager.py

@@ -76,6 +76,42 @@ def load_character(char_name: str, _ignored: str | None = None) -> Character | N
             session.close()
 
 
+def delete_character(char_name: str) -> bool:
+    """Permanently delete a character from the canonical store (DB row).
+
+    DB-canonical (INV-008): the player's gameplay state and auth both live in
+    the ``characters`` DB row, so deletion means removing that row — NOT
+    unlinking a pfile (there is no JSON pfile path). Also drops any matching
+    runtime ``Character`` from ``character_registry`` so the name cannot be
+    referenced after deletion (INV-003 complement).
+
+    ROM Reference: src/act_comm.c do_delete (lines 54-93) — ROM ``do_quit``s the
+    character (which saves the pfile) and then ``unlink(strsave)`` removes it.
+    The DB-row delete here is the faithful equivalent of that ``unlink``.
+
+    Returns True if a row was deleted, False if no row existed.
+    """
+    # Drop any live runtime instance(s) by name first (idempotent).
+    for prior in [c for c in character_registry if getattr(c, "name", None) == char_name]:
+        character_registry.remove(prior)
+
+    session = None
+    try:
+        session = SessionLocal()
+        db_char = session.query(DBCharacter).filter(DBCharacter.name == char_name).first()
+        if db_char is None:
+            return False
+        session.delete(db_char)
+        session.commit()
+        return True
+    except Exception as e:
+        print(f"[ERROR] delete_character failed for {char_name}: {e}")
+        return False
+    finally:
+        if session:
+            session.close()
+
+
 def save_character(character: Character) -> None:
     """Persist ``character`` to the DB row (DB-canonical path).
 

mud/account/account_service.py

@@ -824,6 +824,19 @@ def _mark_character_active(name: str) -> None:
     _active_characters.add(_normalize(name))
 
 
+def mark_character_active(name: str) -> None:
+    """Set the active-session marker for this character.
+
+    Public counterpart to :func:`release_character`. ``login_with_host`` marks
+    returning logins internally; the INV-051 deferred-persistence new-character
+    path needs this entry point because it no longer routes through
+    ``login_with_host`` (it persists via ``create_character`` at creation end),
+    so a freshly-created in-game character must still be flagged active for the
+    name-phase duplicate-login check (``connection.py`` ``is_account_active``).
+    """
+    _mark_character_active(name)
+
+
 def release_character(name: str) -> None:
     """Clear the active-session marker for this character."""
     _active_characters.discard(_normalize(name))

mud/ai/__init__.py

@@ -100,18 +100,6 @@ def _find_character(name: str) -> Character | None:
     return None
 
 
-def _broadcast_room(room: Room, message: str, exclude: object | None = None) -> None:
-    if hasattr(room, "broadcast"):
-        room.broadcast(message, exclude=exclude)
-        return
-    for occupant in getattr(room, "people", []) or []:
-        if occupant is exclude:
-            continue
-        messages = getattr(occupant, "messages", None)
-        if isinstance(messages, list):
-            messages.append(message)
-
-
 def _can_loot(mob: Character, obj: Object) -> bool:
     if getattr(mob, "is_admin", False):
         return True
@@ -187,11 +175,13 @@ def _take_object(mob: Character, obj: Object) -> None:
             if isinstance(inventory, list) and obj not in inventory:
                 inventory.insert(0, obj)
 
+    # mirroring ROM src/update.c:491 — act("$n gets $p.", ch, obj_best, NULL, TO_ROOM)
+    # act_to_room handles per-recipient formatting + TRIG_ACT dispatch (src/comm.c:2384).
     room = getattr(mob, "room", None)
-    if room is not None and hasattr(room, "broadcast"):
-        mob_name = getattr(mob, "short_descr", None) or getattr(mob, "name", None) or "Someone"
-        obj_name = getattr(obj, "short_descr", None) or getattr(obj, "name", None) or "something"
-        room.broadcast(f"{mob_name} gets {obj_name}.", exclude=mob)
+    if room is not None:
+        from mud.utils.act import act_to_room
+
+        act_to_room(room, "$n gets $p.", mob, arg1=obj, exclude=mob)
 
 
 def _maybe_scavenge(mob: Character, room: Room) -> None:
@@ -239,8 +229,15 @@ def _maybe_wander(mob: Character, room: Room) -> None:
     if rng_mm.number_bits(3) != 0:
         return
 
-    # ROM C mob_cmds.c:1274 uses number_door() for random direction
-    door = rng_mm.number_door()
+    # mirroring ROM src/update.c:498 — wander draws a SINGLE 5-bit direction
+    # `(door = number_bits(5)) <= 5` and aborts the whole wander when the roll
+    # exceeds 5 (so a mob only wanders on 6/32 of otherwise-eligible ticks).
+    # NOT number_door() (the do_flee/do_mpflee primitive, src/db.c:3541), which
+    # re-rolls with a 3-bit mask until ≤5 and therefore always returns a valid
+    # door — that over-wanders ~5× and desyncs the shared Mitchell-Moore stream.
+    door = rng_mm.number_bits(5)
+    if door > 5:
+        return
 
     exit_obj = _valid_exit(room, door)
     if exit_obj is None:
@@ -275,7 +272,16 @@ def _maybe_wander(mob: Character, room: Room) -> None:
 def mobile_update() -> None:
     """Mirror ROM ``mobile_update`` scavenging, wandering, and mobprog triggers."""
 
-    for mob in list(character_registry):
+    # mirroring ROM src/update.c:416 — mobile_update walks ``char_list``, which
+    # src/db.c:2256-2257 (create_mobile) head-inserts, so ROM visits the NEWEST
+    # mob first. ``character_registry`` is append-order, so iterate it reversed
+    # — load-bearing for the shared RNG draw order (shop-wealth rolls, scavenger
+    # 1/64, wander door rolls), like violence_tick/char_update/obj_update. GL-042.
+    for mob in list(reversed(character_registry)):
+        # mirroring ROM extract_char re-linking — a char removed from char_list
+        # mid-tick is never revisited in ROM's walk; skip extracted mobs. GL-042.
+        if mob not in character_registry:
+            continue
         if not getattr(mob, "is_npc", False):
             continue
         room = getattr(mob, "room", None)
@@ -289,6 +295,17 @@ def mobile_update() -> None:
             if not _mob_has_act_flag(mob, ActFlag.UPDATE_ALWAYS):
                 continue
 
+        # mirroring ROM src/update.c:425-431 — the special procedure runs INSIDE
+        # the per-mob loop, after the charm/empty gates and BEFORE shop-gold,
+        # triggers, scavenge, and wander. A TRUE result `continue`s, skipping the
+        # rest of this mob's tick. Dispatched here (not as a separate
+        # run_npc_specs pass) so the gates and suppression match ROM exactly
+        # and the spec's RNG draws interleave per-mob with scavenge/wander. INV-049.
+        from mud.spec_funs import run_spec_fun
+
+        if run_spec_fun(mob):
+            continue
+
         shop, wealth = _resolve_shop_info(mob)
         if shop is not None and wealth > 0:
             try:

mud/ai/aggressive.py

@@ -54,7 +54,17 @@ def _eligible_victims(ch: Character, occupants: Iterable[Character]) -> Iterable
 def aggressive_update() -> None:
     """Wake aggressive NPCs and initiate combat when players enter their rooms."""
 
-    for watcher in list(character_registry):
+    # mirroring ROM src/update.c:1087 — aggr_update walks ``char_list`` for the
+    # PC watcher ``wch``; src/db.c:2256-2257 / src/nanny.c:757-758 head-insert,
+    # so ROM visits the NEWEST character first. ``character_registry`` is
+    # append-order, so iterate it reversed — load-bearing for the shared RNG
+    # draw order (number_bits(1) aggression coin, number_range victim
+    # reservoir), like violence_tick/char_update/mobile_update. GL-043.
+    for watcher in reversed(list(character_registry)):
+        # mirroring ROM's saved ``wch_next`` pointer — a char extracted
+        # mid-tick (multi_hit kill) is never revisited in ROM's walk. GL-043.
+        if watcher not in character_registry:
+            continue
         if getattr(watcher, "is_npc", False):
             continue
         if watcher.is_immortal():
@@ -98,9 +108,12 @@ def aggressive_update() -> None:
             if victim is None:
                 continue
 
+            # mirroring ROM src/update.c:1136 — aggr_update ends each aggression
+            # with a bare multi_hit(ch, victim, TYPE_UNDEFINED). It does NOT call
+            # check_assist: auto-assist is exclusively violence_update's job
+            # (src/fight.c:90, run on the next PULSE_VIOLENCE — Python's
+            # game_loop.violence_tick). Calling check_assist here started assists
+            # a full tick early and drew extra coins from the shared MM RNG
+            # stream (the comment that used to cite "fight.c:90" mislabeled the
+            # violence_update site as if it belonged to aggr_update).
             multi_hit(mob, victim)
-
-            # ROM src/fight.c:90 - Check for assist after combat starts
-            from mud.combat.assist import check_assist
-
-            check_assist(mob, victim)

mud/characters/follow.py

@@ -3,24 +3,13 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from mud.models.constants import AffectFlag
+from mud.utils.act import act_format
 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:
-    if character is None:
-        return "Someone"
-    name = getattr(character, "name", None)
-    if isinstance(name, str) and name:
-        return name
-    short_descr = getattr(character, "short_descr", None)
-    if isinstance(short_descr, str) and short_descr:
-        return short_descr
-    return "Someone"
-
-
 def add_follower(follower: Character, master: Character) -> None:
     """Attach ``follower`` to ``master`` mirroring ROM ``add_follower``."""
     # mirroring ROM src/act_comm.c:1591-1607
@@ -38,10 +27,13 @@ def add_follower(follower: Character, master: Character) -> None:
     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.")
+        # FOLLOW-003: ROM act("$n now follows you.", ch, NULL, master, TO_VICT) —
+        # $n = PERS(follower, master) = NPC short_descr (cap), not the keyword name.
+        push_message(master, act_format("$n now follows you.", recipient=master, actor=follower))
 
-    # ROM line 1605: TO_CHAR is unconditional.
-    push_message(follower, f"You now follow {_display_name(master)}.")
+    # ROM line 1605: TO_CHAR is unconditional. FOLLOW-004: $N = PERS(master, ch)
+    # is gated on can_see(ch, master) — an unseen master renders "someone".
+    push_message(follower, act_format("You now follow $N.", recipient=follower, arg2=master))
 
 
 def stop_follower(follower: Character) -> None:
@@ -65,8 +57,12 @@ def stop_follower(follower: Character) -> None:
         # 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)}.")
+        # FOLLOW-003: ROM act("$n stops following you.", ch, NULL, ch->master,
+        # TO_VICT) — $n = PERS(follower, master) = NPC short_descr (cap).
+        push_message(master, act_format("$n stops following you.", recipient=master, actor=follower))
+        # FOLLOW-004: $N = PERS(master, ch) — gated on can_see(ch, master); an
+        # unseen master (e.g. blind follower) renders "someone".
+        push_message(follower, act_format("You stop following $N.", recipient=follower, arg2=master))
 
     if getattr(master, "pet", None) is follower:
         master.pet = None

mud/combat/assist.py

@@ -10,7 +10,6 @@ from typing import TYPE_CHECKING
 
 from mud.characters import is_same_group
 from mud.combat.engine import is_evil, is_good, is_neutral, multi_hit
-from mud.combat.safety import is_safe
 from mud.models.constants import AffectFlag, OffFlag, PlayerFlag
 from mud.utils import rng_mm
 from mud.world.vision import can_see_character
@@ -81,8 +80,23 @@ def check_assist(ch: Character, victim: Character) -> None:
             is_rch_charmed = _is_affected(rch, AffectFlag.CHARM)
 
             if (is_rch_autoassist or is_rch_charmed) and is_same_group(ch, rch):
-                if not is_safe(rch, victim):
+                # INV-050: route through the faithful ROM is_safe() mirror
+                # (_kill_safety_message, src/fight.c:1018-1124) rather than the
+                # silent bool combat.safety.is_safe. ROM check_assist gates on
+                # `!is_safe(rch, victim)` (src/fight.c:131); is_safe writes its
+                # OWN rejection line to rch via send_to_char BEFORE returning
+                # TRUE (e.g. "Join a clan if you want to kill players." for a
+                # non-clan PC autoassister) — so a blocked assister sees the
+                # line. A None return == not safe → rch assists. The silent bool
+                # lacked the PC clan ladder, so non-clan PCs wrongly auto-assisted
+                # in PvP. (Function-local import avoids an engine→command cycle.)
+                from mud.commands.combat import _kill_safety_message
+
+                safety_message = _kill_safety_message(rch, victim)
+                if safety_message is None:
                     multi_hit(rch, victim, None)
+                else:
+                    _send_to_char(rch, safety_message + "\n")
 
             continue
 
@@ -95,19 +109,25 @@ def check_assist(ch: Character, victim: Character) -> None:
             rch_off_flags = getattr(rch, "off_flags", 0)
             should_assist = False
 
+            # mirroring ROM src/fight.c:141-150 — all five assist conditions are a
+            # flat || OR chain; C evaluates each until one is true.  Python's
+            # `elif` would enter the ASSIST_RACE branch (flag set) and skip
+            # ASSIST_ALIGN/ASSIST_VNUM even when the inner race predicate fails.
+            # Independent `if` checks restore the ROM || semantics.
+
             # ASSIST_ALL: Assist any mob
             if rch_off_flags & OffFlag.ASSIST_ALL:
                 should_assist = True
 
-            # ASSIST_RACE: Assist same race
-            elif rch_off_flags & OffFlag.ASSIST_RACE:
+            # ASSIST_RACE: Assist same race (ROM src/fight.c:143-144)
+            if rch_off_flags & OffFlag.ASSIST_RACE:
                 ch_race = getattr(ch, "race", None)
                 rch_race = getattr(rch, "race", None)
                 if ch_race and rch_race and ch_race == rch_race:
                     should_assist = True
 
-            # ASSIST_ALIGN: Assist same alignment
-            elif rch_off_flags & OffFlag.ASSIST_ALIGN:
+            # ASSIST_ALIGN: Assist same alignment (ROM src/fight.c:145-148)
+            if rch_off_flags & OffFlag.ASSIST_ALIGN:
                 if (
                     (is_good(rch) and is_good(ch))
                     or (is_evil(rch) and is_evil(ch))
@@ -115,8 +135,8 @@ def check_assist(ch: Character, victim: Character) -> None:
                 ):
                     should_assist = True
 
-            # ASSIST_VNUM: Assist same vnum (same mob prototype)
-            elif rch_off_flags & OffFlag.ASSIST_VNUM:
+            # ASSIST_VNUM: Assist same vnum/mob prototype (ROM src/fight.c:149-150)
+            if rch_off_flags & OffFlag.ASSIST_VNUM:
                 ch_vnum = getattr(ch, "vnum", None)
                 rch_vnum = getattr(rch, "vnum", None)
                 if ch_vnum is not None and rch_vnum is not None and ch_vnum == rch_vnum:
@@ -137,12 +157,15 @@ def check_assist(ch: Character, victim: Character) -> None:
                 target = None
                 number = 0
 
-                # Use reservoir sampling to pick random group member
+                # ROM src/fight.c:159-170 — number++ is INSIDE the selection block;
+                # it only increments when a new target is chosen, not on every
+                # visible group member. This matches ROM's biased selection distribution
+                # and, critically, keeps the shared MM RNG stream in sync.
                 for vch in list(people_in_room):
                     if can_see_character(rch, vch) and is_same_group(vch, victim):
                         if rng_mm.number_range(0, number) == 0:
                             target = vch
-                        number += 1
+                            number += 1  # mirroring ROM src/fight.c:165
 
                 # ROM lines 172-176: Attack the selected target
                 if target is not None: