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

mud/persistence.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+import os
+
+from mud.models.character import Character, character_registry
+from mud.models.json_io import dump_dataclass, load_dataclass
+from mud.spawning.obj_spawner import spawn_object
+from mud.registry import room_registry
+from mud.time import time_info, Sunlight
+
+
+@dataclass
+class PlayerSave:
+    """Serializable snapshot of a player's state."""
+
+    name: str
+    level: int
+    hit: int
+    max_hit: int
+    mana: int
+    max_mana: int
+    move: int
+    max_move: int
+    gold: int
+    silver: int
+    exp: int
+    position: int
+    # ROM bitfields to preserve flags parity
+    affected_by: int = 0
+    wiznet: int = 0
+    room_vnum: Optional[int] = None
+    inventory: List[int] = field(default_factory=list)
+    equipment: Dict[str, int] = field(default_factory=dict)
+    aliases: Dict[str, str] = field(default_factory=dict)
+
+
+PLAYERS_DIR = Path("data/players")
+TIME_FILE = Path("data/time.json")
+
+
+def save_character(char: Character) -> None:
+    """Persist ``char`` to ``PLAYERS_DIR`` as JSON."""
+    PLAYERS_DIR.mkdir(parents=True, exist_ok=True)
+    data = PlayerSave(
+        name=char.name or "",
+        level=char.level,
+        hit=char.hit,
+        max_hit=char.max_hit,
+        mana=char.mana,
+        max_mana=char.max_mana,
+        move=char.move,
+        max_move=char.max_move,
+        gold=char.gold,
+        silver=char.silver,
+        exp=char.exp,
+        position=char.position,
+        affected_by=getattr(char, "affected_by", 0),
+        wiznet=getattr(char, "wiznet", 0),
+        room_vnum=char.room.vnum if getattr(char, "room", None) else None,
+        inventory=[obj.prototype.vnum for obj in char.inventory],
+        equipment={slot: obj.prototype.vnum for slot, obj in char.equipment.items()},
+        aliases=dict(getattr(char, "aliases", {})),
+    )
+    path = PLAYERS_DIR / f"{char.name.lower()}.json"
+    tmp_path = path.with_suffix(".tmp")
+    with tmp_path.open("w") as f:
+        dump_dataclass(data, f, indent=2)
+        f.flush()
+        os.fsync(f.fileno())
+    os.replace(tmp_path, path)
+
+
+def load_character(name: str) -> Optional[Character]:
+    """Load a character by ``name`` from ``PLAYERS_DIR``."""
+    path = PLAYERS_DIR / f"{name.lower()}.json"
+    if not path.exists():
+        return None
+    with path.open() as f:
+        data = load_dataclass(PlayerSave, f)
+    char = Character(
+        name=data.name,
+        level=data.level,
+        hit=data.hit,
+        max_hit=data.max_hit,
+        mana=data.mana,
+        max_mana=data.max_mana,
+        move=data.move,
+        max_move=data.max_move,
+        gold=data.gold,
+        silver=data.silver,
+        exp=data.exp,
+        position=data.position,
+    )
+    # restore bitfields
+    char.affected_by = getattr(data, "affected_by", 0)
+    char.wiznet = getattr(data, "wiznet", 0)
+    if data.room_vnum is not None:
+        room = room_registry.get(data.room_vnum)
+        if room:
+            room.add_character(char)
+    for vnum in data.inventory:
+        obj = spawn_object(vnum)
+        if obj:
+            char.add_object(obj)
+    for slot, vnum in data.equipment.items():
+        obj = spawn_object(vnum)
+        if obj:
+            char.equip_object(obj, slot)
+    # restore aliases
+    try:
+        char.aliases.update(getattr(data, "aliases", {}) or {})
+    except Exception:
+        pass
+    character_registry.append(char)
+    return char
+
+
+def save_world() -> None:
+    """Write all registered characters to disk."""
+    save_time_info()
+    for char in list(character_registry):
+        if char.name:
+            save_character(char)
+
+
+def load_world() -> List[Character]:
+    """Load all character files from ``PLAYERS_DIR``."""
+    chars: List[Character] = []
+    load_time_info()
+    if not PLAYERS_DIR.exists():
+        return chars
+    for path in PLAYERS_DIR.glob("*.json"):
+        char = load_character(path.stem)
+        if char:
+            chars.append(char)
+    return chars
+
+
+# --- Time persistence ---
+
+@dataclass
+class TimeSave:
+    hour: int
+    day: int
+    month: int
+    year: int
+    sunlight: int
+
+
+def save_time_info() -> None:
+    """Persist global time_info to TIME_FILE (atomic write)."""
+    TIME_FILE.parent.mkdir(parents=True, exist_ok=True)
+    data = TimeSave(
+        hour=time_info.hour,
+        day=time_info.day,
+        month=time_info.month,
+        year=time_info.year,
+        sunlight=int(time_info.sunlight),
+    )
+    tmp_path = TIME_FILE.with_suffix(".tmp")
+    with tmp_path.open("w") as f:
+        dump_dataclass(data, f, indent=2)
+        f.flush()
+        os.fsync(f.fileno())
+    os.replace(tmp_path, TIME_FILE)
+
+
+def load_time_info() -> None:
+    """Load global time_info from TIME_FILE if present."""
+    if not TIME_FILE.exists():
+        return
+    with TIME_FILE.open() as f:
+        data = load_dataclass(TimeSave, f)
+    time_info.hour = data.hour
+    time_info.day = data.day
+    time_info.month = data.month
+    time_info.year = data.year
+    try:
+        time_info.sunlight = Sunlight(data.sunlight)
+    except Exception:
+        # Fallback if invalid value
+        time_info.sunlight = Sunlight.DARK

mud/registry.py

@@ -0,0 +1,5 @@
+room_registry = {}
+mob_registry = {}
+obj_registry = {}
+area_registry = {}
+shop_registry = {}

mud/scripts/convert_are_to_json.py

@@ -0,0 +1,162 @@
+import argparse
+import json
+from pathlib import Path
+
+from mud.loaders.area_loader import load_area_file
+from mud.models.constants import Direction, Sector
+from mud.registry import area_registry, room_registry, mob_registry, obj_registry
+
+
+def clear_registries() -> None:
+    """Reset global registries to avoid cross-contamination."""
+    area_registry.clear()
+    room_registry.clear()
+    mob_registry.clear()
+    obj_registry.clear()
+
+
+def room_to_dict(room) -> dict:
+    exits = {}
+    for idx, exit_obj in enumerate(room.exits):
+        if not exit_obj:
+            continue
+        direction = Direction(idx).name.lower()
+        exits[direction] = {
+            "to_room": exit_obj.vnum or 0,
+        }
+        if exit_obj.description:
+            exits[direction]["description"] = exit_obj.description
+        if exit_obj.keyword:
+            exits[direction]["keyword"] = exit_obj.keyword
+        exits[direction]["flags"] = getattr(exit_obj, 'flags', '0')
+        if exit_obj.key:
+            exits[direction]["key"] = exit_obj.key
+    extra = []
+    for ed in room.extra_descr:
+        if ed.keyword and ed.description:
+            extra.append({"keyword": ed.keyword, "description": ed.description})
+    # Note: Resets are stored at area level, not per-room in ROM format
+    try:
+        sector = Sector(room.sector_type).name.lower()
+    except ValueError:
+        sector = str(room.sector_type)
+    return {
+        "id": room.vnum,
+        "name": room.name or "",
+        "description": room.description or "",
+        "sector_type": sector,
+        "flags": room.room_flags or 0,
+        "exits": exits,
+        "extra_descriptions": extra,
+        "area": room.area.vnum if room.area else 0,
+    }
+
+
+def mob_to_dict(mob) -> dict:
+    return {
+        "id": mob.vnum,
+        "name": mob.short_descr or "",
+        "player_name": mob.player_name or "",
+        "long_description": mob.long_descr or "",
+        "description": mob.description or "",
+        "race": getattr(mob, 'race', ''),
+        "act_flags": getattr(mob, 'act_flags', ''),
+        "affected_by": getattr(mob, 'affected_by', ''),
+        "alignment": getattr(mob, 'alignment', 0),
+        "group": getattr(mob, 'group', 0),
+        "level": getattr(mob, 'level', 1),
+        "thac0": getattr(mob, 'thac0', 20),
+        "ac": getattr(mob, 'ac', '1d1+0'),
+        "hit_dice": getattr(mob, 'hit_dice', '1d1+0'),
+        "mana_dice": getattr(mob, 'mana_dice', '1d1+0'),
+        "damage_dice": getattr(mob, 'damage_dice', '1d4+0'),
+        "damage_type": getattr(mob, 'damage_type', 'beating'),
+        "ac_pierce": getattr(mob, 'ac_pierce', 0),
+        "ac_bash": getattr(mob, 'ac_bash', 0),
+        "ac_slash": getattr(mob, 'ac_slash', 0),
+        "ac_exotic": getattr(mob, 'ac_exotic', 0),
+        "offensive": getattr(mob, 'offensive', ''),
+        "immune": getattr(mob, 'immune', ''),
+        "resist": getattr(mob, 'resist', ''),
+        "vuln": getattr(mob, 'vuln', ''),
+        "start_pos": getattr(mob, 'start_pos', 'standing'),
+        "default_pos": getattr(mob, 'default_pos', 'standing'),
+        "sex": getattr(mob, 'sex', 'neutral'),
+        "wealth": getattr(mob, 'wealth', 0),
+        "form": getattr(mob, 'form', '0'),
+        "parts": getattr(mob, 'parts', '0'),
+        "size": getattr(mob, 'size', 'medium'),
+        "material": getattr(mob, 'material', '0'),
+    }
+
+def object_to_dict(obj) -> dict:
+    return {
+        "id": obj.vnum,
+        "name": obj.short_descr or "",
+        "description": obj.description or "",
+        "material": obj.material or "",
+        "item_type": getattr(obj, 'item_type', 'trash'),
+        "extra_flags": getattr(obj, 'extra_flags', ''),
+        "wear_flags": getattr(obj, 'wear_flags', ''),
+        "weight": getattr(obj, 'weight', 0),
+        "cost": getattr(obj, 'cost', 0),
+        "condition": getattr(obj, 'condition', 'P'),
+        "values": getattr(obj, 'value', [0, 0, 0, 0, 0]),
+        "affects": getattr(obj, 'affects', []),
+        "extra_descriptions": getattr(obj, 'extra_descr', []),
+    }
+
+def convert_area(path: str) -> dict:
+    clear_registries()
+    area = load_area_file(path)
+    rooms = [room_to_dict(r) for r in room_registry.values() if r.area is area]
+    mobiles = [mob_to_dict(m) for m in mob_registry.values() if m.area is area]
+    objects = [object_to_dict(o) for o in obj_registry.values() if o.area is area]
+    # Extract #SPECIALS mapping from prototypes for persistence
+    specials: list[dict] = []
+    for m in mob_registry.values():
+        if m.area is area and getattr(m, "spec_fun", None):
+            specials.append({"mob_vnum": m.vnum, "spec": str(m.spec_fun)})
+
+    # Convert area-level resets 
+    resets = []
+    for r in area.resets:
+        resets.append({
+            "command": r.command,
+            "arg1": r.arg1,
+            "arg2": r.arg2,
+            "arg3": r.arg3,
+            "arg4": r.arg4,
+        })
+
+    data = {
+        "name": area.name or "",
+        "vnum_range": {"min": area.min_vnum, "max": area.max_vnum},
+        "builders": [b.strip() for b in (area.builders or "").split(",") if b.strip()],
+        "rooms": rooms,
+        "mobiles": mobiles,
+        "objects": objects,
+        "resets": resets,
+        "specials": specials,
+    }
+    return data
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert ROM .are file to JSON")
+    parser.add_argument("input", help="Path to .are file")
+    parser.add_argument(
+        "--out-dir",
+        default=Path("data/areas"),
+        type=Path,
+        help="Directory to write JSON files (default: data/areas)",
+    )
+    args = parser.parse_args()
+    data = convert_area(args.input)
+    out_dir = args.out_dir
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / f"{Path(args.input).stem}.json"
+    out_file.write_text(json.dumps(data, indent=2) + "\n")
+
+if __name__ == "__main__":
+    main()

mud/scripts/convert_help_are_to_json.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def parse_help_are(path: Path) -> list[dict]:
+    """Parse a ROM #HELPS section from an .are file into JSON entries.
+
+    Preserves help text exactly (including spacing and newlines).
+    Each entry is a dict with: level:int, keywords:list[str], text:str.
+    """
+    entries: list[dict] = []
+    in_helps = False
+    level: int | None = None
+    keywords: list[str] | None = None
+    buf: list[str] = []
+
+    def flush_current() -> None:
+        nonlocal level, keywords, buf
+        if level is None or keywords is None:
+            return
+        text = "\n".join(buf)
+        entries.append({
+            "level": level,
+            "keywords": keywords,
+            "text": text,
+        })
+        level, keywords, buf = None, None, []
+
+    with path.open("r", encoding="utf-8", errors="ignore") as fp:
+        for raw in fp:
+            line = raw.rstrip("\n")
+            if not in_helps:
+                if line.strip() == "#HELPS":
+                    in_helps = True
+                continue
+
+            # End of helps section sentinel: `0 $~`
+            if line.strip() == "0 $~":
+                flush_current()
+                break
+
+            # New entry header: "<level> <keywords>~"
+            if level is None and line.strip():
+                # Some areas may have spacing/tabs before values; split once.
+                try:
+                    lvl_part, rest = line.strip().split(" ", 1)
+                except ValueError:
+                    # Malformed header; skip gracefully
+                    continue
+                # Header may end with trailing '~'
+                rest = rest.rstrip()
+                if rest.endswith("~"):
+                    rest = rest[:-1]
+                try:
+                    level = int(lvl_part)
+                except ValueError:
+                    # Not a numeric level; skip
+                    level = None
+                    continue
+                # Keywords are space-separated tokens
+                keywords = [tok for tok in rest.split() if tok]
+                buf = []
+                continue
+
+            # Inside help text body; a line with only '~' terminates the entry
+            if level is not None:
+                if line.strip() == "~":
+                    flush_current()
+                else:
+                    buf.append(line)
+
+    return entries
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Convert ROM help.are #HELPS to JSON")
+    ap.add_argument("infile", type=Path, help="Path to area/help.are")
+    ap.add_argument("outfile", type=Path, help="Output JSON path")
+    args = ap.parse_args()
+
+    entries = parse_help_are(args.infile)
+    args.outfile.parent.mkdir(parents=True, exist_ok=True)
+    with args.outfile.open("w", encoding="utf-8") as fp:
+        json.dump(entries, fp, ensure_ascii=False, indent=2)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
+

mud/scripts/convert_player_to_json.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+from typing import Tuple
+
+from mud.models.player_json import PlayerJson
+
+
+def _letters_to_bits(spec: str) -> int:
+    """Map a compact ROM letter-spec (e.g., "QT" or "NOP") to a bitmask.
+
+    Supports 'A'..'Z' → bits 0..25. Extended pairs like 'aa' not required for
+    this conversion but can be added later.
+    """
+    bits = 0
+    for ch in spec.strip():
+        if 'A' <= ch <= 'Z':
+            bits |= 1 << (ord(ch) - ord('A'))
+    return bits
+
+
+def _parse_hmv(tokens: list[str]) -> Tuple[int, int, int, int, int, int]:
+    # HMV <hit> <max_hit> <mana> <max_mana> <move> <max_move>
+    vals = [int(t) for t in tokens]
+    while len(vals) < 6:
+        vals.append(0)
+    return vals[0], vals[1], vals[2], vals[3], vals[4], vals[5]
+
+
+def convert_player(path: str | Path) -> PlayerJson:
+    name = ""
+    level = 0
+    room_vnum = None
+    hit = max_hit = mana = max_mana = move = max_move = 0
+    plr_flags = 0
+    comm_flags = 0
+
+    lines = Path(path).read_text(encoding="latin-1").splitlines()
+    # Validate header/footer sentinels
+    nonempty = [ln.strip() for ln in lines if ln.strip()]
+    if not nonempty or nonempty[0] != "#PLAYER":
+        raise ValueError("invalid player file: missing #PLAYER header")
+    if "#END" not in nonempty:
+        raise ValueError("invalid player file: missing #END footer")
+
+    for raw in lines:
+        line = raw.strip()
+        if not line:
+            continue
+        if line.startswith("Name "):
+            name = line.split(" ", 1)[1].rstrip("~")
+        elif line.startswith("Levl "):
+            try:
+                level = int(line.split()[1])
+            except Exception as e:
+                raise ValueError("invalid Levl field") from e
+        elif line.startswith("Room "):
+            try:
+                room_vnum = int(line.split()[1])
+            except Exception as e:
+                raise ValueError("invalid Room field") from e
+        elif line.startswith("HMV "):
+            vals = line.split()[1:]
+            if len(vals) != 6:
+                raise ValueError("invalid HMV field: expected 6 integers")
+            hit, max_hit, mana, max_mana, move, max_move = _parse_hmv(vals)
+        elif line.startswith("Act "):
+            spec = line.split()[1]
+            if not spec.isalpha() or not spec.isupper():
+                raise ValueError("invalid Act flags: expected A..Z letters")
+            plr_flags = _letters_to_bits(spec)
+        elif line.startswith("Comm "):
+            spec = line.split()[1]
+            if not spec.isalpha() or not spec.isupper():
+                raise ValueError("invalid Comm flags: expected A..Z letters")
+            comm_flags = _letters_to_bits(spec)
+
+    return PlayerJson(
+        name=name,
+        level=level,
+        hit=hit,
+        max_hit=max_hit,
+        mana=mana,
+        max_mana=max_mana,
+        move=move,
+        max_move=max_move,
+        gold=0,
+        silver=0,
+        exp=0,
+        position=0,
+        room_vnum=room_vnum,
+        inventory=[],
+        equipment={},
+        plr_flags=plr_flags,
+        comm_flags=comm_flags,
+    )
+
+
+def main() -> None:
+    import argparse
+    import json
+
+    parser = argparse.ArgumentParser(description="Convert ROM player file to JSON")
+    parser.add_argument("input", help="Path to legacy player file")
+    args = parser.parse_args()
+    pj = convert_player(args.input)
+    print(json.dumps(asdict(pj), indent=2))
+
+
+if __name__ == "__main__":
+    main()

mud/scripts/convert_shops_to_json.py

@@ -0,0 +1,64 @@
+import argparse
+import json
+from pathlib import Path
+
+from mud.loaders.area_loader import load_area_file
+from mud.models.constants import ItemType
+from mud.registry import shop_registry, area_registry, room_registry, mob_registry, obj_registry
+
+
+def clear_registries() -> None:
+    """Reset all global registries."""
+    shop_registry.clear()
+    area_registry.clear()
+    room_registry.clear()
+    mob_registry.clear()
+    obj_registry.clear()
+
+
+def shop_to_dict(shop) -> dict:
+    buy_types = []
+    for t in shop.buy_types:
+        if t == 0:
+            continue
+        try:
+            buy_types.append(ItemType(t).name.lower())
+        except ValueError:
+            buy_types.append(str(t))
+    return {
+        "keeper": shop.keeper,
+        "buy_types": buy_types,
+        "profit_buy": shop.profit_buy,
+        "profit_sell": shop.profit_sell,
+        "open_hour": shop.open_hour,
+        "close_hour": shop.close_hour,
+    }
+
+
+def convert_shops(area_list: str) -> list[dict]:
+    """Load areas listed in ``area_list`` and return shop dicts."""
+    clear_registries()
+    area_dir = Path(area_list).parent
+    with open(area_list, "r", encoding="latin-1") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("$"):
+                continue
+            load_area_file(str(area_dir / line))
+    return [shop_to_dict(s) for s in shop_registry.values()]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Convert #SHOPS to JSON")
+    parser.add_argument("area_list", help="Path to area.lst")
+    parser.add_argument(
+        "--out", default=Path("data/shops.json"), type=Path, help="Output JSON file"
+    )
+    args = parser.parse_args()
+    data = convert_shops(args.area_list)
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(json.dumps(data, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    main()