rom24-quickmud-python 1.2.2__py3-none-any.whl

mud/__main__.py

@@ -0,0 +1,40 @@
+import asyncio
+import typer
+from mud.server import run_game_loop
+from mud.db.migrations import run_migrations
+from mud.net.telnet_server import start_server as start_telnet
+from mud.network.websocket_server import run as start_websocket
+
+cli = typer.Typer()
+
+@cli.command()
+def runserver():
+    """Start the main game server."""
+    run_game_loop()
+
+
+@cli.command()
+def migrate():
+    """Run database migrations."""
+    run_migrations()
+
+
+@cli.command()
+def loadtestuser():
+    """Load a default test account and character."""
+    from mud.scripts.load_test_data import load_test_user
+    load_test_user()
+
+
+@cli.command()
+def socketserver(host: str = "0.0.0.0", port: int = 5000):
+    """Start the telnet server."""
+    asyncio.run(start_telnet(host=host, port=port))
+
+@cli.command()
+def websocketserver(host: str = "0.0.0.0", port: int = 8000):
+    """Start the websocket server."""
+    start_websocket(host=host, port=port)
+
+if __name__ == "__main__":
+    cli()

mud/account/__init__.py

@@ -0,0 +1,20 @@
+"""Account management utilities."""
+
+from .account_manager import load_character, save_character
+from .account_service import (
+    create_account,
+    login,
+    login_with_host,
+    list_characters,
+    create_character,
+)
+
+__all__ = [
+    "load_character",
+    "save_character",
+    "create_account",
+    "login",
+    "login_with_host",
+    "list_characters",
+    "create_character",
+]

mud/account/account_manager.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from mud.db.session import SessionLocal
+from mud.db.models import Character as DBCharacter, PlayerAccount
+from mud.models.character import Character, from_orm
+from mud.models.conversion import (
+    load_objects_for_character,
+    save_objects_for_character,
+)
+
+
+def load_character(username: str, char_name: str) -> Optional[Character]:
+    session = None
+    try:
+        session = SessionLocal()
+        db_char = (
+            session.query(DBCharacter)
+            .join(PlayerAccount)
+            .filter(
+                DBCharacter.name == char_name,
+                PlayerAccount.username == username,
+            )
+            .first()
+        )
+        char = from_orm(db_char) if db_char else None
+        if char and db_char:
+            db_char.player  # load relationship
+            char.inventory, char.equipment = load_objects_for_character(
+                db_char
+            )
+        return char
+    except Exception as e:
+        print(f"[ERROR] Failed to load character {char_name}: {e}")
+        return None
+    finally:
+        if session:
+            session.close()
+
+
+def save_character(character: Character) -> None:
+    session = None
+    try:
+        session = SessionLocal()
+        db_char = (
+            session.query(DBCharacter)
+            .filter_by(name=character.name)
+            .first()
+        )
+        if db_char:
+            db_char.level = character.level
+            db_char.hp = character.hit
+            if getattr(character, "room", None):
+                db_char.room_vnum = character.room.vnum
+            save_objects_for_character(session, character, db_char)
+            session.commit()
+    except Exception as e:
+        print(f"[ERROR] Failed to save character {character.name}: {e}")
+    finally:
+        if session:
+            session.close()

mud/account/account_service.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Optional, List
+
+from mud.db.session import SessionLocal
+from mud.db.models import PlayerAccount, Character
+from mud.security.hash_utils import hash_password, verify_password
+from mud.security import bans
+
+
+def create_account(username: str, raw_password: str) -> bool:
+    """Create a new PlayerAccount if username is available."""
+    session = SessionLocal()
+    if session.query(PlayerAccount).filter_by(username=username).first():
+        session.close()
+        return False
+    account = PlayerAccount(
+        username=username,
+        password_hash=hash_password(raw_password),
+    )
+    session.add(account)
+    session.commit()
+    session.close()
+    return True
+
+
+def login(username: str, raw_password: str) -> Optional[PlayerAccount]:
+    """Return PlayerAccount if credentials match."""
+    # Enforce account-name bans irrespective of host.
+    if bans.is_account_banned(username):
+        return None
+    session = SessionLocal()
+    account = session.query(PlayerAccount).filter_by(username=username).first()
+    if account and verify_password(raw_password, account.password_hash):
+        # pre-load characters before detaching
+        account.characters  # type: ignore[unused-any]
+        session.expunge(account)
+        session.close()
+        return account
+    session.close()
+    return None
+
+
+def login_with_host(
+    username: str, raw_password: str, host: str | None
+) -> Optional[PlayerAccount]:
+    """Login that also enforces site bans.
+
+    This wrapper checks both account and host bans and only then delegates to
+    the standard login function.
+    """
+    if bans.is_host_banned(host):
+        return None
+    return login(username, raw_password)
+
+
+def list_characters(account: PlayerAccount) -> List[str]:
+    """Return list of character names for this account."""
+    return [char.name for char in getattr(account, "characters", [])]
+
+
+def create_character(
+    account: PlayerAccount, name: str, starting_room_vnum: int = 3001
+) -> bool:
+    """Create a new character for the account."""
+    session = SessionLocal()
+    if session.query(Character).filter_by(name=name).first():
+        session.close()
+        return False
+    new_char = Character(
+        name=name,
+        level=1,
+        hp=100,
+        room_vnum=starting_room_vnum,
+        player_id=account.id,
+    )
+    session.add(new_char)
+    session.commit()
+    session.close()
+    return True

mud/advancement.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from mud.models.character import Character
+
+BASE_XP_PER_LEVEL = 1000
+
+# Multipliers roughly mirroring ROM class/race adjustments.
+# Index by `ch_class` or `race` id; default to 1.0 if not found.
+CLASS_XP_MOD = {
+    0: 1.0,  # mage
+    1: 1.0,  # cleric
+    2: 1.1,  # thief
+    3: 1.2,  # warrior
+}
+
+RACE_XP_MOD = {
+    0: 1.0,  # human
+    1: 1.1,  # elf
+    2: 0.9,  # dwarf
+}
+
+# Per-class stat gains applied on level-up: (hp, mana, move)
+LEVEL_BONUS = {
+    0: (8, 6, 4),  # mage
+    1: (6, 8, 4),  # cleric
+    2: (7, 6, 5),  # thief
+    3: (10, 4, 6),  # warrior
+}
+
+PRACTICES_PER_LEVEL = 2
+TRAINS_PER_LEVEL = 1
+
+def exp_per_level(char: Character) -> int:
+    """Base experience required for a single level."""
+    class_mod = CLASS_XP_MOD.get(char.ch_class, 1.0)
+    race_mod = RACE_XP_MOD.get(char.race, 1.0)
+    return int(BASE_XP_PER_LEVEL * class_mod * race_mod)
+
+
+def advance_level(char: Character) -> None:
+    """Increase hit points, mana, move, practices, and trains."""
+    hp, mana, move = LEVEL_BONUS.get(char.ch_class, (8, 6, 5))
+    char.max_hit += hp
+    char.max_mana += mana
+    char.max_move += move
+    char.practice += PRACTICES_PER_LEVEL
+    char.train += TRAINS_PER_LEVEL
+
+def gain_exp(char: Character, amount: int) -> None:
+    """Grant experience and handle level ups.
+
+    Experience required to reach *n* is ``exp_per_level(char) * n``.
+    The character's ``exp`` tracks total lifetime experience.
+    """
+    if amount <= 0:
+        return
+    char.exp += amount
+    # Level up while total exp meets threshold for next level.
+    while char.exp >= exp_per_level(char) * (char.level + 1):
+        char.level += 1
+        advance_level(char)
+

mud/affects/saves.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from mud.math.c_compat import c_div, urange
+from mud.models.character import Character
+from mud.models.constants import AffectFlag, DamageType, DefenseBit
+from mud.utils import rng_mm
+
+
+# Minimal fMana mapping from ROM const.c order: mage, cleric → True; thief, warrior → False
+FMANA_BY_CLASS = {
+    0: True,  # mage
+    1: True,  # cleric
+    2: False,  # thief
+    3: False,  # warrior
+}
+
+
+def _check_immune(victim: Character, dam_type: int) -> int:
+    """ROM-compatible check_immune.
+
+    Returns one of: IS_NORMAL=0, IS_IMMUNE=1, IS_RESISTANT=2, IS_VULNERABLE=3.
+    Mirrors src/handler.c:check_immune with globals (WEAPON/MAGIC) and per-type bits.
+    """
+    IS_NORMAL = 0
+    IS_IMMUNE = 1
+    IS_RESISTANT = 2
+    IS_VULNERABLE = 3
+
+    if dam_type == DamageType.NONE:
+        return -1
+
+    # Default from global WEAPON/MAGIC flags
+    if dam_type <= DamageType.SLASH:
+        if victim.imm_flags & DefenseBit.WEAPON:
+            default = IS_IMMUNE
+        elif victim.res_flags & DefenseBit.WEAPON:
+            default = IS_RESISTANT
+        elif victim.vuln_flags & DefenseBit.WEAPON:
+            default = IS_VULNERABLE
+        else:
+            default = IS_NORMAL
+    else:
+        if victim.imm_flags & DefenseBit.MAGIC:
+            default = IS_IMMUNE
+        elif victim.res_flags & DefenseBit.MAGIC:
+            default = IS_RESISTANT
+        elif victim.vuln_flags & DefenseBit.MAGIC:
+            default = IS_VULNERABLE
+        else:
+            default = IS_NORMAL
+
+    # Map dam_type to specific IMM_* bit
+    bit = None
+    dt = DamageType(dam_type)
+    mapping = {
+        DamageType.BASH: DefenseBit.BASH,
+        DamageType.PIERCE: DefenseBit.PIERCE,
+        DamageType.SLASH: DefenseBit.SLASH,
+        DamageType.FIRE: DefenseBit.FIRE,
+        DamageType.COLD: DefenseBit.COLD,
+        DamageType.LIGHTNING: DefenseBit.LIGHTNING,
+        DamageType.ACID: DefenseBit.ACID,
+        DamageType.POISON: DefenseBit.POISON,
+        DamageType.NEGATIVE: DefenseBit.NEGATIVE,
+        DamageType.HOLY: DefenseBit.HOLY,
+        DamageType.ENERGY: DefenseBit.ENERGY,
+        DamageType.MENTAL: DefenseBit.MENTAL,
+        DamageType.DISEASE: DefenseBit.DISEASE,
+        DamageType.DROWNING: DefenseBit.DROWNING,
+        DamageType.LIGHT: DefenseBit.LIGHT,
+        DamageType.CHARM: DefenseBit.CHARM,
+        DamageType.SOUND: DefenseBit.SOUND,
+    }
+    bit = mapping.get(dt)
+    if bit is None:
+        return default
+
+    immune = -1
+    if victim.imm_flags & bit:
+        immune = IS_IMMUNE
+    elif (victim.res_flags & bit) and immune != IS_IMMUNE:
+        immune = IS_RESISTANT
+    elif victim.vuln_flags & bit:
+        if immune == IS_IMMUNE:
+            immune = IS_RESISTANT
+        elif immune == IS_RESISTANT:
+            immune = IS_NORMAL
+        else:
+            immune = IS_VULNERABLE
+
+    return default if immune == -1 else immune
+
+
+def saves_spell(level: int, victim: Character, dam_type: int) -> bool:
+    """Compute ROM-like saving throw outcome.
+
+    Mirrors src/magic.c:saves_spell() logic:
+    - base: 50 + (victim.level - level) * 5 - victim.saving_throw * 2
+    - berserk: + victim.level/2 (C integer division)
+    - immunity/resistance/vulnerability adjustments (stubbed to normal for now)
+    - player classes with fMana: save = 9*save/10 (C division)
+    - clamp 5..95, succeed if number_percent() < save
+    """
+    save = 50 + (victim.level - level) * 5 - victim.saving_throw * 2
+
+    if victim.has_affect(AffectFlag.BERSERK):
+        save += c_div(victim.level, 2)
+
+    riv = _check_immune(victim, dam_type)
+    # IS_IMMUNE(1) → auto success; IS_RESISTANT(2) → +2; IS_VULNERABLE(3) → -2
+    if riv == 1:
+        return True
+    if riv == 2:
+        save += 2
+    elif riv == 3:
+        save -= 2
+
+    # Not NPC → apply fMana reduction if class gains mana
+    if FMANA_BY_CLASS.get(victim.ch_class, False):
+        save = c_div(9 * save, 10)
+
+    save = urange(5, save, 95)
+    return rng_mm.number_percent() < save

mud/agent/agent_protocol.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List
+
+
+class AgentInterface(ABC):
+    @abstractmethod
+    def get_observation(self) -> Dict:
+        """Return structured game state view."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_available_actions(self) -> List[str]:
+        """Return a list of valid actions the agent can choose from."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def perform_action(self, action: str, args: List[str]) -> str:
+        """Execute an action in-game. Returns textual feedback."""
+        raise NotImplementedError

mud/agent/character_agent.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from typing import List
+
+from mud.models.character import Character
+from mud.agent.agent_protocol import AgentInterface
+from mud.world.movement import move_character
+from mud.commands.communication import do_say
+from mud.commands.inventory import do_get, do_drop
+
+
+class CharacterAgentAdapter(AgentInterface):
+    def __init__(self, character: Character):
+        self.character = character
+
+    def get_observation(self):
+        room = self.character.room
+        return {
+            "name": self.character.name,
+            "room": {
+                "vnum": room.vnum if room else None,
+                "name": getattr(room, "name", None),
+                "description": getattr(room, "description", None),
+                "npcs": [getattr(npc, "name", None) for npc in getattr(room, "people", []) if npc is not self.character],
+                "players": [p.name for p in getattr(room, "people", []) if getattr(p, "name", None) and hasattr(p, "messages") and p is not self.character],
+                "exits": [i for i, ex in enumerate(getattr(room, "exits", [])) if ex],
+            } if room else None,
+            "inventory": [obj.short_descr or obj.name for obj in self.character.inventory],
+            "equipment": {slot: obj.short_descr or obj.name for slot, obj in self.character.equipment.items()},
+            "hp": getattr(self.character, "hit", 0),
+            "level": getattr(self.character, "level", 0),
+        }
+
+    def get_available_actions(self) -> List[str]:
+        return ["move", "say", "pickup", "drop", "equip", "attack"]
+
+    def perform_action(self, action: str, args: List[str]) -> str:
+        try:
+            if action == "move":
+                direction = args[0]
+                return move_character(self.character, direction)
+            elif action == "say":
+                return do_say(self.character, " ".join(args))
+            elif action == "pickup":
+                return do_get(self.character, args[0])
+            elif action == "drop":
+                return do_drop(self.character, args[0])
+            elif action == "equip":
+                item_name = args[0]
+                slot = args[1] if len(args) > 1 else "wield"
+                for obj in list(self.character.inventory):
+                    obj_name = (obj.short_descr or obj.name or "").lower()
+                    if item_name.lower() in obj_name:
+                        self.character.equip_object(obj, slot)
+                        return f"Equipped {obj_name} on {slot}"
+                return "Item not found."
+            elif action == "attack":
+                return "Attack not implemented"
+            else:
+                return f"Unknown action: {action}"
+        except Exception as e:
+            return f"⚠️ Error: {str(e)}"

mud/combat/__init__.py

@@ -0,0 +1,3 @@
+"""Combat engine utilities."""
+from .engine import attack_round
+__all__ = ["attack_round"]

mud/combat/engine.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from mud.models.character import Character
+from mud.models.constants import (
+    Position,
+    DamageType,
+    AC_PIERCE,
+    AC_BASH,
+    AC_SLASH,
+    AC_EXOTIC,
+)
+from mud.utils import rng_mm
+from mud.math.c_compat import c_div
+from mud.affects.saves import _check_immune as _riv_check
+from mud.math.c_compat import urange
+from mud.models.constants import AffectFlag
+from mud.config import COMBAT_USE_THAC0
+
+
+def attack_round(attacker: Character, victim: Character) -> str:
+    """Resolve a single attack round.
+
+    The attacker attempts to hit the victim.  Hit chance is derived from a
+    base 50% modified by the attacker's ``hitroll``.  Successful hits apply
+    ``damroll`` damage.  Living combatants are placed into FIGHTING position.
+    If the victim dies, they are removed from the room and their position set
+    to ``DEAD``.
+    """
+
+    attacker.position = Position.FIGHTING
+    # Capture victim's pre-attack position for ROM-like modifiers
+    _victim_pos_before = victim.position
+    victim.position = Position.FIGHTING
+
+    dam_type = attacker.dam_type or int(DamageType.BASH)
+    ac_idx = ac_index_for_dam_type(dam_type)
+    victim_ac = 0
+    if hasattr(victim, "armor") and 0 <= ac_idx < len(victim.armor):
+        victim_ac = victim.armor[ac_idx]
+    # Visibility and position modifiers (ROM-inspired)
+    if getattr(victim, "has_affect", None) and victim.has_affect(AffectFlag.INVISIBLE):
+        victim_ac -= 4
+    if _victim_pos_before < Position.FIGHTING:
+        victim_ac += 4
+    if _victim_pos_before < Position.RESTING:
+        victim_ac += 6
+
+    if COMBAT_USE_THAC0:
+        # ROM diceroll using number_bits(5) until < 20
+        while True:
+            diceroll = rng_mm.number_bits(5)
+            if diceroll < 20:
+                break
+        # Compute class-based thac0 with hitroll/skill contributions
+        th = compute_thac0(attacker.level, attacker.ch_class, hitroll=attacker.hitroll, skill=100)
+        vac = c_div(victim_ac, 10)
+        # Miss if nat 0 or (not 19 and diceroll < thac0 - victim_ac)
+        if diceroll == 0 or (diceroll != 19 and diceroll < (th - vac)):
+            return f"You miss {victim.name}."
+    else:
+        # Percent model kept for parity stability outside feature flag
+        to_hit = 50 + attacker.hitroll
+        # Use C-style division for negative AC to match ROM semantics
+        to_hit += c_div(victim_ac, 2)
+        to_hit = urange(5, to_hit, 100)
+        if rng_mm.number_percent() > to_hit:
+            return f"You miss {victim.name}."
+
+    # Defense checks in ROM order: shield block → parry → dodge.
+    if check_shield_block(attacker, victim):
+        return f"{victim.name} blocks your attack with a shield."
+    if check_parry(attacker, victim):
+        return f"{victim.name} parries your attack."
+    if check_dodge(attacker, victim):
+        return f"{victim.name} dodges your attack."
+
+    damage = max(1, attacker.damroll)
+    # Apply RIV (IMMUNE/RESIST/VULN) scaling before any side-effects.
+    dam_type = attacker.dam_type or int(DamageType.BASH)
+    riv = _riv_check(victim, dam_type)
+    if riv == 1:  # IS_IMMUNE
+        damage = 0
+    elif riv == 2:  # IS_RESISTANT: dam -= dam/3 (ROM)
+        damage = damage - c_div(damage, 3)
+    elif riv == 3:  # IS_VULNERABLE: dam += dam/2 (ROM)
+        damage = damage + c_div(damage, 2)
+
+    # Invoke any on-hit effects with scaled damage (can be monkeypatched in tests).
+    on_hit_effects(attacker, victim, damage)
+    victim.hit -= damage
+    if victim.hit <= 0:
+        victim.hit = 0
+        victim.position = Position.DEAD
+        attacker.position = Position.STANDING
+        if getattr(victim, "room", None):
+            victim.room.broadcast(f"{victim.name} is DEAD!!!", exclude=victim)
+            victim.room.remove_character(victim)
+        return f"You kill {victim.name}."
+    return f"You hit {victim.name} for {damage} damage."
+
+
+def on_hit_effects(attacker: Character, victim: Character, damage: int) -> None:  # pragma: no cover - default no-op
+    """Hook for on-hit side-effects; receives RIV-scaled damage."""
+    return None
+
+
+# --- Defense checks (override in tests as needed) ---
+def check_shield_block(attacker: Character, victim: Character) -> bool:
+    """Basic shield block chance using victim.shield_block_chance (percent).
+
+    Defaults to 0 if not set. Uses rng_mm.number_percent() ≤ chance.
+    """
+    chance = getattr(victim, "shield_block_chance", 0) or 0
+    if chance <= 0:
+        return False
+    return rng_mm.number_percent() <= chance
+
+
+def check_parry(attacker: Character, victim: Character) -> bool:
+    """Basic parry chance using victim.parry_chance (percent)."""
+    chance = getattr(victim, "parry_chance", 0) or 0
+    if chance <= 0:
+        return False
+    return rng_mm.number_percent() <= chance
+
+
+def check_dodge(attacker: Character, victim: Character) -> bool:
+    """Basic dodge chance using victim.dodge_chance (percent)."""
+    chance = getattr(victim, "dodge_chance", 0) or 0
+    if chance <= 0:
+        return False
+    return rng_mm.number_percent() <= chance
+
+
+# --- AC mapping helpers ---
+def ac_index_for_dam_type(dam_type: int) -> int:
+    """Map a damage type to the correct AC index.
+
+    ROM maps: PIERCE→AC_PIERCE, BASH→AC_BASH, SLASH→AC_SLASH, everything else→AC_EXOTIC.
+    Unarmed (NONE) is treated as BASH.
+    """
+    dt = DamageType(dam_type) if not isinstance(dam_type, DamageType) else dam_type
+    if dt == DamageType.PIERCE:
+        return AC_PIERCE
+    if dt == DamageType.BASH or dt == DamageType.NONE:
+        return AC_BASH
+    if dt == DamageType.SLASH:
+        return AC_SLASH
+    return AC_EXOTIC
+
+
+def is_better_ac(ac_a: int, ac_b: int) -> bool:
+    """Return True if ac_a is better protection than ac_b (more negative)."""
+    return ac_a < ac_b
+
+
+# --- THAC0 interpolation (ROM-inspired) ---
+# Class ids align with FMANA mapping used elsewhere: 0:mage, 1:cleric, 2:thief, 3:warrior
+THAC0_TABLE: dict[int, tuple[int, int]] = {
+    0: (20, 6),    # mage
+    1: (20, 2),    # cleric
+    2: (20, -4),   # thief
+    3: (20, -10),  # warrior
+}
+
+
+def interpolate(level: int, v00: int, v32: int) -> int:
+    """ROM-like integer interpolate between level 0 and 32 using C division."""
+    return v00 + c_div((v32 - v00) * level, 32)
+
+
+def compute_thac0(level: int, ch_class: int, *, hitroll: int = 0, skill: int = 100) -> int:
+    """Compute THAC0 following ROM fight.c adjustments.
+
+    - interpolate(level, thac0_00, thac0_32)
+    - if thac0 < 0: thac0 = thac0 / 2 (C div)
+    - if thac0 < -5: thac0 = -5 + (thac0 + 5)/2 (C div)
+    - thac0 -= hitroll * skill / 100
+    - thac0 += 5 * (100 - skill) / 100
+    """
+    t00, t32 = THAC0_TABLE.get(ch_class, (20, 6))
+    th = interpolate(level, t00, t32)
+    if th < 0:
+        th = c_div(th, 2)
+    if th < -5:
+        th = -5 + c_div(th + 5, 2)
+    th -= c_div(hitroll * skill, 100)
+    th += c_div(5 * (100 - skill), 100)
+    return th

mud/commands/__init__.py

@@ -0,0 +1,3 @@
+from .dispatcher import process_command, run_test_session
+
+__all__ = ["process_command", "run_test_session"]