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

mud/models/social.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .social_json import SocialJson
+from mud.models.constants import Sex
+
+
+@dataclass
+class Social:
+    """Runtime representation of a social command."""
+
+    name: str
+    char_no_arg: str = ""
+    others_no_arg: str = ""
+    char_found: str = ""
+    others_found: str = ""
+    vict_found: str = ""
+    not_found: str = ""
+    char_auto: str = ""
+    others_auto: str = ""
+
+    @classmethod
+    def from_json(cls, data: SocialJson) -> "Social":
+        return cls(**data.to_dict())
+
+
+# placeholder registry to track loaded socials
+social_registry: dict[str, Social] = {}
+
+
+def register_social(social: Social) -> None:
+    """Register a social by its lowercase name."""
+    social_registry[social.name.lower()] = social
+
+
+# START socials
+def expand_placeholders(message: str, actor: object, victim: object | None = None) -> str:
+    """Replace basic ROM placeholders in social messages."""
+    def subj(sex: Sex | object) -> str:
+        if isinstance(sex, Sex):
+            return {Sex.MALE: "he", Sex.FEMALE: "she", Sex.NONE: "it"}.get(sex, "they")
+        return "they"
+
+    def obj(sex: Sex | object) -> str:
+        if isinstance(sex, Sex):
+            return {Sex.MALE: "him", Sex.FEMALE: "her", Sex.NONE: "it"}.get(sex, "them")
+        return "them"
+
+    def poss(sex: Sex | object) -> str:
+        if isinstance(sex, Sex):
+            return {Sex.MALE: "his", Sex.FEMALE: "her", Sex.NONE: "its"}.get(sex, "their")
+        return "their"
+
+    # Names
+    result = message.replace("$n", getattr(actor, "name", ""))
+    if victim is not None:
+        result = result.replace("$N", getattr(victim, "name", ""))
+
+    # Actor pronouns: replace $mself before $m to avoid overlap
+    asex = getattr(actor, "sex", None)
+    result = result.replace(
+        "$mself",
+        {Sex.MALE: "himself", Sex.FEMALE: "herself", Sex.NONE: "itself"}.get(asex, "themselves"),
+    )
+    result = result.replace("$e", subj(asex))
+    result = result.replace("$m", obj(asex))
+    result = result.replace("$s", poss(asex))
+
+    # Victim pronouns: $E $M $S
+    if victim is not None:
+        vsex = getattr(victim, "sex", None)
+        result = result.replace("$E", subj(vsex))
+        result = result.replace("$M", obj(vsex))
+        result = result.replace("$S", poss(vsex))
+
+    return result
+# END socials

mud/models/social_json.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class SocialJson(JsonDataclass):
+    """Social command messages matching ``schemas/social.schema.json``."""
+
+    name: str
+    char_no_arg: str = ""
+    others_no_arg: str = ""
+    char_found: str = ""
+    others_found: str = ""
+    vict_found: str = ""
+    not_found: str = ""
+    char_auto: str = ""
+    others_auto: str = ""

mud/net/__init__.py

@@ -0,0 +1,9 @@
+from .session import Session, SESSIONS
+from .protocol import send_to_char, broadcast_room
+
+__all__ = [
+    "Session",
+    "SESSIONS",
+    "send_to_char",
+    "broadcast_room",
+]

mud/net/ansi.py

@@ -0,0 +1,27 @@
+"""ANSI color code translation for ROM-style tokens."""
+from __future__ import annotations
+
+ANSI_CODES: dict[str, str] = {
+    "{x": "\x1b[0m",
+    "{r": "\x1b[31m",
+    "{g": "\x1b[32m",
+    "{y": "\x1b[33m",
+    "{b": "\x1b[34m",
+    "{m": "\x1b[35m",
+    "{c": "\x1b[36m",
+    "{w": "\x1b[37m",
+    "{R": "\x1b[1;31m",
+    "{G": "\x1b[1;32m",
+    "{Y": "\x1b[1;33m",
+    "{B": "\x1b[1;34m",
+    "{M": "\x1b[1;35m",
+    "{C": "\x1b[1;36m",
+    "{W": "\x1b[1;37m",
+}
+
+
+def translate_ansi(text: str) -> str:
+    """Replace ROM color tokens with ANSI escape sequences."""
+    for token, code in ANSI_CODES.items():
+        text = text.replace(token, code)
+    return text

mud/net/connection.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+import asyncio
+
+from mud.account import (
+    load_character,
+    save_character,
+    create_account,
+    login_with_host,
+    list_characters,
+    create_character,
+)
+from mud.commands import process_command
+from mud.net.session import Session, SESSIONS
+from mud.net.protocol import send_to_char
+
+
+async def handle_connection(
+    reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+) -> None:
+    addr = writer.get_extra_info("peername")
+    host_for_ban = None
+    if isinstance(addr, tuple) and addr:
+        host_for_ban = addr[0]
+    session = None
+    char = None
+    account = None
+    username = ""
+
+    try:
+        writer.write(b"Welcome to PythonMUD\r\n")
+        await writer.drain()
+
+        # Account login / creation
+        while not account:
+            writer.write(b"Account: ")
+            await writer.drain()
+            name_data = await reader.readline()
+            if not name_data:
+                return
+            username = name_data.decode().strip()
+            writer.write(b"Password: ")
+            await writer.drain()
+            pwd_data = await reader.readline()
+            if not pwd_data:
+                return
+            password = pwd_data.decode().strip()
+            # Enforce site/account bans at login time
+            account = login_with_host(username, password, host_for_ban)
+            if not account:
+                if create_account(username, password):
+                    account = login_with_host(username, password, host_for_ban)
+                else:
+                    writer.write(b"Login failed.\r\n")
+                    await writer.drain()
+
+        # Character selection / creation
+        chars = list_characters(account)
+        if chars:
+            writer.write(
+                ("Characters: " + ", ".join(chars) + "\r\n").encode()
+            )
+        writer.write(b"Character: ")
+        await writer.drain()
+        char_data = await reader.readline()
+        if not char_data:
+            return
+        char_name = char_data.decode().strip()
+        if char_name not in chars:
+            create_character(account, char_name)
+        try:
+            char = load_character(username, char_name)
+        except Exception as e:
+            print(f"[ERROR] Failed to load character {char_name}: {e}")
+            return
+        if char and char.room:
+            try:
+                char.room.add_character(char)
+            except Exception as e:
+                print(f"[ERROR] Failed to add character to room: {e}")
+
+        char.connection = writer
+
+        session = Session(
+            name=char.name or "",
+            character=char,
+            reader=reader,
+            writer=writer,
+        )
+        SESSIONS[session.name] = session
+        print(f"[CONNECT] {addr} as {session.name}")
+
+        # Send initial room description and prompt
+        try:
+            if char and char.room:
+                response = process_command(char, "look")
+                await send_to_char(char, response)
+            else:
+                await send_to_char(char, "You are floating in a void...")
+        except Exception as e:
+            print(f"[ERROR] Failed to send initial look: {e}")
+            await send_to_char(char, "Welcome to the world!")
+
+        # Main command loop with error handling
+        while True:
+            try:
+                writer.write(b"> ")
+                await writer.drain()
+                data = await reader.readline()
+                if not data:
+                    break
+                command = data.decode().strip()
+                if not command:
+                    continue
+
+                try:
+                    response = process_command(char, command)
+                    await send_to_char(char, response)
+                except Exception as e:
+                    print(
+                        "[ERROR] Command processing failed for "
+                        f"'{command}': {e}"
+                    )
+                    await send_to_char(
+                        char,
+                        "Sorry, there was an error processing that "
+                        "command.",
+                    )
+
+                # flush broadcast messages queued on character
+                while char and char.messages:
+                    try:
+                        msg = char.messages.pop(0)
+                        await send_to_char(char, msg)
+                    except Exception as e:
+                        print(f"[ERROR] Failed to send message: {e}")
+                        break
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                print(
+                    "[ERROR] Connection loop error for "
+                    f"{session.name if session else 'unknown'}: {e}"
+                )
+                break
+
+    except Exception as e:
+        print(f"[ERROR] Connection handler error for {addr}: {e}")
+    finally:
+        # Cleanup with error handling
+        try:
+            if char:
+                save_character(char)
+        except Exception as e:
+            print(f"[ERROR] Failed to save character: {e}")
+
+        try:
+            if char and char.room:
+                char.room.remove_character(char)
+        except Exception as e:
+            print(f"[ERROR] Failed to remove character from room: {e}")
+
+        if session and session.name in SESSIONS:
+            SESSIONS.pop(session.name, None)
+
+        try:
+            writer.close()
+            await writer.wait_closed()
+        except Exception as e:
+            print(f"[ERROR] Failed to close connection: {e}")
+
+        print(
+            f"[DISCONNECT] {addr} as {session.name if session else 'unknown'}"
+        )

mud/net/protocol.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+import asyncio
+from typing import Iterable, Optional
+
+from mud.models.character import Character, character_registry
+from mud.net.ansi import translate_ansi
+
+
+async def send_to_char(char: Character, message: str | Iterable[str]) -> None:
+    """Send message to character's connection with CRLF."""
+    writer = getattr(char, "connection", None)
+    if writer is None:
+        return
+
+    if isinstance(message, (list, tuple)):
+        text = "\r\n".join(str(m) for m in message)
+    else:
+        text = str(message)
+    text = translate_ansi(text)
+
+    if not text.endswith("\r\n"):
+        text += "\r\n"
+    writer.write(text.encode())
+    await writer.drain()
+
+
+def broadcast_room(
+    room,
+    message: str,
+    exclude: Optional[Character] = None,
+) -> None:
+    for char in list(getattr(room, "people", [])):
+        if char is exclude:
+            continue
+        writer = getattr(char, "connection", None)
+        if writer:
+            # fire and forget
+            asyncio.create_task(send_to_char(char, message))
+        if hasattr(char, "messages"):
+            char.messages.append(message)
+
+
+def broadcast_global(
+    message: str,
+    channel: str,
+    exclude: Optional[Character] = None,
+) -> None:
+    for char in list(character_registry):
+        if char is exclude:
+            continue
+        if channel in getattr(char, "muted_channels", set()):
+            continue
+        writer = getattr(char, "connection", None)
+        if writer:
+            asyncio.create_task(send_to_char(char, message))
+        if hasattr(char, "messages"):
+            char.messages.append(message)

mud/net/session.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Dict
+import asyncio
+
+from mud.models.character import Character
+
+
+@dataclass
+class Session:
+    name: str
+    character: Character
+    reader: asyncio.StreamReader
+    writer: asyncio.StreamWriter
+
+
+SESSIONS: Dict[str, Session] = {}
+
+
+def get_online_players() -> list[Character]:
+    return [sess.character for sess in SESSIONS.values()]

mud/net/telnet_server.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+import asyncio
+
+from mud.world.world_state import initialize_world
+from mud.db.migrations import run_migrations
+from .connection import handle_connection
+
+
+async def create_server(
+    host: str = "0.0.0.0", port: int = 4000, area_list: str = "area/area.lst"
+) -> asyncio.AbstractServer:
+    """Return a started telnet server without blocking the loop."""
+    # Initialize database tables
+    run_migrations()
+    # Initialize world data
+    initialize_world(area_list)
+    return await asyncio.start_server(handle_connection, host, port)
+
+
+async def start_server(
+    host: str = "0.0.0.0", port: int = 4000, area_list: str = "area/area.lst"
+) -> None:
+    server = await create_server(host, port, area_list)
+    addr = server.sockets[0].getsockname()
+    print(f"Serving on {addr}")
+    async with server:
+        await server.serve_forever()
+
+
+if __name__ == "__main__":
+    asyncio.run(start_server())

mud/network/websocket_server.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+
+from mud.config import HOST, PORT, CORS_ORIGINS
+from mud.world.world_state import initialize_world, create_test_character
+from mud.account import load_character, save_character
+from mud.commands import process_command
+from .websocket_session import WebSocketPlayerSession
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.on_event("startup")
+async def startup() -> None:
+    initialize_world(None)
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    await websocket.send_json({"type": "info", "text": "Welcome to PythonMUD. What is your name?"})
+    try:
+        data = await websocket.receive_json()
+    except WebSocketDisconnect:
+        return
+    name = data.get("text", "guest")
+    char = load_character(name, name)
+    if not char:
+        char = create_test_character(name, 3001)
+    elif char.room:
+        char.room.add_character(char)
+
+    session = WebSocketPlayerSession(websocket=websocket, character=char, name=name)
+    char.connection = session
+
+    try:
+        while True:
+            try:
+                message = await session.recv()
+            except WebSocketDisconnect:
+                break
+            if message.get("type") != "command":
+                continue
+            command = message.get("text", "").strip()
+            if not command:
+                continue
+            response = process_command(char, command)
+            await session.send({
+                "type": "output",
+                "text": response,
+                "room": char.room.vnum if getattr(char, "room", None) else None,
+                "hp": char.hit,
+            })
+            while char.messages:
+                msg = char.messages.pop(0)
+                await session.send({
+                    "type": "output",
+                    "text": msg,
+                    "room": char.room.vnum if getattr(char, "room", None) else None,
+                    "hp": char.hit,
+                })
+    finally:
+        save_character(char)
+        if char.room:
+            char.room.remove_character(char)
+
+
+def run(host: str = HOST, port: int = PORT) -> None:
+    uvicorn.run("mud.network.websocket_server:app", host=host, port=port)
+
+
+if __name__ == "__main__":
+    run()

mud/network/websocket_session.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+from fastapi import WebSocket
+from mud.models.character import Character
+
+
+@dataclass
+class WebSocketPlayerSession:
+    """Session wrapper for WebSocket clients."""
+
+    websocket: WebSocket
+    character: Character
+    name: str
+    session_type: str = "websocket"
+
+    async def send(self, payload: Dict[str, Any]) -> None:
+        await self.websocket.send_json(payload)
+
+    async def recv(self) -> Dict[str, Any]:
+        return await self.websocket.receive_json()

mud/notes.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict
+import os
+
+from mud.models.board import Board
+from mud.models.board_json import BoardJson
+from mud.models.json_io import load_dataclass, dump_dataclass
+
+BOARDS_DIR = Path("data/boards")
+
+board_registry: Dict[str, Board] = {}
+
+
+def load_boards() -> None:
+    """Load all boards from ``BOARDS_DIR`` into ``board_registry``."""
+    board_registry.clear()
+    if not BOARDS_DIR.exists():
+        return
+    for path in BOARDS_DIR.glob("*.json"):
+        with path.open() as f:
+            data = load_dataclass(BoardJson, f)
+        board_registry[data.name] = Board.from_json(data)
+
+
+def save_board(board: Board) -> None:
+    """Persist ``board`` to ``BOARDS_DIR`` atomically."""
+    BOARDS_DIR.mkdir(parents=True, exist_ok=True)
+    path = BOARDS_DIR / f"{board.name}.json"
+    tmp = path.with_suffix(".tmp")
+    with tmp.open("w") as f:
+        dump_dataclass(board.to_json(), f, indent=2)
+        f.flush()
+        os.fsync(f.fileno())
+    os.replace(tmp, path)
+
+
+def get_board(name: str, description: str | None = None) -> Board:
+    """Fetch a board by name, creating it if necessary."""
+    board = board_registry.get(name)
+    if not board:
+        board = Board(name=name, description=description or name.title())
+        board_registry[name] = board
+    return board