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

mud/models/help.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .help_json import HelpJson
+
+
+@dataclass
+class HelpEntry:
+    """Runtime representation of a help entry."""
+
+    keywords: list[str]
+    text: str
+    level: int = 0
+
+    @classmethod
+    def from_json(cls, data: HelpJson) -> "HelpEntry":
+        return cls(**data.to_dict())
+
+
+# placeholder registry to track loaded help entries
+help_registry: dict[str, HelpEntry] = {}
+
+
+def register_help(entry: HelpEntry) -> None:
+    """Register a help entry under each keyword."""
+    for keyword in entry.keywords:
+        help_registry[keyword.lower()] = entry

mud/models/help_json.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class HelpJson(JsonDataclass):
+    """Help entry matching ``schemas/help.schema.json``."""
+
+    keywords: list[str]
+    text: str
+    level: int = 0

mud/models/json_io.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+from dataclasses import MISSING, asdict, fields, is_dataclass
+from typing import Any, Type, TypeVar, get_args, get_origin, get_type_hints, cast
+
+T = TypeVar("T")
+JsonT = TypeVar("JsonT", bound="JsonDataclass")
+
+
+def _convert_value(annotation, value):
+    origin = get_origin(annotation)
+    if is_dataclass(annotation):
+        return dataclass_from_dict(annotation, value)
+    if origin is list:
+        (item_type,) = get_args(annotation)
+        return [_convert_value(item_type, v) for v in value]
+    if origin is dict:
+        key_type, val_type = get_args(annotation)
+        # assume keys are primitive; only convert values
+        return {k: _convert_value(val_type, v) for k, v in value.items()}
+    return value
+
+
+def dataclass_from_dict(cls: Type[T], data: dict) -> T:
+    """Instantiate ``cls`` from ``data`` applying dataclass defaults."""
+    kwargs = {}
+    hints = get_type_hints(cls)
+    for f in fields(cast(Any, cls)):
+        ann = hints.get(f.name, f.type)
+        if f.name in data:
+            kwargs[f.name] = _convert_value(ann, data[f.name])
+        elif f.default is not MISSING:
+            kwargs[f.name] = f.default
+        elif f.default_factory is not MISSING:  # type: ignore[attr-defined]
+            kwargs[f.name] = f.default_factory()  # type: ignore[misc]
+    return cls(**kwargs)  # type: ignore[arg-type]
+
+
+def dataclass_to_dict(obj: Any) -> dict:
+    """Convert ``obj`` into a JSON-serializable ``dict``."""
+    return asdict(obj)
+
+
+def load_dataclass(cls: Type[T], fp) -> T:
+    """Load ``cls`` from a JSON file-like object."""
+    data = json.load(fp)
+    return dataclass_from_dict(cls, data)
+
+
+def dump_dataclass(obj: Any, fp, **json_kwargs) -> None:
+    """Dump dataclass instance ``obj`` to ``fp`` as JSON."""
+    json.dump(dataclass_to_dict(obj), fp, **json_kwargs)
+
+
+class JsonDataclass:
+    """Mixin adding ``to_dict``/``from_dict`` helpers to dataclasses."""
+
+    def to_dict(self) -> dict:
+        return dataclass_to_dict(self)
+
+    @classmethod
+    def from_dict(cls: Type[JsonT], data: dict) -> JsonT:
+        return dataclass_from_dict(cls, data)

mud/models/mob.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+@dataclass
+class MobProgram:
+    """Representation of MPROG_LIST"""
+    trig_type: int
+    trig_phrase: Optional[str] = None
+    vnum: int = 0
+    code: Optional[str] = None
+
+@dataclass
+class MobIndex:
+    """Python representation of MOB_INDEX_DATA"""
+    vnum: int
+    player_name: Optional[str] = None
+    short_descr: Optional[str] = None
+    long_descr: Optional[str] = None
+    description: Optional[str] = None
+    race: Optional[str] = None
+    act_flags: str = ''
+    affected_by: str = ''
+    alignment: int = 0
+    group: int = 0
+    level: int = 1
+    thac0: int = 20
+    ac: str = '1d1+0'
+    hit_dice: str = '1d1+0'
+    mana_dice: str = '1d1+0'
+    damage_dice: str = '1d4+0'
+    damage_type: str = 'beating'
+    ac_pierce: int = 0
+    ac_bash: int = 0
+    ac_slash: int = 0
+    ac_exotic: int = 0
+    offensive: str = ''
+    immune: str = ''
+    resist: str = ''
+    vuln: str = ''
+    start_pos: str = 'standing'
+    default_pos: str = 'standing'
+    sex: str = 'neutral'
+    wealth: int = 0
+    form: str = '0'
+    parts: str = '0'
+    size: str = 'medium'
+    material: str = '0'
+    spec_fun: Optional[str] = None
+    pShop: Optional[object] = None
+    mprogs: List[MobProgram] = field(default_factory=list)
+    area: Optional['Area'] = None
+    new_format: bool = False
+    count: int = 0
+    killed: int = 0
+    # Legacy compatibility fields
+    act: int = 0
+    hitroll: int = 0
+    hit: Tuple[int, int, int] = (0, 0, 0)
+    mana: Tuple[int, int, int] = (0, 0, 0)
+    damage: Tuple[int, int, int] = (0, 0, 0)
+    dam_type: int = 0
+    off_flags: int = 0
+    imm_flags: int = 0
+    res_flags: int = 0
+    vuln_flags: int = 0
+    start_pos: int = 0
+    default_pos: int = 0
+    sex: int = 0
+    race: int = 0
+    wealth: int = 0
+    form: int = 0
+    parts: int = 0
+    size: int = 0
+    material: Optional[str] = None
+    mprog_flags: int = 0
+
+    def __repr__(self) -> str:
+        return f"<MobIndex vnum={self.vnum} name={self.short_descr!r}>"
+
+
+mob_registry: dict[int, MobIndex] = {}

mud/models/note.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .note_json import NoteJson
+
+
+@dataclass
+class Note:
+    """Runtime representation of a message board note."""
+
+    sender: str
+    to: str
+    subject: str
+    text: str
+    timestamp: float
+
+    def to_json(self) -> NoteJson:
+        return NoteJson(
+            sender=self.sender,
+            to=self.to,
+            subject=self.subject,
+            text=self.text,
+            timestamp=self.timestamp,
+        )
+
+    @classmethod
+    def from_json(cls, data: NoteJson) -> "Note":
+        return cls(**data.to_dict())

mud/models/note_json.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class NoteJson(JsonDataclass):
+    """Schema-aligned representation of a message board note."""
+
+    sender: str
+    to: str
+    subject: str
+    text: str
+    timestamp: float

mud/models/obj.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+from .room import ExtraDescr, Room
+from .character import Character
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+@dataclass
+class Affect:
+    """Representation of AFFECT_DATA"""
+    where: int
+    type: int
+    level: int
+    duration: int
+    location: int
+    modifier: int
+    bitvector: int
+
+@dataclass
+class ObjIndex:
+    """Python representation of OBJ_INDEX_DATA"""
+    vnum: int
+    name: Optional[str] = None
+    short_descr: Optional[str] = None
+    description: Optional[str] = None
+    material: Optional[str] = None
+    item_type: str = 'trash'
+    extra_flags: int = 0
+    wear_flags: str = ''
+    level: int = 0
+    condition: str = 'P'
+    count: int = 0
+    weight: int = 0
+    cost: int = 0
+    value: List[int] = field(default_factory=lambda: [0] * 5)
+    affects: List[dict] = field(default_factory=list)  # {'location': int, 'modifier': int}
+    extra_descr: List[dict] = field(default_factory=list)  # {'keyword': str, 'description': str}
+    area: Optional['Area'] = None
+    new_format: bool = False
+    reset_num: int = 0
+    next: Optional['ObjIndex'] = None
+    # Legacy compatibility
+    affected: List[Affect] = field(default_factory=list)
+
+    def __repr__(self) -> str:
+        return f"<ObjIndex vnum={self.vnum} name={self.short_descr!r}>"
+
+obj_index_registry: dict[int, ObjIndex] = {}
+
+@dataclass
+class ObjectData:
+    """Python representation of OBJ_DATA"""
+    item_type: int
+    extra_flags: int = 0
+    wear_flags: int = 0
+    wear_loc: int = 0
+    weight: int = 0
+    cost: int = 0
+    level: int = 0
+    condition: int = 0
+    timer: int = 0
+    value: List[int] = field(default_factory=lambda: [0] * 5)
+    owner: Optional[str] = None
+    name: Optional[str] = None
+    short_descr: Optional[str] = None
+    description: Optional[str] = None
+    material: Optional[str] = None
+    carried_by: Optional['Character'] = None
+    in_obj: Optional['ObjectData'] = None
+    contains: List['ObjectData'] = field(default_factory=list)
+    extra_descr: List['ExtraDescr'] = field(default_factory=list)
+    affected: List[Affect] = field(default_factory=list)
+    pIndexData: Optional[ObjIndex] = None
+    in_room: Optional['Room'] = None
+    enchanted: bool = False
+    next_content: Optional['ObjectData'] = None
+    next: Optional['ObjectData'] = None
+
+    def __repr__(self) -> str:
+        return f"<ObjectData type={self.item_type} name={self.short_descr!r}>"
+
+
+object_registry: list[ObjectData] = []

mud/models/object.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .room import Room
+
+from .obj import ObjIndex
+
+
+@dataclass
+class Object:
+    """Instance of an object tied to a prototype."""
+    instance_id: Optional[int]
+    prototype: ObjIndex
+    location: Optional['Room'] = None
+    contained_items: List['Object'] = field(default_factory=list)
+    level: int = 0
+    # Instance values — copy of prototype.value for runtime mutations (e.g., locks/charges)
+    value: List[int] = field(default_factory=lambda: [0, 0, 0, 0, 0])
+
+    @property
+    def name(self) -> Optional[str]:
+        return self.prototype.name
+
+    @property
+    def short_descr(self) -> Optional[str]:
+        return getattr(self.prototype, "short_descr", None)

mud/models/object_json.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class AffectJson(JsonDataclass):
+    """Per-object affect modifier."""
+    location: str
+    modifier: int
+
+
+@dataclass
+class ExtraDescriptionJson(JsonDataclass):
+    """Extra description block for objects."""
+    keyword: str
+    description: str
+
+
+@dataclass
+class ObjectJson(JsonDataclass):
+    """Object record matching ``schemas/object.schema.json``."""
+    id: int
+    name: str
+    description: str
+    item_type: str
+    values: List[int]
+    weight: int
+    cost: int
+    short_description: Optional[str] = None
+    flags: List[str] = field(default_factory=list)
+    wear_flags: List[str] = field(default_factory=list)
+    level: int = 0
+    condition: int = 0
+    material: str = ""
+    affects: List[AffectJson] = field(default_factory=list)
+    extra_descriptions: List[ExtraDescriptionJson] = field(default_factory=list)

mud/models/player_json.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class PlayerJson(JsonDataclass):
+    """Player record matching ``schemas/player.schema.json``."""
+
+    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
+    room_vnum: Optional[int]
+    inventory: List[int] = field(default_factory=list)
+    equipment: Dict[str, int] = field(default_factory=dict)
+    plr_flags: int = 0
+    comm_flags: int = 0

mud/models/room.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mud.models.object import Object
+    from mud.spawning.templates import MobInstance
+    from mud.models.area import Area
+    from mud.models.character import Character
+
+from .constants import Direction
+from .room_json import ResetJson
+
+@dataclass
+class ExtraDescr:
+    """Python representation of EXTRA_DESCR_DATA"""
+    keyword: Optional[str] = None
+    description: Optional[str] = None
+
+@dataclass
+class Exit:
+    """Representation of EXIT_DATA"""
+    to_room: Optional['Room'] = None
+    vnum: Optional[int] = None
+    exit_info: int = 0
+    key: int = 0
+    keyword: Optional[str] = None
+    description: Optional[str] = None
+    flags: str = '0'  # String representation of exit flags
+    rs_flags: int = 0
+    orig_door: int = 0
+
+@dataclass
+class Room:
+    """Runtime room container built from area files."""
+    vnum: int
+    name: Optional[str] = None
+    description: Optional[str] = None
+    owner: Optional[str] = None
+    area: Optional['Area'] = None
+    room_flags: int = 0
+    light: int = 0
+    sector_type: int = 0
+    heal_rate: int = 0
+    mana_rate: int = 0
+    clan: int = 0
+    exits: List[Optional[Exit]] = field(default_factory=lambda: [None] * len(Direction))
+    extra_descr: List[ExtraDescr] = field(default_factory=list)
+    resets: List[ResetJson] = field(default_factory=list)
+    people: List['Character'] = field(default_factory=list)
+    contents: List['Object'] = field(default_factory=list)
+    next: Optional['Room'] = None
+
+    def __repr__(self) -> str:
+        return f"<Room vnum={self.vnum} name={self.name!r}>"
+
+    def add_character(self, char: 'Character') -> None:
+        if char not in self.people:
+            self.people.append(char)
+        char.room = self
+
+    def remove_character(self, char: 'Character') -> None:
+        if char in self.people:
+            self.people.remove(char)
+
+    def add_object(self, obj: 'Object') -> None:
+        if obj not in self.contents:
+            self.contents.append(obj)
+        if hasattr(obj, "location"):
+            obj.location = self
+
+    def add_mob(self, mob: 'MobInstance') -> None:
+        if mob not in self.people:
+            self.people.append(mob)
+        mob.room = self
+
+    def broadcast(self, message: str, exclude: Optional['Character'] = None) -> None:
+        for char in self.people:
+            if char is exclude:
+                continue
+            if hasattr(char, 'messages'):
+                char.messages.append(message)
+
+
+room_registry: dict[int, Room] = {}
+

mud/models/room_json.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class ExitJson(JsonDataclass):
+    """Exit specification for JSON rooms."""
+    to_room: int
+    description: Optional[str] = None
+    keyword: Optional[str] = None
+    flags: List[str] = field(default_factory=list)
+
+
+@dataclass
+class ExtraDescriptionJson(JsonDataclass):
+    """Extra description block for JSON rooms."""
+    keyword: str
+    description: str
+
+
+@dataclass
+class ResetJson(JsonDataclass):
+    """Reset command affecting a room."""
+    command: str
+    arg1: Optional[int] = None
+    arg2: Optional[int] = None
+    arg3: Optional[int] = None
+    arg4: Optional[int] = None
+
+
+@dataclass
+class RoomJson(JsonDataclass):
+    """Room record matching ``schemas/room.schema.json``."""
+    id: int
+    name: str
+    description: str
+    sector_type: str
+    area: int
+    flags: List[str] = field(default_factory=list)
+    exits: Dict[str, ExitJson] = field(default_factory=dict)
+    extra_descriptions: List[ExtraDescriptionJson] = field(default_factory=list)
+    resets: List[ResetJson] = field(default_factory=list)

mud/models/shop.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .shop_json import ShopJson
+
+
+@dataclass
+class Shop:
+    """Runtime representation of a shop."""
+
+    keeper: int
+    buy_types: list[str] = field(default_factory=list)
+    profit_buy: int = 100
+    profit_sell: int = 100
+    open_hour: int = 0
+    close_hour: int = 23
+
+    @classmethod
+    def from_json(cls, data: ShopJson) -> "Shop":
+        return cls(**data.to_dict())

mud/models/shop_json.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class ShopJson(JsonDataclass):
+    """Shop record matching ``schemas/shop.schema.json``."""
+
+    keeper: int
+    buy_types: list[str] = field(default_factory=list)
+    profit_buy: int = 100
+    profit_sell: int = 100
+    open_hour: int = 0
+    close_hour: int = 23

mud/models/skill.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict
+
+from .skill_json import SkillJson
+
+
+@dataclass
+class Skill:
+    """Runtime representation of a skill or spell."""
+
+    name: str
+    type: str
+    function: str
+    target: str = "victim"
+    mana_cost: int = 0
+    lag: int = 0
+    cooldown: int = 0
+    failure_rate: float = 0.0
+    messages: Dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_json(cls, data: SkillJson) -> "Skill":
+        return cls(**data.to_dict())

mud/models/skill_json.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .json_io import JsonDataclass
+
+
+@dataclass
+class SkillJson(JsonDataclass):
+    """Schema-aligned representation of a skill or spell."""
+
+    name: str
+    type: str
+    function: str
+    target: str = "victim"
+    mana_cost: int = 0
+    lag: int = 0
+    cooldown: int = 0
+    failure_rate: float = 0.0
+    messages: dict[str, str] = field(default_factory=dict)