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

mud/account/account_manager.py

@@ -1,34 +1,75 @@
+"""Account manager — DB-canonical persistence (INV-008 Phase 2).
+
+The DB row (mud.db.models.Character) is the single source of truth for ALL
+player gameplay state.  The JSON pfile path (mud.persistence) has been removed.
+
+``save_character`` writes all 71 fields to the DB row via ``save_character_to_db``.
+``load_character`` queries the DB row and returns a fully-initialized runtime
+Character via ``from_orm``.
+
+ROM Reference: src/save.c fread_char / fwrite_char — the C engine's pfile is
+the single source of truth; the only external auth store is the pfile itself.
+Python equivalent: the DB row owns both auth and all gameplay state.
+
+INV-003: ``character_registry`` membership is maintained — ``load_character``
+appends to the registry after a successful DB load.
+
+INV-008 (DB-CANONICAL): The invariant has been reversed — the DB row is now
+the canonical source, not the JSON pfile.  There is no JSON fallback path.
+"""
+
 from __future__ import annotations
 
-import json
+import time
+from typing import TYPE_CHECKING
 
 from mud.db.models import Character as DBCharacter
 from mud.db.session import SessionLocal
-from mud.models.character import Character, from_orm
+
+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.models.conversion import (
-    load_objects_for_character,
-    save_objects_for_character,
+from mud.db.serializers import (
+    _normalize_int_list,
+    _serialize_colour_table,
+    _serialize_object,
+    _serialize_pet,
+    _serialize_skill_map,
+    _serialize_groups,
 )
 
 
 def load_character(char_name: str, _ignored: str | None = None) -> Character | None:
-    """Load a character by name from the database.
+    """Load a character by name from the DB row (DB-canonical path).
 
     The second argument is accepted but ignored for backward compatibility;
-    previously it was a username (account name).  Characters are now
-    standalone identities — mirroring ROM src/save.c:fread_char.
+    previously it was a username (account name).  Characters are standalone
+    identities — mirroring ROM src/save.c:fread_char.
+
+    The loaded character is appended to ``character_registry`` (INV-003).
     """
     session = None
     try:
         session = SessionLocal()
         db_char = session.query(DBCharacter).filter(DBCharacter.name == char_name).first()
-        char = from_orm(db_char) if db_char else None
-        if char and db_char:
-            char.inventory, char.equipment = load_objects_for_character(db_char)
+        if db_char is None:
+            return None
+        char = from_orm(db_char)
+        if char is not None:
+            # 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}: {e}")
+        print(f"[ERROR] Failed to load character {char_name} from DB: {e}")
         return None
     finally:
         if session:
@@ -36,73 +77,258 @@ def load_character(char_name: str, _ignored: str | None = None) -> Character | N
 
 
 def save_character(character: Character) -> None:
+    """Persist ``character`` to the DB row (DB-canonical path).
+
+    UPDATE-only: the character row must already exist (created via
+    account_service.create_character).  If the row is not found, returns silently.
+
+    ROM Reference: src/save.c fwrite_char — all fields persisted.
+    # mirroring mud/persistence.py:save_character (now removed for JSON path)
+    """
     session = None
     try:
         session = SessionLocal()
-        db_char = session.query(DBCharacter).filter_by(name=character.name).first()
-        if not db_char:
-            print(f"[WARN] Character '{character.name}' not found in database, creating new record")
-            db_char = DBCharacter(name=character.name)
-            session.add(db_char)
-
-        if db_char:
-            db_char.level = character.level
-            db_char.hp = character.hit
-            db_char.race = int(character.race or 0)
-            db_char.ch_class = int(character.ch_class or 0)
-            pcdata = getattr(character, "pcdata", None)
-            true_sex_value = int(getattr(pcdata, "true_sex", getattr(character, "sex", 0)) or 0)
-            db_char.true_sex = true_sex_value
-            db_char.sex = int(character.sex or true_sex_value or 0)
-            db_char.alignment = int(character.alignment or 0)
-            db_char.act = int(getattr(character, "act", 0) or 0)
-            db_char.hometown_vnum = int(character.hometown_vnum or 0)
-            db_char.perm_stats = json.dumps([int(val) for val in character.perm_stat])
-            db_char.size = int(character.size or 0)
-            db_char.form = int(character.form or 0)
-            db_char.parts = int(character.parts or 0)
-            db_char.imm_flags = int(character.imm_flags or 0)
-            db_char.res_flags = int(character.res_flags or 0)
-            db_char.vuln_flags = int(character.vuln_flags or 0)
-            db_char.practice = int(character.practice or 0)
-            db_char.train = int(character.train or 0)
-
-            # Save perm stats from pcdata (ROM src/handler.c stores perm_hit/perm_mana/perm_move)
-            if pcdata:
-                db_char.perm_hit = int(getattr(pcdata, "perm_hit", character.max_hit or 20))
-                db_char.perm_mana = int(getattr(pcdata, "perm_mana", character.max_mana or 100))
-                db_char.perm_move = int(getattr(pcdata, "perm_move", character.max_move or 100))
-            else:
-                db_char.perm_hit = int(character.max_hit or 20)
-                db_char.perm_mana = int(character.max_mana or 100)
-                db_char.perm_move = int(character.max_move or 100)
-
-            # Persist password hash if available on runtime character
-            if pcdata:
-                pwd = getattr(pcdata, "pwd", None) or ""
-                if pwd and not getattr(db_char, "password_hash", ""):
-                    db_char.password_hash = pwd
-
-            db_char.default_weapon_vnum = int(character.default_weapon_vnum or 0)
-            db_char.creation_points = int(getattr(character, "creation_points", 0) or 0)
-            db_char.creation_groups = json.dumps(list(getattr(character, "creation_groups", ())))
-            db_char.newbie_help_seen = bool(getattr(character, "newbie_help_seen", False))
-            room = getattr(character, "room", None)
-            was_in_room = getattr(character, "was_in_room", None)
-            room_vnum = 0
-            if room is not None:
-                room_vnum = int(getattr(room, "vnum", 0) or 0)
-                if room_vnum == int(ROOM_VNUM_LIMBO) and was_in_room is not None:
-                    room_vnum = int(getattr(was_in_room, "vnum", 0) or 0)
-            elif was_in_room is not None:
-                room_vnum = int(getattr(was_in_room, "vnum", 0) or 0)
-            if room_vnum <= 0:
-                room_vnum = int(ROOM_VNUM_TEMPLE)
-            db_char.room_vnum = room_vnum
-            save_objects_for_character(session, character, db_char)
-            session.commit()
+        save_character_to_db(session, character)
+        session.commit()
     except Exception as e:
-        print(f"[ERROR] Failed to save character {character.name}: {e}")
+        print(f"[ERROR] save_character failed for {character.name}: {e}")
     finally:
         if session:
             session.close()
+
+
+def save_character_to_db(session: Session, character: Character) -> None:
+    """Write all character state to the DB row — the canonical DB save path.
+
+    UPDATE-only: the character row must already exist (created via
+    account_service.create_character).  If the row is not found, returns silently.
+
+    Replicates the nontrivial logic from the former mud.persistence.save_character:
+      - room_vnum LIMBO → TEMPLE fallback (mirroring ROM src/save.c:fwrite_char)
+      - played accumulation: base_played + (now - logon) (ROM src/save.c:fwrite_char)
+      - act flags reconciled with ansi_enabled (PlayerFlag.COLOUR bit)
+      - All 71 fields from INV008_REVERSAL_AUDIT §1
+
+    Does NOT commit the session — caller is responsible for session.commit()
+    so multiple saves can be batched.
+
+    ROM Reference: src/save.c fwrite_char / fwrite_pet
+    # mirroring mud/persistence.py:save_character
+    """
+    from mud.models.constants import PlayerFlag
+    from mud.notes import DEFAULT_BOARD_NAME
+
+    db_char = session.query(DBCharacter).filter_by(name=character.name).first()
+    if db_char is None:
+        return  # Character must exist — creation path handles inserts
+
+    pcdata = character.pcdata or __import__("mud.models.character", fromlist=["PCData"]).PCData()
+
+    # --- room_vnum: LIMBO fallback → TEMPLE (mirroring persistence.py:913-932) ---
+    room = getattr(character, "room", None)
+    current_vnum = getattr(room, "vnum", None)
+    if current_vnum == ROOM_VNUM_LIMBO:
+        was_in_room = getattr(character, "was_in_room", None)
+        fallback_vnum = getattr(was_in_room, "vnum", None)
+        if fallback_vnum is not None:
+            try:
+                room_vnum = int(fallback_vnum)
+            except (TypeError, ValueError):
+                room_vnum = ROOM_VNUM_TEMPLE
+        else:
+            room_vnum = ROOM_VNUM_TEMPLE
+    elif current_vnum is None:
+        room_vnum = ROOM_VNUM_TEMPLE
+    else:
+        try:
+            room_vnum = int(current_vnum)
+        except (TypeError, ValueError):
+            room_vnum = ROOM_VNUM_TEMPLE
+
+    # --- played accumulation (mirroring persistence.py:935-946) ---
+    now = int(time.time())
+    try:
+        logon_value = int(getattr(character, "logon", 0) or 0)
+    except (TypeError, ValueError):
+        logon_value = 0
+    try:
+        base_played = int(getattr(character, "played", 0) or 0)
+    except (TypeError, ValueError):
+        base_played = 0
+    session_played = max(0, now - logon_value) if logon_value else 0
+    total_played = max(0, base_played + session_played)
+
+    # --- act flags: reconcile ANSI colour bit (mirroring persistence.py:903-911) ---
+    ansi_enabled = bool(getattr(character, "ansi_enabled", True))
+    act_flags = int(getattr(character, "act", 0))
+    colour_bit = int(PlayerFlag.COLOUR)
+    if ansi_enabled:
+        act_flags |= colour_bit
+    else:
+        act_flags &= ~colour_bit
+
+    # --- scalar fields ---
+    db_char.level = character.level
+    db_char.hp = character.hit  # column is named hp, field is hit
+    db_char.max_hit = character.max_hit
+    db_char.mana = character.mana
+    db_char.move = character.move
+    db_char.room_vnum = room_vnum
+    db_char.race = int(getattr(character, "race", 0))
+    db_char.ch_class = int(getattr(character, "ch_class", 0))
+    db_char.sex = int(getattr(character, "sex", 0))
+    db_char.true_sex = int(getattr(pcdata, "true_sex", 0))
+    db_char.alignment = int(getattr(character, "alignment", 0))
+    db_char.act = act_flags
+    db_char.practice = int(getattr(character, "practice", 0))
+    db_char.train = int(getattr(character, "train", 0))
+    db_char.perm_hit = int(getattr(pcdata, "perm_hit", 0))
+    db_char.perm_mana = int(getattr(pcdata, "perm_mana", 0))
+    db_char.perm_move = int(getattr(pcdata, "perm_move", 0))
+    db_char.gold = int(getattr(character, "gold", 0))
+    db_char.silver = int(getattr(character, "silver", 0))
+    db_char.exp = int(getattr(character, "exp", 0))
+    db_char.trust = int(getattr(character, "trust", 0))
+    db_char.invis_level = int(getattr(character, "invis_level", 0))
+    db_char.incog_level = int(getattr(character, "incog_level", 0))
+    db_char.saving_throw = int(getattr(character, "saving_throw", 0))
+    db_char.hitroll = int(getattr(character, "hitroll", 0))
+    db_char.damroll = int(getattr(character, "damroll", 0))
+    db_char.wimpy = int(getattr(character, "wimpy", 0))
+    db_char.position = int(getattr(character, "position", 8))
+    db_char.played = total_played
+    db_char.logon = logon_value
+    db_char.lines = int(getattr(character, "lines", 22))
+    db_char.prompt = getattr(character, "prompt", None)
+    prefix_value = getattr(character, "prefix", None)
+    db_char.prefix = str(prefix_value) if prefix_value is not None else None
+    db_char.affected_by = int(getattr(character, "affected_by", 0))
+    db_char.comm = int(getattr(character, "comm", 0))
+    db_char.wiznet = int(getattr(character, "wiznet", 0))
+    db_char.log_commands = bool(getattr(character, "log_commands", False))
+    db_char.newbie_help_seen = bool(getattr(character, "newbie_help_seen", False))
+    db_char.pfile_version = 1  # TABLES-001: always ROM-canonical on DB path
+
+    # --- pcdata scalar fields ---
+    db_char.title = getattr(pcdata, "title", None)
+    bamfin = getattr(pcdata, "bamfin", None)
+    db_char.bamfin = str(bamfin) if bamfin is not None else None
+    bamfout = getattr(pcdata, "bamfout", None)
+    db_char.bamfout = str(bamfout) if bamfout is not None else None
+    db_char.security = int(getattr(pcdata, "security", 0))
+    db_char.points = int(getattr(pcdata, "points", 0))
+    db_char.last_level = int(getattr(pcdata, "last_level", 0))
+
+    # --- password_hash sync ---
+    pwd = getattr(pcdata, "pwd", "") or ""
+    if pwd:
+        db_char.password_hash = pwd
+
+    # --- JSON collection fields ---
+    # skills: merge char.skills and pcdata.learned (mirroring persistence.py:898-901)
+    skills_snapshot = _serialize_skill_map(getattr(character, "skills", {}))
+    pcdata.learned = dict(skills_snapshot)
+    db_char.skills = skills_snapshot
+
+    # groups: from pcdata.group_known (mirroring persistence.py:899)
+    groups_snapshot = _serialize_groups(getattr(pcdata, "group_known", ()))
+    pcdata.group_known = tuple(groups_snapshot)
+    db_char.groups = groups_snapshot
+
+    # colours
+    colour_table = _serialize_colour_table(pcdata)
+    db_char.colours = colour_table
+
+    # conditions [drunk, full, thirst, hunger]
+    raw_conditions = list(getattr(pcdata, "condition", []))
+    conditions = [0, 48, 48, 48]
+    for idx, val in enumerate(raw_conditions[:4]):
+        try:
+            conditions[idx] = int(val)
+        except (TypeError, ValueError):
+            pass
+    db_char.conditions = conditions
+
+    # armor and mod_stat
+    db_char.armor = _normalize_int_list(getattr(character, "armor", []), 4)
+    db_char.mod_stat = _normalize_int_list(getattr(character, "mod_stat", []), 5)
+
+    # aliases
+    db_char.aliases = dict(getattr(character, "aliases", {}))
+
+    # board name
+    board_name = getattr(pcdata, "board_name", DEFAULT_BOARD_NAME) or DEFAULT_BOARD_NAME
+    db_char.board = board_name
+
+    # last_notes
+    db_char.last_notes = dict(getattr(pcdata, "last_notes", {}) or {})
+
+    # 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)
+
+    # inventory as JSON blob (Option A from audit §3.1)
+    inventory_list = []
+    for obj in character.inventory:
+        try:
+            obj_save = _serialize_object(obj)
+            # Convert dataclass to dict for JSON storage
+            inventory_list.append(_dataclass_to_dict(obj_save))
+        except Exception:
+            pass
+    db_char.inventory_state = inventory_list
+
+    # equipment as JSON blob (Option A from audit §3.1)
+    equipment_dict = {}
+    for slot, obj in character.equipment.items():
+        try:
+            obj_save = _serialize_object(obj, wear_slot=slot)
+            equipment_dict[slot] = _dataclass_to_dict(obj_save)
+        except Exception:
+            pass
+    db_char.equipment_state = equipment_dict
+
+    # pet as JSON blob (audit §3.1)
+    pet = getattr(character, "pet", None)
+    if pet is not None:
+        try:
+            pet_save = _serialize_pet(pet)
+            if pet_save is not None:
+                db_char.pet_state = _dataclass_to_dict(pet_save)
+            else:
+                db_char.pet_state = None
+        except Exception:
+            db_char.pet_state = None
+    else:
+        db_char.pet_state = 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]
+            val = getattr(obj, f.name)
+            if dataclasses.is_dataclass(val) and not isinstance(val, type):
+                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
+                    for item in val
+                ]
+            elif isinstance(val, dict):
+                result[f.name] = {
+                    k: (_dataclass_to_dict(v) if (dataclasses.is_dataclass(v) and not isinstance(v, type)) else v)
+                    for k, v in val.items()
+                }
+            else:
+                result[f.name] = val
+        return result
+    return obj  # type: ignore[return-value]

mud/account/account_service.py

@@ -1,46 +1,53 @@
 import json
 from collections.abc import Iterable
-from functools import lru_cache
 from dataclasses import dataclass, field
 from enum import Enum
+from functools import lru_cache
 from pathlib import Path
-from typing import Final, Iterable, NamedTuple
+from typing import Final, NamedTuple
 
+from mud.advancement import exp_per_level_for_creation
 from mud.db.models import Character
 from mud.db.session import SessionLocal
 from mud.models.classes import (
     ClassType,
+)
+from mud.models.classes import (
     get_player_class as _get_player_class,
+)
+from mud.models.classes import (
     list_player_classes as _list_player_classes,
 )
 from mud.models.constants import (
-    OBJ_VNUM_SCHOOL_DAGGER,
-    OBJ_VNUM_SCHOOL_MACE,
-    OBJ_VNUM_SCHOOL_SWORD,
-    PlayerFlag,
     ROOM_VNUM_SCHOOL,
+    PlayerFlag,
     Sex,
-    Stat,
 )
 from mud.models.races import (
     PcRaceType,
     RaceType,
+)
+from mud.models.races import (
     get_pc_race as _get_pc_race,
+)
+from mud.models.races import (
     get_race as _get_race,
+)
+from mud.models.races import (
     list_playable_races as _list_playable_races,
 )
+from mud.models.titles import default_title_storage
+from mud.models.weapon_table import weapon_table_entry_by_name
 from mud.security import bans
 from mud.security.bans import BanFlag
 from mud.security.hash_utils import hash_password, verify_password
 from mud.skills.groups import get_group, iter_group_names, list_groups
 from mud.skills.metadata import ROM_SKILL_METADATA, ROM_SKILL_NAMES_BY_INDEX
+from mud.utils import rng_mm
 from mud.world.world_state import (
     is_newlock_enabled,
     is_wizlock_enabled,
 )
-from mud.utils import rng_mm
-
-from mud.advancement import exp_per_level_for_creation
 
 
 class LoginFailureReason(Enum):
@@ -94,13 +101,6 @@ _WEAPON_CHOICES: Final[dict[str, tuple[str, ...]]] = {
     "warrior": ("sword", "mace"),
 }
 
-_WEAPON_VNUMS: Final[dict[str, int]] = {
-    "dagger": OBJ_VNUM_SCHOOL_DAGGER,
-    "mace": OBJ_VNUM_SCHOOL_MACE,
-    "sword": OBJ_VNUM_SCHOOL_SWORD,
-}
-
-
 @lru_cache(maxsize=1)
 def _load_skill_data() -> dict[str, dict[str, object]]:
     """Return ROM skill metadata (type/ratings) keyed by lower-case name."""
@@ -563,7 +563,8 @@ def get_weapon_choices(class_type: ClassType) -> tuple[str, ...]:
 def lookup_weapon_choice(name: str) -> int | None:
     """Map a weapon name from creation prompts to its object vnum."""
 
-    return _WEAPON_VNUMS.get(name.strip().lower())
+    entry = weapon_table_entry_by_name(name)
+    return entry.school_vnum if entry is not None else None
 
 
 def sanitize_account_name(username: str) -> str:
@@ -1062,8 +1063,12 @@ def create_character(
         "perm_move": 100,
         "act": int(PlayerFlag.NOSUMMON),
         "default_weapon_vnum": weapon_vnum,
+        "title": default_title_storage(_class_index_for(selected_class), 1, sex_value),
         "newbie_help_seen": False,
         "creation_points": int(creation_points_value),
+        # mirroring ROM src/nanny.c: the creation point total is persistent
+        # character state, so keep DB-canonical `points` in sync on initial save.
+        "points": int(creation_points_value),
         "creation_groups": json.dumps(list(groups_tuple)),
         "creation_skills": json.dumps(list(skills_tuple)),
     }

mud/advancement.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 import time
 
+from mud.logging import log_game_event
 from mud.math.c_compat import c_div
 from mud.math.stat_apps import con_hitp_bonus, wis_practice_bonus
 from mud.models.character import Character
 from mud.models.classes import CLASS_TABLE, ClassType
 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.wiznet import WiznetFlag, wiznet
 
@@ -138,6 +140,9 @@ def advance_level(char: Character) -> None:
         pcdata.perm_hit = int(getattr(pcdata, "perm_hit", 0) or 0) + hp
         pcdata.perm_mana = int(getattr(pcdata, "perm_mana", 0) or 0) + mana
         pcdata.perm_move = int(getattr(pcdata, "perm_move", 0) or 0) + move
+        from mud.commands.character import set_title
+
+        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):
         hit_suffix = "" if hp == 1 else "s"
@@ -212,10 +217,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):
-        char.level += 1
-        advance_level(char)
         if hasattr(char, "send_to_char"):
             char.send_to_char("{GYou raise a level!!  {x")
+        char.level += 1
+        log_game_event(f"{getattr(char, 'name', 'Someone')} gained level {char.level}")
         wiznet(
             f"$N has attained level {char.level}!",
             char,
@@ -224,6 +229,7 @@ def gain_exp(char: Character, amount: int) -> None:
             None,
             0,
         )
+        advance_level(char)
         # Lazy import to avoid circular dependency
         from mud.account.account_manager import save_character
         save_character(char)

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"
 
@@ -15,6 +16,59 @@ def tick_spell_effects(character: Character) -> list[str]:
     if not isinstance(effects, dict):
         return messages
 
+    affected = getattr(character, "affected", None)
+    if isinstance(affected, list) and affected:
+        touched_names: set[str] = set()
+        ordered_affects = list(affected)
+
+        for index, affect in enumerate(ordered_affects):
+            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)
+                continue
+            if duration < 0:
+                continue
+
+            spell_name = getattr(affect, "type", None)
+            next_affect = ordered_affects[index + 1] if index + 1 < len(ordered_affects) else None
+            should_emit = (
+                next_affect is None
+                or getattr(next_affect, "type", None) != spell_name
+                or int(getattr(next_affect, "duration", 0) or 0) > 0
+            )
+
+            if affect in affected:
+                affected.remove(affect)
+
+            if isinstance(spell_name, str) and spell_name in effects:
+                touched_names.add(spell_name)
+                wear_off = getattr(effects[spell_name], "wear_off_message", None)
+                if should_emit and wear_off:
+                    messages.append(f"{wear_off}{ROM_NEWLINE}")
+
+        for spell_name in touched_names:
+            remaining = [
+                affect
+                for affect in getattr(character, "affected", [])
+                if getattr(affect, "type", None) == spell_name
+            ]
+            if remaining:
+                primary = remaining[0]
+                effect = effects.get(spell_name)
+                if effect is not None:
+                    effect.duration = int(getattr(primary, "duration", 0) or 0)
+                    effect.level = int(getattr(primary, "level", 0) or 0)
+                continue
+            character.remove_spell_effect(spell_name)
+
+        return messages
+
     for name, effect in list(effects.items()):
         duration = int(getattr(effect, "duration", 0) or 0)
         if duration > 0: