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

mud/scripts/convert_skills_to_json.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+Convert ROM 2.4 skill_table from const.c to JSON format.
+"""
+
+import json
+import re
+from pathlib import Path
+from typing import List, Dict, Any
+
+
+def parse_skill_table(const_c_path: Path) -> List[Dict[str, Any]]:
+    """Parse the skill_table from src/const.c and convert to JSON format."""
+    
+    content = const_c_path.read_text(encoding='latin-1')
+    
+    # Find the skill_table definition
+    start_match = re.search(r'const struct skill_type skill_table\[MAX_SKILL\] = \{', content)
+    if not start_match:
+        raise ValueError("Could not find skill_table definition")
+    
+    # Extract the skill table content
+    start_pos = start_match.end()
+    brace_count = 1
+    pos = start_pos
+    
+    while pos < len(content) and brace_count > 0:
+        if content[pos] == '{':
+            brace_count += 1
+        elif content[pos] == '}':
+            brace_count -= 1
+        pos += 1
+    
+    if brace_count != 0:
+        raise ValueError("Could not find end of skill_table")
+    
+    table_content = content[start_pos:pos-1]
+    
+    # Parse individual skill entries
+    skills = []
+    
+    # Split by skill entries (each starts with {)
+    skill_pattern = r'\{\s*"([^"]+)",\s*\{([^}]+)\},\s*\{([^}]+)\},\s*([^,\n]+),\s*([^,\n]+),\s*([^,\n]+),\s*([^,\n]+),\s*([^,\n]+),\s*([^,\n]+),\s*([^,\n]+),\s*"([^"]*)",\s*"([^"]*)"(?:,\s*"([^"]*)")?\s*\}'
+    
+    for match in re.finditer(skill_pattern, table_content, re.MULTILINE | re.DOTALL):
+        name = match.group(1)
+        skill_levels = match.group(2).strip()
+        ratings = match.group(3).strip()
+        spell_fun = match.group(4).strip()
+        target = match.group(5).strip()
+        position = match.group(6).strip()
+        gsn = match.group(7).strip()
+        slot = match.group(8).strip()
+        min_mana = match.group(9).strip()
+        beats = match.group(10).strip()
+        noun_damage = match.group(11).strip()
+        msg_off = match.group(12).strip()
+        msg_obj = match.group(13).strip() if match.group(13) else ""
+        
+        # Skip reserved entry
+        if name == "reserved":
+            continue
+            
+        # Determine if this is a spell or skill
+        is_spell = "spell_" in spell_fun and spell_fun != "spell_null"
+        skill_type = "spell" if is_spell else "skill"
+        
+        # Extract function name
+        function_name = name.replace(" ", "_")
+        if is_spell:
+            function_name = spell_fun.replace("spell_", "") if spell_fun.startswith("spell_") else function_name
+        
+        # Parse mana cost
+        try:
+            mana_cost = int(min_mana) if min_mana.isdigit() else 0
+        except:
+            mana_cost = 0
+            
+        # Parse lag (beats)
+        try:
+            lag = int(beats) if beats.isdigit() else 0
+        except:
+            lag = 0
+        
+        # Determine target type
+        target_mapping = {
+            "TAR_IGNORE": "ignore",
+            "TAR_CHAR_OFFENSIVE": "victim", 
+            "TAR_CHAR_DEFENSIVE": "friendly",
+            "TAR_CHAR_SELF": "self",
+            "TAR_OBJ_INV": "object",
+            "TAR_OBJ_CHAR_DEF": "character_or_object",
+            "TAR_OBJ_CHAR_OFF": "character_or_object"
+        }
+        target_type = target_mapping.get(target, "victim")
+        
+        skill_entry = {
+            "name": name,
+            "type": skill_type,
+            "function": function_name,
+            "target": target_type,
+            "mana_cost": mana_cost,
+            "lag": lag,
+            "cooldown": 0,  # Default cooldown
+            "failure_rate": 0.0,  # Default failure rate
+            "messages": {
+                "damage": noun_damage,
+                "wear_off": msg_off
+            }
+        }
+        
+        # Add object message if present
+        if msg_obj:
+            skill_entry["messages"]["object"] = msg_obj
+            
+        skills.append(skill_entry)
+    
+    return skills
+
+
+def main():
+    """Convert ROM 2.4 skills to JSON."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Convert ROM 2.4 skill_table to JSON")
+    parser.add_argument(
+        "--const-c", 
+        type=Path, 
+        default=Path("src/const.c"),
+        help="Path to const.c file (default: src/const.c)"
+    )
+    parser.add_argument(
+        "--output",
+        type=Path, 
+        default=Path("data/skills.json"),
+        help="Output JSON file (default: data/skills.json)"
+    )
+    
+    args = parser.parse_args()
+    
+    if not args.const_c.exists():
+        print(f"Error: {args.const_c} not found")
+        return 1
+        
+    try:
+        skills = parse_skill_table(args.const_c)
+        
+        # Ensure output directory exists
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write JSON with nice formatting
+        with args.output.open('w', encoding='utf-8') as f:
+            json.dump(skills, f, indent=2, ensure_ascii=False)
+            
+        print(f"✅ Converted {len(skills)} skills to {args.output}")
+        print(f"Sample skills: {[s['name'] for s in skills[:5]]}")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"Error converting skills: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())

mud/scripts/convert_social_are_to_json.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+"""Convert ROM social.are to JSON matching schemas/social.schema.json.
+
+Rules:
+- Each social consists of a name line (optionally followed by two ints)
+  and up to 8 message lines in the order documented in doc/command.txt.
+- A line consisting of a single "$" denotes an empty string for that field.
+- A line consisting of a single "#" terminates the current social early;
+  remaining fields default to empty strings.
+"""
+
+from pathlib import Path
+import json
+from typing import List, Dict
+
+FIELDS = [
+    "char_no_arg",
+    "others_no_arg",
+    "char_found",
+    "others_found",
+    "vict_found",
+    "not_found",
+    "char_auto",
+    "others_auto",
+]
+
+
+def parse_socials(text: str) -> List[Dict[str, str]]:
+    lines = [ln.rstrip("\n") for ln in text.splitlines()]
+    out: List[Dict[str, str]] = []
+    i = 0
+    # skip header
+    while i < len(lines) and not lines[i].startswith("#SOCIALS"):
+        i += 1
+    if i < len(lines) and lines[i].startswith("#SOCIALS"):
+        i += 1
+    # parse entries
+    while i < len(lines):
+        # skip blank lines
+        while i < len(lines) and lines[i].strip() == "":
+            i += 1
+        if i >= len(lines):
+            break
+        # name line or terminator
+        line = lines[i].strip()
+        if not line or line.startswith("#"):
+            i += 1
+            continue
+        # name may be followed by integers; take first token as name
+        name = line.split()[0]
+        i += 1
+        entry: Dict[str, str] = {"name": name}
+        # read up to 8 fields
+        remaining = len(FIELDS)
+        for field in FIELDS:
+            if i >= len(lines):
+                entry[field] = ""
+                continue
+            val = lines[i]
+            i += 1
+            if val == "#":
+                # early terminator: fill the rest with empty
+                entry[field] = ""
+                for rest in FIELDS[FIELDS.index(field) + 1 :]:
+                    entry[rest] = ""
+                break
+            if val == "$":
+                entry[field] = ""
+            else:
+                entry[field] = val
+            remaining -= 1
+        out.append(entry)
+    return out
+
+
+def convert(in_path: str | Path, out_path: str | Path) -> None:
+    text = Path(in_path).read_text(encoding="utf-8")
+    data = parse_socials(text)
+    Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Convert ROM social.are to JSON")
+    ap.add_argument("infile", help="Path to area/social.are")
+    ap.add_argument("outfile", help="Output JSON path")
+    args = ap.parse_args()
+    convert(args.infile, args.outfile)

mud/scripts/load_test_data.py

@@ -0,0 +1,17 @@
+from mud.db.session import SessionLocal
+from mud.db.models import PlayerAccount, Character
+from mud.world.world_state import initialize_world
+
+
+def load_test_user():
+    db = SessionLocal()
+
+    account = PlayerAccount(username="test", email="test@example.com")
+    account.set_password("test123")
+    db.add(account)
+    db.flush()
+
+    char = Character(name="Tester", hp=100, room_vnum=3001, player_id=account.id)
+    db.add(char)
+    db.commit()
+    print("✅ Test user created: login=test / pw=test123")

mud/security/bans.py

@@ -0,0 +1,112 @@
+"""Simple ban registry for site/account bans (Phase 1).
+
+This module provides in-memory helpers to enforce ROM-style bans at login.
+Persistence and full ROM format will be added in a follow-up task.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Set
+
+_banned_hosts: Set[str] = set()
+_banned_accounts: Set[str] = set()
+
+# Default storage location, mirroring ROM's BAN_FILE semantics.
+BANS_FILE = Path("data/bans.txt")
+
+
+def clear_all_bans() -> None:
+    _banned_hosts.clear()
+    _banned_accounts.clear()
+
+
+def add_banned_host(host: str) -> None:
+    _banned_hosts.add(host.strip().lower())
+
+
+def remove_banned_host(host: str) -> None:
+    _banned_hosts.discard(host.strip().lower())
+
+
+def is_host_banned(host: str | None) -> bool:
+    if not host:
+        return False
+    return host.strip().lower() in _banned_hosts
+
+
+def add_banned_account(username: str) -> None:
+    _banned_accounts.add(username.strip().lower())
+
+
+def remove_banned_account(username: str) -> None:
+    _banned_accounts.discard(username.strip().lower())
+
+
+def is_account_banned(username: str | None) -> bool:
+    if not username:
+        return False
+    return username.strip().lower() in _banned_accounts
+
+
+# --- ROM-compatible persistence (minimal) ---
+
+# ROM uses letter flags A.. for bit positions; for bans we need:
+# BAN_ALL = D, BAN_PERMANENT = F. We emit "DF" for permanent site-wide bans.
+_ROM_FLAG_ALL = "D"
+_ROM_FLAG_PERM = "F"
+
+
+def _flags_to_string() -> str:
+    # For now, we only persist permanent, all-site bans.
+    return _ROM_FLAG_ALL + _ROM_FLAG_PERM
+
+
+def save_bans_file(path: Path | str | None = None) -> None:
+    """Write permanent site bans to file in ROM format.
+
+    Format per ROM src/ban.c save_bans():
+        "%-20s %-2d %s\n" → name, level, flags-as-letters
+    We don't track setter level yet; write level 0.
+    """
+    target = Path(path) if path else BANS_FILE
+    if not _banned_hosts:
+        # Mirror ROM behavior: delete file if no permanent bans remain.
+        try:
+            if target.exists():
+                target.unlink()
+        except OSError:
+            pass
+        return
+    target.parent.mkdir(parents=True, exist_ok=True)
+    with target.open("w", encoding="utf-8") as fp:
+        for host in sorted(_banned_hosts):
+            name = host
+            level = 0
+            flags = _flags_to_string()
+            fp.write(f"{name:<20} {level:2d} {flags}\n")
+
+
+def load_bans_file(path: Path | str | None = None) -> int:
+    """Load bans from ROM-format file into memory; returns count loaded."""
+    target = Path(path) if path else BANS_FILE
+    if not target.exists():
+        return 0
+    count = 0
+    with target.open("r", encoding="utf-8") as fp:
+        for raw in fp:
+            line = raw.strip()
+            if not line:
+                continue
+            # Expect: name(<20 padded>) <level> <flags>
+            parts = line.split()
+            if len(parts) < 3:
+                continue
+            name = parts[0]
+            # level = parts[1]  # unused here
+            flags = parts[2]
+            # Only import entries that include permanent+all flags
+            if _ROM_FLAG_PERM in flags:
+                _banned_hosts.add(name.lower())
+                count += 1
+    return count

mud/security/hash_utils.py

@@ -0,0 +1,20 @@
+import hashlib
+import os
+
+
+def hash_password(password: str) -> str:
+    """Return a salted hash for the given password."""
+    salt = os.urandom(16)
+    hashed = hashlib.pbkdf2_hmac("sha256", password.encode(), salt, 100_000)
+    return salt.hex() + ":" + hashed.hex()
+
+
+def verify_password(password: str, stored_hash: str) -> bool:
+    """Check password against the stored ``salt:hash`` string."""
+    try:
+        salt_hex, hash_hex = stored_hash.split(":")
+    except ValueError:
+        return False
+    salt = bytes.fromhex(salt_hex)
+    new_hash = hashlib.pbkdf2_hmac("sha256", password.encode(), salt, 100_000)
+    return new_hash.hex() == hash_hex

mud/server.py

@@ -0,0 +1,8 @@
+import asyncio
+from mud.net.telnet_server import start_server
+from mud.config import HOST, PORT
+
+
+def run_game_loop():
+    print("\U0001F30D Starting MUD server...")
+    asyncio.run(start_server(host=HOST, port=PORT))

mud/skills/__init__.py

@@ -0,0 +1,3 @@
+from .registry import SkillRegistry, load_skills, skill_registry
+
+__all__ = ["SkillRegistry", "load_skills", "skill_registry"]