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

mud/db/models.py

@@ -0,0 +1,98 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, Boolean
+from sqlalchemy.orm import relationship, declarative_base
+
+Base = declarative_base()
+
+class Area(Base):
+    __tablename__ = "areas"
+    id = Column(Integer, primary_key=True)
+    vnum = Column(Integer, unique=True)
+    name = Column(String)
+    min_vnum = Column(Integer)
+    max_vnum = Column(Integer)
+    rooms = relationship("Room", back_populates="area")
+
+class Room(Base):
+    __tablename__ = "rooms"
+    id = Column(Integer, primary_key=True)
+    vnum = Column(Integer, unique=True)
+    name = Column(String)
+    description = Column(String)
+    sector_type = Column(Integer)
+    room_flags = Column(Integer)
+    area_id = Column(Integer, ForeignKey("areas.id"))
+    area = relationship("Area", back_populates="rooms")
+    exits = relationship("Exit", back_populates="room")
+
+class Exit(Base):
+    __tablename__ = "exits"
+    id = Column(Integer, primary_key=True)
+    room_id = Column(Integer, ForeignKey("rooms.id"))
+    direction = Column(String)
+    to_room_vnum = Column(Integer)
+    room = relationship("Room", back_populates="exits")
+
+class MobPrototype(Base):
+    __tablename__ = "mob_prototypes"
+    id = Column(Integer, primary_key=True)
+    vnum = Column(Integer, unique=True)
+    name = Column(String)
+    short_desc = Column(String)
+    long_desc = Column(String)
+    level = Column(Integer)
+    alignment = Column(Integer)
+
+class ObjPrototype(Base):
+    __tablename__ = "obj_prototypes"
+    id = Column(Integer, primary_key=True)
+    vnum = Column(Integer, unique=True)
+    name = Column(String)
+    short_desc = Column(String)
+    long_desc = Column(String)
+    item_type = Column(Integer)
+    flags = Column(Integer)
+    value0 = Column(Integer)
+    value1 = Column(Integer)
+    value2 = Column(Integer)
+    value3 = Column(Integer)
+
+
+class ObjectInstance(Base):
+    __tablename__ = "object_instances"
+    id = Column(Integer, primary_key=True)
+    prototype_vnum = Column(Integer, ForeignKey("obj_prototypes.vnum"))
+    location = Column(String)
+    character_id = Column(Integer, ForeignKey("characters.id"))
+
+    prototype = relationship("ObjPrototype")
+    character = relationship("Character", back_populates="objects")
+
+
+class PlayerAccount(Base):
+    __tablename__ = "player_accounts"
+    id = Column(Integer, primary_key=True)
+    username = Column(String, unique=True)
+    email = Column(String)
+    password_hash = Column(String)
+    is_admin = Column(Boolean, default=False)
+
+    characters = relationship("Character", back_populates="player")
+    
+    def set_password(self, password: str):
+        """Set the password hash for this account."""
+        from mud.security.hash_utils import hash_password
+        self.password_hash = hash_password(password)
+
+
+class Character(Base):
+    __tablename__ = "characters"
+    id = Column(Integer, primary_key=True)
+    name = Column(String, unique=True)
+    level = Column(Integer)
+    hp = Column(Integer)
+    room_vnum = Column(Integer)
+
+    player_id = Column(Integer, ForeignKey("player_accounts.id"))
+    player = relationship("PlayerAccount", back_populates="characters")
+    objects = relationship("ObjectInstance", back_populates="character")
+

mud/db/seed.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from mud.db.session import SessionLocal
+from mud.db.models import PlayerAccount, Character
+from mud.security.hash_utils import hash_password
+
+
+def create_test_account():
+    session = SessionLocal()
+    if session.query(PlayerAccount).filter_by(username="admin").first():
+        session.close()
+        return
+    account = PlayerAccount(
+        username="admin",
+        password_hash=hash_password("admin"),
+        is_admin=True,
+    )
+    char = Character(
+        name="Testman",
+        level=1,
+        hp=100,
+        room_vnum=3001,
+        player=account,
+    )
+    session.add(account)
+    session.add(char)
+    session.commit()
+    session.close()

mud/db/session.py

@@ -0,0 +1,11 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///mud.db")
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {},
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

mud/devtools/agent_demo.py

@@ -0,0 +1,19 @@
+from mud.registry import room_registry, mob_registry
+from mud.spawning.mob_spawner import spawn_mob
+from mud.agent.character_agent import CharacterAgentAdapter
+
+
+def run_agent_demo() -> None:
+    room = room_registry.get(3001)
+    proto_vnum = next(iter(mob_registry)) if mob_registry else None
+    if proto_vnum is None or room is None:
+        print("World not initialized or no mobs available")
+        return
+    mob = spawn_mob(proto_vnum)
+    if not mob:
+        print("Failed to spawn mob")
+        return
+    adapter = CharacterAgentAdapter(mob)
+    room.add_mob(mob)
+    print(adapter.get_observation())
+    print(adapter.perform_action("say", ["I", "am", "alive!"]))

mud/entrypoint.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from mud.account.account_service import create_account, login
+
+
+def prompt_login():
+    print("Welcome to the Realm.")
+    username = input("Username: ")
+    password = input("Password: ")
+
+    account = login(username, password)
+    if not account:
+        print("❌ Invalid login.")
+        return None
+
+    print(f"✅ Logged in as {username}")
+    return account
+
+
+def prompt_account_creation():
+    print("Create your account:")
+    username = input("Username: ")
+    password = input("Password: ")
+    confirm = input("Confirm Password: ")
+    if password != confirm:
+        print("❌ Passwords do not match.")
+        return None
+
+    success = create_account(username, password)
+    if success:
+        print("✅ Account created.")
+    else:
+        print("❌ Username already taken.")
+    return success

mud/game_loop.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, List
+
+from mud.models.character import Character, character_registry
+from mud.skills.registry import skill_registry
+from mud.spawning.reset_handler import reset_tick
+from mud.time import time_info
+from mud.config import get_pulse_tick, get_pulse_violence, GAME_LOOP_STRICT_POINT
+from mud.net.protocol import broadcast_global
+from mud.logging.admin import rotate_admin_log
+from mud.spec_funs import run_npc_specs
+
+
+@dataclass
+class WeatherState:
+    """Very small placeholder for global weather."""
+    sky: str = "sunny"
+
+
+weather = WeatherState()
+
+
+@dataclass
+class TimedEvent:
+    ticks: int
+    callback: Callable[[], None]
+
+
+events: List[TimedEvent] = []
+
+
+def schedule_event(ticks: int, callback: Callable[[], None]) -> None:
+    """Schedule a callback to run after a number of ticks."""
+    events.append(TimedEvent(ticks, callback))
+
+
+def event_tick() -> None:
+    """Advance timers and fire ready callbacks."""
+    for ev in events[:]:
+        ev.ticks -= 1
+        if ev.ticks <= 0:
+            ev.callback()
+            events.remove(ev)
+
+
+def regen_character(ch: Character) -> None:
+    """Apply a single tick of regeneration to a character."""
+    ch.hit = min(ch.max_hit, ch.hit + 1)
+    ch.mana = min(ch.max_mana, ch.mana + 1)
+    ch.move = min(ch.max_move, ch.move + 1)
+    skill_registry.tick(ch)
+
+
+def regen_tick() -> None:
+    for ch in list(character_registry):
+        regen_character(ch)
+
+
+_WEATHER_STATES = ["sunny", "cloudy", "rainy"]
+
+
+def weather_tick() -> None:
+    """Cycle through simple weather states."""
+    index = _WEATHER_STATES.index(weather.sky)
+    weather.sky = _WEATHER_STATES[(index + 1) % len(_WEATHER_STATES)]
+
+
+def time_tick() -> None:
+    """Advance world time and broadcast day/night transitions."""
+    messages = time_info.advance_hour()
+    if time_info.hour == 0:
+        try:
+            rotate_admin_log()
+        except Exception:
+            pass
+    for message in messages:
+        broadcast_global(message, channel="info")
+
+
+_pulse_counter = 0
+_violence_counter = 0
+
+
+def violence_tick() -> None:
+    """Violence cadence updates: decrement wait/daze counters."""
+    for ch in list(character_registry):
+        ch.wait = max(0, int(getattr(ch, "wait", 0)) - 1)
+        # daze is optional in some tests; default to attr when present
+        if hasattr(ch, "daze"):
+            ch.daze = max(0, int(getattr(ch, "daze", 0)) - 1)
+
+
+def game_tick() -> None:
+    """Run a full game tick: time, regen, weather, timed events, and resets."""
+    global _pulse_counter, _violence_counter
+    _pulse_counter += 1
+    # Violence cadence: decrement wait/daze on PULSE_VIOLENCE boundaries
+    # This mirrors ROM's update_handler calling violence_update.
+    _violence_counter += 1
+    if _violence_counter % get_pulse_violence() == 0:
+        violence_tick()
+    # Advance time/weather/resets on point pulses, preserving legacy behavior when not strict
+    point_pulse = (_pulse_counter % get_pulse_tick() == 0)
+    if point_pulse:
+        time_tick()
+        weather_tick()
+        reset_tick()
+    else:
+        if not GAME_LOOP_STRICT_POINT:
+            weather_tick()
+            reset_tick()
+    regen_tick()
+    event_tick()
+    # Invoke NPC special functions after resets to mirror ROM's update cadence
+    run_npc_specs()

mud/imc/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import os
+
+
+def imc_enabled() -> bool:
+    """Feature flag for IMC. Disabled by default."""
+    return os.getenv("IMC_ENABLED", "false").lower() in {"1", "true", "yes"}
+
+
+def maybe_open_socket() -> None:
+    """No-op when IMC is disabled. Never opens sockets in disabled mode."""
+    if not imc_enabled():
+        return None
+    # Intentionally unimplemented: networking is out of scope for P0 stub.
+    raise NotImplementedError("IMC networking not implemented in stub")
+

mud/imc/protocol.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Frame:
+    """Minimal IMC-like frame for testing parser/serializer.
+
+    Format (text line):
+      "<type> <from> <to> :<message>"
+    Example:
+      "chat alice@quickmud * :Hello world"
+    """
+
+    type: str
+    source: str
+    target: str
+    message: str
+
+
+def parse_frame(line: str) -> Frame:
+    parts = line.strip().split(" ", 3)
+    if len(parts) < 4 or not parts[3].startswith(":"):
+        raise ValueError("invalid IMC frame: expected '<type> <from> <to> :<message>'")
+    ftype, source, target, msg = parts
+    return Frame(type=ftype, source=source, target=target, message=msg[1:])
+
+
+def serialize_frame(frame: Frame) -> str:
+    return f"{frame.type} {frame.source} {frame.target} :{frame.message}"
+

mud/loaders/__init__.py

@@ -0,0 +1,27 @@
+from .area_loader import load_area_file
+from .json_area_loader import load_all_areas_from_json
+from pathlib import Path
+
+from mud.registry import area_registry, room_registry, mob_registry, obj_registry, shop_registry
+
+
+def load_all_areas(list_path: str = "area/area.lst"):
+    # Clear all registries before loading to prevent conflicts
+    area_registry.clear()
+    room_registry.clear()
+    mob_registry.clear()
+    obj_registry.clear()
+    shop_registry.clear()
+    sentinel_found = False
+    with open(list_path, 'r', encoding='latin-1') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            if line == '$':
+                sentinel_found = True
+                break
+            path = Path('area') / line
+            load_area_file(str(path))
+    if not sentinel_found:
+        raise ValueError("area.lst missing '$' sentinel")

mud/loaders/area_loader.py

@@ -0,0 +1,73 @@
+from .base_loader import BaseTokenizer
+from .room_loader import load_rooms
+from .mob_loader import load_mobiles
+from .obj_loader import load_objects
+from .reset_loader import load_resets
+from .shop_loader import load_shops
+from .specials_loader import load_specials
+from mud.models.area import Area
+from mud.registry import area_registry
+
+SECTION_HANDLERS = {
+    "#ROOMS": load_rooms,
+    "#MOBILES": load_mobiles,
+    "#OBJECTS": load_objects,
+    "#RESETS": load_resets,
+    "#SHOPS": load_shops,
+    "#SPECIALS": load_specials,
+}
+
+
+def load_area_file(filepath: str) -> Area:
+    with open(filepath, 'r', encoding='latin-1') as f:
+        lines = f.readlines()
+    tokenizer = BaseTokenizer(lines)
+    area = Area()
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        if line == '#AREA':
+            area.file_name = tokenizer.next_line().rstrip('~')
+            area.name = tokenizer.next_line().rstrip('~')
+            area.credits = tokenizer.next_line().rstrip('~')
+            vnums = tokenizer.next_line()
+            if vnums:
+                parts = vnums.split()
+                if len(parts) >= 2:
+                    area.min_vnum = int(parts[0])
+                    area.max_vnum = int(parts[1])
+        elif line in SECTION_HANDLERS:
+            handler = SECTION_HANDLERS[line]
+            handler(tokenizer, area)
+        elif line == "#AREADATA":
+            while True:
+                peek = tokenizer.peek_line()
+                if peek is None or peek.startswith('#'):
+                    break
+                data_line = tokenizer.next_line()
+                if data_line.startswith('Builders'):
+                    area.builders = data_line.split(None, 1)[1].rstrip('~')
+                elif data_line.startswith('Security'):
+                    parts = data_line.split()
+                    if len(parts) > 1:
+                        area.security = int(parts[1])
+                elif data_line.startswith('Flags'):
+                    parts = data_line.split()
+                    if len(parts) > 1:
+                        area.area_flags = int(parts[1])
+        elif line.startswith('#$') or line == '$':
+            break
+    key = area.min_vnum
+    area.vnum = area.min_vnum
+    # START enforce unique area vnum
+    if (
+        key != 0
+        and key in area_registry
+        and area_registry[key].file_name != area.file_name
+    ):
+        raise ValueError(f"duplicate area vnum {key}")
+    # END enforce unique area vnum
+    area_registry[key] = area
+
+    return area

mud/loaders/base_loader.py

@@ -0,0 +1,38 @@
+class BaseTokenizer:
+    """Simple tokenizer for area files."""
+    def __init__(self, lines):
+        self.lines = [line.rstrip('\n') for line in lines]
+        self.index = 0
+
+    def next_line(self):
+        while self.index < len(self.lines):
+            line = self.lines[self.index].strip()
+            self.index += 1
+            if line.startswith('*') or line == '':
+                continue
+            return line
+        return None
+
+    def peek_line(self):
+        pos = self.index
+        line = self.next_line()
+        self.index = pos
+        return line
+
+    def read_string_tilde(self):
+        parts = []
+        while True:
+            line = self.next_line()
+            if line is None:
+                break
+            if line.endswith('~'):
+                parts.append(line[:-1])
+                break
+            parts.append(line)
+        return '\n'.join(parts)
+
+    def read_number(self):
+        line = self.next_line()
+        if line is None:
+            raise ValueError('Unexpected EOF while reading number')
+        return int(line.split()[0])

mud/loaders/help_loader.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mud.models.help import HelpEntry, register_help, help_registry
+from mud.models.help_json import HelpJson
+
+
+def load_help_file(path: str | Path) -> None:
+    """Load help entries from ``path`` into ``help_registry``."""
+    with open(path, "r", encoding="utf-8") as fp:
+        data = json.load(fp)
+    help_registry.clear()
+    for raw in data:
+        entry = HelpEntry.from_json(HelpJson.from_dict(raw))
+        register_help(entry)