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

mud/commands/inspection.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from mud.models.character import Character
+from mud.world.look import look, dir_names
+from mud.models.constants import Direction
+
+
+def do_scan(char: Character, args: str = "") -> str:
+    """ROM-like scan output with distances and optional direction.
+
+    - No arg: list current room (depth 0) and adjacent rooms (depth 1) in N,E,S,W,Up,Down order.
+    - With direction: follow exits up to depth 3 and list visible characters per room.
+    """
+    if not char.room:
+        return "You see nothing."
+
+    order = [
+        Direction.NORTH,
+        Direction.EAST,
+        Direction.SOUTH,
+        Direction.WEST,
+        Direction.UP,
+        Direction.DOWN,
+    ]
+    dir_name = {
+        Direction.NORTH: "north",
+        Direction.EAST: "east",
+        Direction.SOUTH: "south",
+        Direction.WEST: "west",
+        Direction.UP: "up",
+        Direction.DOWN: "down",
+    }
+    distance = [
+        "right here.",
+        "nearby to the %s.",
+        "not far %s.",
+        "off in the distance %s.",
+    ]
+
+    def list_room(room, depth: int, door: int) -> list[str]:
+        lines: list[str] = []
+        if not room:
+            return lines
+        for p in room.people:
+            if p is char:
+                continue
+            who = p.name or "someone"
+            if depth == 0:
+                lines.append(f"{who}, {distance[0]}")
+            else:
+                dn = dir_name[Direction(door)]
+                lines.append(f"{who}, {distance[depth] % dn}")
+        return lines
+
+    s = args.strip().lower()
+    if not s:
+        lines: list[str] = ["Looking around you see:"]
+        # current room
+        lines += list_room(char.room, 0, -1)
+        # each direction at depth 1
+        for d in order:
+            ex = char.room.exits[int(d)] if char.room.exits and int(d) < len(char.room.exits) else None
+            to_room = ex.to_room if ex else None
+            lines += list_room(to_room, 1, int(d))
+        if len(lines) == 1:
+            lines.append("No one is nearby.")
+        return "\n".join(lines)
+
+    # Directional scan up to depth 3
+    token_map = {
+        "n": Direction.NORTH,
+        "north": Direction.NORTH,
+        "e": Direction.EAST,
+        "east": Direction.EAST,
+        "s": Direction.SOUTH,
+        "south": Direction.SOUTH,
+        "w": Direction.WEST,
+        "west": Direction.WEST,
+        "u": Direction.UP,
+        "up": Direction.UP,
+        "d": Direction.DOWN,
+        "down": Direction.DOWN,
+    }
+    if s not in token_map:
+        return "Which way do you want to scan?"
+    d = token_map[s]
+    dir_str = dir_name[d]
+    lines = [f"Looking {dir_str} you see:"]
+    scan_room = char.room
+    for depth in (1, 2, 3):
+        ex = scan_room.exits[int(d)] if scan_room and scan_room.exits and int(d) < len(scan_room.exits) else None
+        scan_room = ex.to_room if ex else None
+        if not scan_room:
+            break
+        lines += list_room(scan_room, depth, int(d))
+    if len(lines) == 1:
+        lines.append("Nothing of note.")
+    return "\n".join(lines)
+
+
+def do_look(char: Character, args: str = "") -> str:
+    return look(char)
+
+
+def do_exits(char: Character, args: str = "") -> str:
+    """List obvious exits from the current room (ROM-style)."""
+    room = char.room
+    if not room or not getattr(room, "exits", None):
+        return "Obvious exits: none."
+    dirs = [dir_names[type(list(dir_names.keys())[0]) (i)] for i, ex in enumerate(room.exits) if ex]
+    if not dirs:
+        return "Obvious exits: none."
+    return f"Obvious exits: {' '.join(dirs)}."

mud/commands/inventory.py

@@ -0,0 +1,42 @@
+from mud.models.character import Character
+
+
+def do_get(char: Character, args: str) -> str:
+    if not args:
+        return "Get what?"
+    name = args.lower()
+    for obj in list(char.room.contents):
+        obj_name = (obj.short_descr or obj.name or "").lower()
+        if name in obj_name:
+            char.room.contents.remove(obj)
+            char.add_object(obj)
+            return f"You pick up {obj.short_descr or obj.name}."
+    return "You don't see that here."
+
+
+def do_drop(char: Character, args: str) -> str:
+    if not args:
+        return "Drop what?"
+    name = args.lower()
+    for obj in list(char.inventory):
+        obj_name = (obj.short_descr or obj.name or "").lower()
+        if name in obj_name:
+            char.inventory.remove(obj)
+            char.room.add_object(obj)
+            return f"You drop {obj.short_descr or obj.name}."
+    return "You aren't carrying that."
+
+
+def do_inventory(char: Character, args: str = "") -> str:
+    if not char.inventory:
+        return "You are carrying nothing."
+    return "You are carrying: " + ", ".join(obj.short_descr or obj.name or "object" for obj in char.inventory)
+
+
+def do_equipment(char: Character, args: str = "") -> str:
+    if not char.equipment:
+        return "You are wearing nothing."
+    parts = []
+    for slot, obj in char.equipment.items():
+        parts.append(f"{slot}: {obj.short_descr or obj.name or 'object'}")
+    return "You are using: " + ", ".join(parts)

mud/commands/movement.py

@@ -0,0 +1,71 @@
+from mud.world.movement import move_character
+from mud.models.character import Character
+from mud.models.constants import ItemType, EX_CLOSED
+from mud.registry import room_registry
+
+
+def do_north(char: Character, args: str = "") -> str:
+    return move_character(char, "north")
+
+
+def do_south(char: Character, args: str = "") -> str:
+    return move_character(char, "south")
+
+
+def do_east(char: Character, args: str = "") -> str:
+    return move_character(char, "east")
+
+
+def do_west(char: Character, args: str = "") -> str:
+    return move_character(char, "west")
+
+
+def do_up(char: Character, args: str = "") -> str:
+    return move_character(char, "up")
+
+
+def do_down(char: Character, args: str = "") -> str:
+    return move_character(char, "down")
+
+
+def do_enter(char: Character, args: str = "") -> str:
+    target = (args or "").strip().lower()
+    if not target:
+        return "Enter what?"
+
+    # Find a portal object in the room matching target token
+    portal = None
+    for obj in getattr(char.room, "contents", []):
+        proto = getattr(obj, "prototype", None)
+        if not proto or getattr(proto, "item_type", 0) != int(ItemType.PORTAL):
+            continue
+        name = (getattr(proto, "short_descr", None) or getattr(proto, "name", "") or "").lower()
+        if target in name or target == "portal" or target in (getattr(obj, "short_descr", "") or "").lower():
+            portal = obj
+            break
+
+    if not portal:
+        return f"I see no {target} here."
+
+    flags = 0
+    proto = portal.prototype
+    values = getattr(proto, "value", [0, 0, 0, 0, 0])
+    if len(values) > 1 and isinstance(values[1], int):
+        flags = int(values[1])
+
+    if flags & EX_CLOSED:
+        return "The portal is closed."
+
+    dest_vnum = values[3] if len(values) > 3 else 0
+    dest = room_registry.get(int(dest_vnum))
+    if dest is None:
+        return "It doesn't seem to go anywhere."
+
+    # Move character
+    old_room = char.room
+    if char in old_room.people:
+        old_room.people.remove(char)
+    dest.people.append(char)
+    char.room = dest
+    char.wait = max(char.wait, 1)
+    return f"You enter the portal and arrive in {dest.name}."

mud/commands/notes.py

@@ -0,0 +1,44 @@
+from mud.models.character import Character
+from mud.notes import board_registry, get_board, save_board
+
+
+def do_board(char: Character, args: str) -> str:
+    if not args:
+        if not board_registry:
+            return "No boards."
+        return "Boards: " + ", ".join(sorted(board_registry))
+    return "Huh?"
+
+
+def do_note(char: Character, args: str) -> str:
+    if not args:
+        return "Note what?"
+    subcmd, *rest = args.split(None, 1)
+    rest_str = rest[0] if rest else ""
+    board = get_board("general")
+    if subcmd == "post":
+        if "|" not in rest_str:
+            return "Usage: note post <subject>|<text>"
+        subject, text = rest_str.split("|", 1)
+        board.post(char.name or "someone", subject.strip(), text.strip())
+        save_board(board)
+        return "Note posted."
+    elif subcmd == "list":
+        if not board.notes:
+            return "No notes."
+        lines = [
+            f"{i+1}: {note.subject} ({note.sender})"
+            for i, note in enumerate(board.notes)
+        ]
+        return "\n".join(lines)
+    elif subcmd == "read":
+        try:
+            index = int(rest_str.strip()) - 1
+        except ValueError:
+            return "Read which note?"
+        if index < 0 or index >= len(board.notes):
+            return "No such note."
+        note = board.notes[index]
+        return f"{note.subject}\n{note.text}"
+    else:
+        return "Huh?"

mud/commands/shop.py

@@ -0,0 +1,138 @@
+"""Shop command handlers."""
+
+from mud.registry import shop_registry
+from mud.models.character import Character
+from mud.models.object import Object
+from mud.models.constants import ItemType
+from mud.math.c_compat import c_div
+
+
+def _find_shopkeeper(char: Character):
+    for mob in getattr(char.room, "people", []):
+        proto = getattr(mob, "prototype", None)
+        if proto and proto.vnum in shop_registry:
+            return mob
+    return None
+
+
+def _get_shop(keeper):
+    proto = getattr(keeper, "prototype", None)
+    if proto:
+        return shop_registry.get(proto.vnum)
+    return None
+
+
+def _get_cost(keeper, obj: Object, *, buy: bool) -> int:
+    """Compute ROM-like shop price for an object.
+
+    Mirrors src/act_obj.c:get_cost:
+    - buy: base = obj.cost * profit_buy / 100
+    - sell: base = obj.cost * profit_sell / 100 if type accepted; otherwise 0
+    - inventory discount on sell when keeper already has same item:
+        - if existing copy has ITEM_INVENTORY → base /= 2
+        - else → base = base * 3 / 4
+    - wand/staff charge scaling: value[1]==0 → base/=4; else base = base * value[2] / value[1]
+    """
+    proto = obj.prototype
+    shop = _get_shop(keeper)
+    if not shop:
+        return 0
+    cost = 0
+    if buy:
+        cost = c_div(getattr(proto, "cost", 0) * shop.profit_buy, 100)
+    else:
+        # ensure shop buys this type
+        item_type = getattr(proto, "item_type", 0)
+        if shop.buy_types and item_type not in shop.buy_types:
+            return 0
+        cost = c_div(getattr(proto, "cost", 0) * shop.profit_sell, 100)
+        # inventory discount if keeper already has same item
+        for other in getattr(keeper, "inventory", []) or []:
+            op = getattr(other, "prototype", None)
+            if not op:
+                continue
+            if op is proto or (
+                getattr(op, "vnum", None) == getattr(proto, "vnum", None)
+                and (getattr(op, "short_descr", None) or "") == (getattr(proto, "short_descr", None) or "")
+            ):
+                # treat bit 1<<18 as ITEM_INVENTORY in this port
+                ITEM_INVENTORY = 1 << 18
+                if getattr(op, "extra_flags", 0) & ITEM_INVENTORY:
+                    cost = c_div(cost, 2)
+                else:
+                    cost = c_div(cost * 3, 4)
+                break
+
+    # Charge scaling for wand/staff
+    if getattr(proto, "item_type", 0) in (int(ItemType.WAND), int(ItemType.STAFF)):
+        vals = getattr(proto, "value", [0, 0, 0, 0, 0])
+        total = vals[1]
+        rem = vals[2]
+        if total == 0:
+            cost = c_div(cost, 4)
+        elif total > 0:
+            cost = c_div(cost * rem, total)
+    return max(0, int(cost))
+
+
+def do_list(char: Character, args: str = "") -> str:
+    keeper = _find_shopkeeper(char)
+    if not keeper:
+        return "You can't do that here."
+    shop = _get_shop(keeper)
+    if not shop:
+        return "You can't do that here."
+    if not keeper.inventory:
+        return "The shop is out of stock."
+    items = []
+    for obj in keeper.inventory:
+        name = obj.short_descr or obj.name or "item"
+        price = _get_cost(keeper, obj, buy=True)
+        items.append(f"{name} {price} gold")
+    return "Items for sale: " + ", ".join(items)
+
+
+def do_buy(char: Character, args: str) -> str:
+    if not args:
+        return "Buy what?"
+    keeper = _find_shopkeeper(char)
+    if not keeper:
+        return "You can't do that here."
+    shop = _get_shop(keeper)
+    if not shop:
+        return "You can't do that here."
+    name = args.lower()
+    for obj in list(keeper.inventory):
+        obj_name = (obj.short_descr or obj.name or "").lower()
+        if name in obj_name:
+            price = _get_cost(keeper, obj, buy=True)
+            if char.gold < price:
+                return "You can't afford that."
+            char.gold -= price
+            keeper.inventory.remove(obj)
+            char.add_object(obj)
+            return f"You buy {obj.short_descr or obj.name} for {price} gold."
+    return "The shopkeeper doesn't sell that."
+
+
+def do_sell(char: Character, args: str) -> str:
+    if not args:
+        return "Sell what?"
+    keeper = _find_shopkeeper(char)
+    if not keeper:
+        return "You can't do that here."
+    shop = _get_shop(keeper)
+    if not shop:
+        return "You can't do that here."
+    name = args.lower()
+    for obj in list(char.inventory):
+        obj_name = (obj.short_descr or obj.name or "").lower()
+        if name in obj_name:
+            price = _get_cost(keeper, obj, buy=False)
+            if price <= 0:
+                return "The shopkeeper doesn't buy that."
+            char.gold += price
+            char.inventory.remove(obj)
+            keeper.inventory.append(obj)
+            return f"You sell {obj.short_descr or obj.name} for {price} gold."
+    return "You don't have that."

mud/commands/socials.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from mud.models.character import Character
+from mud.models.social import social_registry, expand_placeholders
+
+
+def perform_social(char: Character, name: str, arg: str) -> str:
+    social = social_registry.get(name.lower())
+    if social is None or char.room is None:
+        return "Huh?"
+    victim = None
+    if arg:
+        arg_lower = arg.lower()
+        for person in char.room.people:
+            if person is char:
+                continue
+            if getattr(person, "name", "").lower().startswith(arg_lower):
+                victim = person
+                break
+    if victim and victim is not char:
+        char.messages.append(expand_placeholders(social.char_found, char, victim))
+        char.room.broadcast(expand_placeholders(social.others_found, char, victim), exclude=char)
+        victim.messages.append(expand_placeholders(social.vict_found, char, victim))
+    elif arg and victim is char:
+        char.messages.append(expand_placeholders(social.char_auto, char))
+        char.room.broadcast(expand_placeholders(social.others_auto, char), exclude=char)
+    elif arg and not victim:
+        # ROM semantics: if an argument was provided but no victim is found,
+        # emit the "not found" message instead of the no-arg variant.
+        char.messages.append(expand_placeholders(social.not_found, char))
+    else:
+        char.messages.append(expand_placeholders(social.char_no_arg, char))
+        char.room.broadcast(expand_placeholders(social.others_no_arg, char), exclude=char)
+    return ""

mud/config.py

@@ -0,0 +1,59 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configuration for servers
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///mud.db")
+PORT = int(os.getenv("PORT", 5000))
+HOST = os.getenv("HOST", "0.0.0.0")
+
+# Comma separated list of allowed CORS origins
+CORS_ORIGINS = [origin.strip() for origin in os.getenv("CORS_ORIGINS", "*").split(",")]
+
+# ----- ROM tick cadence (PULSE constants) -----
+# ROM defines PULSE_PER_SECOND=4 and PULSE_TICK=60*PULSE_PER_SECOND (see src/merc.h)
+# Keep these values here so engine code can reference parity timings.
+PULSE_PER_SECOND: int = 4
+
+def get_pulse_tick() -> int:
+    """Return pulses per game tick hour (ROM PULSE_TICK).
+
+    Matches ROM's PULSE_TICK = 60 * PULSE_PER_SECOND.
+    """
+    scale = max(1, int(os.getenv("TIME_SCALE", os.getenv("MUD_TIME_SCALE", "1")) or 1))
+    # Allow in-test overrides via module variable as well
+    try:
+        from mud import config as _cfg  # local import to avoid cycles
+        scale = max(scale, int(getattr(_cfg, "TIME_SCALE", 1)))
+    except Exception:
+        pass
+    base = 60 * PULSE_PER_SECOND
+    # Ensure at least 1 pulse per tick when scaled up
+    return max(1, base // scale)
+
+
+def get_pulse_violence() -> int:
+    """Return pulses per violence update (ROM PULSE_VIOLENCE).
+
+    ROM sets PULSE_VIOLENCE = 3 * PULSE_PER_SECOND.
+    Honor TIME_SCALE in the same way as ticks by dividing the base.
+    """
+    scale = max(1, int(os.getenv("TIME_SCALE", os.getenv("MUD_TIME_SCALE", "1")) or 1))
+    try:
+        from mud import config as _cfg
+        scale = max(scale, int(getattr(_cfg, "TIME_SCALE", 1)))
+    except Exception:
+        pass
+    base = 3 * PULSE_PER_SECOND
+    return max(1, base // scale)
+
+# Feature flags
+COMBAT_USE_THAC0: bool = False
+
+# Optional test-only time scaling (1 = real ROM cadence)
+TIME_SCALE: int = 1
+
+# When True, schedule weather/reset strictly on point pulses (ROM-like).
+# Default False to preserve existing test expectations.
+GAME_LOOP_STRICT_POINT: bool = False

mud/db/init.py

@@ -0,0 +1,27 @@
+from mud.db.models import Base
+from mud.db.session import engine
+from mud.db.seed import create_test_account
+import os
+
+
+def initialize_database():
+    """Initialize the database with tables and seed data."""
+    # Create all tables
+    Base.metadata.create_all(engine)
+    
+    # Create test admin account if it doesn't exist
+    create_test_account()
+    
+    print(f"Database initialized at: {engine.url}")
+
+
+def database_exists():
+    """Check if the database file exists."""
+    if str(engine.url).startswith('sqlite:///'):
+        db_path = str(engine.url).replace('sqlite:///', '')
+        return os.path.exists(db_path)
+    return True  # For non-file databases
+
+
+if __name__ == "__main__":
+    initialize_database()

mud/db/migrate_from_files.py

@@ -0,0 +1,87 @@
+"""One-time migration script to populate the database from .are files."""
+from mud.loaders import load_all_areas
+from mud.world.linking import link_exits
+from mud.registry import area_registry, room_registry, mob_registry, obj_registry
+from mud.db.session import SessionLocal, engine
+from mud.db import models
+
+
+def migrate(area_list_path: str = "area/area.lst") -> None:
+    load_all_areas(area_list_path)
+    link_exits()
+    models.Base.metadata.create_all(engine)
+    session = SessionLocal()
+
+    area_map = {}
+    for area in area_registry.values():
+        db_area = models.Area(
+            vnum=area.vnum,
+            name=area.name,
+            min_vnum=area.min_vnum,
+            max_vnum=area.max_vnum,
+        )
+        session.add(db_area)
+        session.flush()
+        area_map[area] = db_area
+
+    room_map = {}
+    for room in room_registry.values():
+        db_room = models.Room(
+            vnum=room.vnum,
+            name=room.name,
+            description=room.description,
+            sector_type=room.sector_type,
+            room_flags=room.room_flags,
+            area=area_map.get(room.area),
+        )
+        session.add(db_room)
+        session.flush()
+        room_map[room] = db_room
+
+    for room in room_registry.values():
+        db_room = room_map[room]
+        for direction, exit_obj in enumerate(room.exits):
+            if exit_obj and exit_obj.vnum:
+                session.add(
+                    models.Exit(
+                        room=db_room,
+                        direction=str(direction),
+                        to_room_vnum=exit_obj.vnum,
+                    )
+                )
+
+    for mob in mob_registry.values():
+        session.add(
+            models.MobPrototype(
+                vnum=mob.vnum,
+                name=mob.player_name,
+                short_desc=mob.short_descr,
+                long_desc=mob.long_descr,
+                level=mob.level,
+                alignment=mob.alignment,
+            )
+        )
+
+    for obj in obj_registry.values():
+        session.add(
+            models.ObjPrototype(
+                vnum=obj.vnum,
+                name=obj.name,
+                short_desc=obj.short_descr,
+                long_desc=obj.description,
+                item_type=obj.item_type,
+                flags=obj.extra_flags,
+                value0=obj.value[0] if len(obj.value) > 0 else None,
+                value1=obj.value[1] if len(obj.value) > 1 else None,
+                value2=obj.value[2] if len(obj.value) > 2 else None,
+                value3=obj.value[3] if len(obj.value) > 3 else None,
+            )
+        )
+
+    session.commit()
+    session.close()
+    print("✅ Migration complete")
+
+
+if __name__ == "__main__":
+    migrate()

mud/db/migrations.py

@@ -0,0 +1,7 @@
+from mud.db.models import Base
+from mud.db.session import engine
+
+
+def run_migrations() -> None:
+    Base.metadata.create_all(bind=engine)
+    print("✅ Migrations complete.")