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

mud/loaders/reset_loader.py

@@ -0,0 +1,29 @@
+from .base_loader import BaseTokenizer
+from mud.models.room_json import ResetJson
+
+
+def load_resets(tokenizer: BaseTokenizer, area):
+    """Parse reset lines and store them on the area."""
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        if line == 'S':
+            continue
+        if line == '$' or line.startswith('#'):
+            # allow outer loader to handle following sections
+            tokenizer.index -= 1
+            break
+        parts = line.split()
+        if not parts:
+            continue
+        cmd = parts[0]
+        try:
+            nums = [int(p) for p in parts[1:] if p.lstrip('-').isdigit()]
+        except ValueError:
+            continue
+        # pad to four integers
+        while len(nums) < 4:
+            nums.append(0)
+        reset = ResetJson(command=cmd, arg1=nums[0], arg2=nums[1], arg3=nums[2], arg4=nums[3])
+        area.resets.append(reset)

mud/loaders/room_loader.py

@@ -0,0 +1,63 @@
+from mud.models.room import Room, Exit, ExtraDescr
+from mud.registry import room_registry
+from .base_loader import BaseTokenizer
+
+
+def load_rooms(tokenizer: BaseTokenizer, area):
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        if line.startswith('#'):
+            if line == '#0':
+                break
+            vnum = int(line[1:])
+            name = tokenizer.next_line().rstrip('~')
+            desc = tokenizer.read_string_tilde()
+            flags_line = tokenizer.next_line()
+            tokens = flags_line.split()
+            room_flags = int(tokens[0]) if tokens else 0
+            sector_type = int(tokens[-1]) if tokens else 0
+            room = Room(vnum=vnum, name=name, description=desc, room_flags=room_flags, sector_type=sector_type, area=area)
+            room_registry[vnum] = room
+            # parse additional blocks until 'S'
+            while True:
+                peek = tokenizer.peek_line()
+                if peek is None:
+                    break
+                if peek.startswith('D'):
+                    dir_line = tokenizer.next_line()
+                    exit_desc = tokenizer.read_string_tilde()
+                    exit_keywords = tokenizer.read_string_tilde()
+                    info_line = tokenizer.next_line()
+                    if info_line is None:
+                        break
+                    info_parts = info_line.split()
+                    exit_flags = info_parts[0] if len(info_parts) >= 1 else '0'
+                    if len(info_parts) >= 3:
+                        key = int(info_parts[1])
+                        to_vnum = int(info_parts[2])
+                    else:
+                        key = 0
+                        to_vnum = 0
+                    exit_obj = Exit(vnum=to_vnum, key=key, description=exit_desc, keyword=exit_keywords, flags=exit_flags)
+                    # direction char at Dn
+                    idx = int(dir_line[1])
+                    if idx < len(room.exits):
+                        room.exits[idx] = exit_obj
+                    continue
+                if peek.startswith('E'):
+                    tokenizer.next_line()
+                    keyword = tokenizer.next_line().rstrip('~')
+                    descr = tokenizer.read_string_tilde()
+                    room.extra_descr.append(ExtraDescr(keyword=keyword, description=descr))
+                    continue
+                if peek == 'S':
+                    tokenizer.next_line()
+                    break
+                if peek.startswith('#'):
+                    break
+                # consume unknown line
+                tokenizer.next_line()
+        elif line == '$':
+            break

mud/loaders/shop_loader.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass, field
+from .base_loader import BaseTokenizer
+from mud.registry import shop_registry
+
+
+@dataclass
+class Shop:
+    """Minimal representation of SHOP_DATA."""
+
+    keeper: int
+    buy_types: list[int] = field(default_factory=list)
+    profit_buy: int = 100
+    profit_sell: int = 100
+    open_hour: int = 0
+    close_hour: int = 23
+
+
+def load_shops(tokenizer: BaseTokenizer, area) -> None:
+    """Load shop entries and register by keeper vnum."""
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        line = line.strip()
+        if not line or line.startswith('0'):
+            break
+        parts = line.split()
+        keeper = int(parts[0])
+        buy_types = [int(p) for p in parts[1:6]]
+        profit_buy = int(parts[6]) if len(parts) > 6 else 100
+        profit_sell = int(parts[7]) if len(parts) > 7 else 100
+        open_hour = int(parts[8]) if len(parts) > 8 else 0
+        close_hour = int(parts[9]) if len(parts) > 9 else 23
+        shop_registry[keeper] = Shop(
+            keeper=keeper,
+            buy_types=buy_types,
+            profit_buy=profit_buy,
+            profit_sell=profit_sell,
+            open_hour=open_hour,
+            close_hour=close_hour,
+        )

mud/loaders/social_loader.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mud.models.social import Social, register_social
+from mud.models.social_json import SocialJson
+
+
+def load_socials(path: str) -> None:
+    """Load socials from a JSON file into the registry."""
+    with open(Path(path), "r", encoding="utf-8") as f:
+        data = json.load(f)
+    for entry in data:
+        sj = SocialJson(**entry)
+        register_social(Social.from_json(sj))

mud/loaders/specials_loader.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from mud.registry import mob_registry
+from .base_loader import BaseTokenizer
+
+
+def load_specials(tokenizer: BaseTokenizer, area) -> None:
+    """Load #SPECIALS section and attach spec_fun names to MobIndex.
+
+    Format (doc/area.txt § #SPECIALS):
+      #SPECIALS
+      { M <mob-vnum> <spec-fun> <comment-to-eol> }
+      S
+    """
+    while True:
+        line = tokenizer.next_line()
+        if line is None:
+            break
+        s = line.strip()
+        if not s:
+            continue
+        if s == 'S':
+            break
+        if not s or s.startswith('*'):
+            continue
+        if s[0] in '{':
+            # Lines may be grouped in braces; consume but ignore braces
+            s = s.lstrip('{').rstrip('}')
+            s = s.strip()
+            if not s:
+                continue
+        if s.startswith('M '):
+            parts = s.split()
+            # parts: ['M', '<vnum>', '<spec>'] + optional comments
+            if len(parts) >= 3:
+                try:
+                    vnum = int(parts[1])
+                except ValueError:
+                    continue
+                spec_name = parts[2]
+                proto = mob_registry.get(vnum)
+                if proto is not None:
+                    proto.spec_fun = spec_name
+    # No return value needed; registry updated in place
+
+
+def apply_specials_from_json(entries: list[dict]) -> None:
+    """Attach spec_fun names from a JSON "specials" list to mob prototypes.
+
+    Each entry must be a dict with keys: {"mob_vnum": int, "spec": str}.
+    Unknown vnums are ignored (matching ROM's tolerant loaders).
+    """
+    for entry in entries or []:
+        try:
+            vnum = int(entry.get("mob_vnum"))
+        except Exception:
+            continue
+        spec = entry.get("spec")
+        if not spec:
+            continue
+        proto = mob_registry.get(vnum)
+        if proto is not None:
+            proto.spec_fun = str(spec)

mud/logging/admin.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+
+def log_admin_command(actor: str, command: str, args: str) -> None:
+    """Append a single admin-command entry to log/admin.log.
+
+    Format: ISO timestamp, actor, command, args (space-joined).
+    Creates the log directory if missing.
+    """
+    Path("log").mkdir(exist_ok=True)
+    line = f"{datetime.utcnow().isoformat()}Z\t{actor}\t{command}\t{args}\n"
+    (Path("log") / "admin.log").open("a", encoding="utf-8").write(line)
+
+
+def rotate_admin_log(today: datetime | None = None) -> Path:
+    """Rotate admin.log to a date-stamped file once per (real) day.
+
+    - If ``log/admin.log`` exists, rename it to ``log/admin-YYYYMMDD.log``.
+    - Always return the new active path (``log/admin.log``).
+    The ``today`` parameter allows tests to inject a deterministic date.
+    """
+    log_dir = Path("log")
+    log_dir.mkdir(exist_ok=True)
+    active = log_dir / "admin.log"
+    if not active.exists():
+        return active
+    dt = today or datetime.utcnow()
+    dated = log_dir / f"admin-{dt.strftime('%Y%m%d')}.log"
+    # Avoid clobbering: if dated file exists, append current log and remove active
+    if dated.exists():
+        dated.open("a", encoding="utf-8").write(active.read_text(encoding="utf-8"))
+        active.unlink()
+    else:
+        active.rename(dated)
+    # Create a fresh active log file
+    active.touch()
+    return active

mud/logging/agent_trace.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+from typing import Any, Dict
+
+
+def log_agent_action(agent_id: str, observation: Dict[str, Any], action: str, result: str) -> None:
+    Path("log").mkdir(exist_ok=True)
+    log_path = Path("log") / f"agent_{agent_id}.log"
+    with log_path.open("a") as f:
+        f.write(f"\nOBS: {observation}\nACT: {action}\nRES: {result}\n{'='*40}\n")

mud/math/c_compat.py

@@ -0,0 +1,27 @@
+"""C-compatibility helpers (division/modulo/clamp).
+
+Matches C integer division semantics (truncate toward zero), unlike Python's
+"//" which floors toward negative infinity.
+"""
+from __future__ import annotations
+
+
+def c_div(a: int, b: int) -> int:
+    """C-style integer division (truncate toward zero)."""
+    if b == 0:
+        raise ZeroDivisionError("c_div by zero")
+    q = abs(a) // abs(b)
+    return q if (a >= 0) == (b >= 0) else -q
+
+
+def c_mod(a: int, b: int) -> int:
+    """C-style modulo consistent with c_div: a == b * c_div(a,b) + c_mod(a,b)."""
+    if b == 0:
+        raise ZeroDivisionError("c_mod by zero")
+    return a - b * c_div(a, b)
+
+
+def urange(low: int, val: int, high: int) -> int:
+    """Clamp to [low, high] inclusive, like ROM's URANGE macro."""
+    return max(low, min(val, high))
+

mud/mobprog.py

@@ -0,0 +1,72 @@
+"""Basic mob program trigger handling and interpreter."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntFlag
+from typing import Iterable
+
+from .models.mob import MobIndex
+
+
+class Trigger(IntFlag):
+    """Bit flags describing mob program trigger types."""
+
+    ACT = 1 << 0
+    BRIBE = 1 << 1
+    DEATH = 1 << 2
+    ENTRY = 1 << 3
+    FIGHT = 1 << 4
+    GIVE = 1 << 5
+    GREET = 1 << 6
+    GRALL = 1 << 7
+    KILL = 1 << 8
+    HPCNT = 1 << 9
+    RANDOM = 1 << 10
+    SPEECH = 1 << 11
+    EXIT = 1 << 12
+    EXALL = 1 << 13
+    DELAY = 1 << 14
+    SURR = 1 << 15
+
+
+@dataclass
+class ExecutionResult:
+    """Represents a single action performed by the interpreter."""
+
+    command: str
+    argument: str
+
+
+def run_prog(
+    mob: MobIndex, trig: Trigger, *, phrase: str | None = None
+) -> list[ExecutionResult]:
+    """Run mob programs matching *trig* and *phrase*.
+
+    This very small interpreter only understands ``say`` and ``emote``
+    commands and returns the actions performed for testing.
+    """
+
+    results: list[ExecutionResult] = []
+    for prog in mob.mprogs:
+        if prog.code is None:
+            continue
+        if not prog.trig_type & int(trig):
+            continue
+        if prog.trig_phrase and phrase is not None:
+            if prog.trig_phrase.lower() not in phrase.lower():
+                continue
+        results.extend(_execute(prog.code))
+    return results
+
+
+def _execute(code: str) -> Iterable[ExecutionResult]:
+    for raw_line in code.strip().splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        if line.startswith("say "):
+            yield ExecutionResult("say", line[4:].strip())
+        elif line.startswith("emote "):
+            yield ExecutionResult("emote", line[6:].strip())
+        # other mob commands ignored for now

mud/models/__init__.py

@@ -0,0 +1,106 @@
+"""Data models for QuickMUD translated from C structs."""
+
+from .area import Area
+from .room import Room, ExtraDescr, Exit
+from .room_json import ResetJson as Reset
+from .mob import MobIndex, MobProgram
+from .obj import ObjIndex, ObjectData, Affect
+from .object import Object
+from .character import Character, PCData
+from .shop import Shop
+from .skill import Skill
+from .help import HelpEntry
+from .social import Social
+from .board import Board
+from .note import Note
+from .constants import (
+    Direction,
+    Sector,
+    Position,
+    WearLocation,
+    Sex,
+    Size,
+    ItemType,
+)
+
+from .area_json import AreaJson, VnumRangeJson
+from .room_json import (
+    RoomJson,
+    ExitJson,
+    ExtraDescriptionJson as RoomExtraDescriptionJson,
+    ResetJson,
+)
+from .object_json import (
+    ObjectJson,
+    AffectJson as ObjectAffectJson,
+    ExtraDescriptionJson as ObjectExtraDescriptionJson,
+)
+from .character_json import CharacterJson, StatsJson, ResourceJson
+from .player_json import PlayerJson
+from .skill_json import SkillJson
+from .shop_json import ShopJson
+from .help_json import HelpJson
+from .social_json import SocialJson
+from .board_json import BoardJson
+from .note_json import NoteJson
+from .json_io import (
+    JsonDataclass,
+    dataclass_from_dict,
+    dataclass_to_dict,
+    dump_dataclass,
+    load_dataclass,
+)
+
+__all__ = [
+    "Area",
+    "Room",
+    "ExtraDescr",
+    "Exit",
+    "Reset",
+    "MobIndex",
+    "MobProgram",
+    "ObjIndex",
+    "ObjectData",
+    "Object",
+    "Affect",
+    "Character",
+    "PCData",
+    "Shop",
+    "Skill",
+    "HelpEntry",
+    "Social",
+    "Board",
+    "Note",
+    # JSON schema-aligned dataclasses
+    "AreaJson",
+    "VnumRangeJson",
+    "RoomJson",
+    "ExitJson",
+    "RoomExtraDescriptionJson",
+    "ResetJson",
+    "ObjectJson",
+    "ObjectAffectJson",
+    "ObjectExtraDescriptionJson",
+    "CharacterJson",
+    "StatsJson",
+    "ResourceJson",
+    "PlayerJson",
+    "SkillJson",
+    "ShopJson",
+    "HelpJson",
+    "SocialJson",
+    "BoardJson",
+    "NoteJson",
+    "JsonDataclass",
+    "dataclass_from_dict",
+    "dataclass_to_dict",
+    "load_dataclass",
+    "dump_dataclass",
+    "Direction",
+    "Sector",
+    "Position",
+    "WearLocation",
+    "Sex",
+    "Size",
+    "ItemType",
+]

mud/models/area.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .room_json import ResetJson
+
+
+@dataclass
+class Area:
+    """Runtime area container loaded from legacy files."""
+    file_name: Optional[str] = None
+    name: Optional[str] = None
+    credits: Optional[str] = None
+    age: int = 0
+    nplayer: int = 0
+    low_range: int = 0
+    high_range: int = 0
+    min_vnum: int = 0
+    max_vnum: int = 0
+    empty: bool = False
+    builders: Optional[str] = None
+    vnum: int = 0
+    area_flags: int = 0
+    security: int = 0
+    helps: List[object] = field(default_factory=list)
+    resets: List[ResetJson] = field(default_factory=list)
+    next: Optional['Area'] = None
+
+    def __repr__(self) -> str:
+        return f"<Area vnum={self.vnum} name={self.name!r}>"
+
+
+area_registry: dict[int, Area] = {}

mud/models/area_json.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+from .room_json import RoomJson
+from .character_json import CharacterJson
+from .object_json import ObjectJson
+from .json_io import JsonDataclass
+
+
+@dataclass
+class VnumRangeJson(JsonDataclass):
+    """Minimum and maximum vnums for an area."""
+    min: int
+    max: int
+
+
+@dataclass
+class AreaJson(JsonDataclass):
+    """Area record matching ``schemas/area.schema.json``."""
+    name: str
+    vnum_range: VnumRangeJson
+    builders: List[str] = field(default_factory=list)
+    rooms: List[RoomJson] = field(default_factory=list)
+    mobiles: List[CharacterJson] = field(default_factory=list)
+    objects: List[ObjectJson] = field(default_factory=list)

mud/models/board.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+import time
+
+from .board_json import BoardJson
+from .note import Note
+
+
+@dataclass
+class Board:
+    """Runtime representation of a message board."""
+
+    name: str
+    description: str
+    notes: List[Note] = field(default_factory=list)
+
+    def post(
+        self,
+        sender: str,
+        subject: str,
+        text: str,
+        to: str = "all",
+    ) -> Note:
+        note = Note(
+            sender=sender,
+            to=to,
+            subject=subject,
+            text=text,
+            timestamp=time.time(),
+        )
+        self.notes.append(note)
+        return note
+
+    def to_json(self) -> BoardJson:
+        return BoardJson(
+            name=self.name,
+            description=self.description,
+            notes=[n.to_json() for n in self.notes],
+        )
+
+    @classmethod
+    def from_json(cls, data: BoardJson) -> "Board":
+        return cls(
+            name=data.name,
+            description=data.description,
+            notes=[Note.from_json(n) for n in data.notes],
+        )

mud/models/board_json.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+from .json_io import JsonDataclass
+from .note_json import NoteJson
+
+
+@dataclass
+class BoardJson(JsonDataclass):
+    """Schema-aligned representation of a message board."""
+
+    name: str
+    description: str
+    notes: List[NoteJson] = field(default_factory=list)