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

mud/skills/registry.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+from importlib import import_module
+from pathlib import Path
+from random import Random
+from typing import Callable, Dict, Optional
+
+from mud.models import Skill, SkillJson
+from mud.utils import rng_mm
+from mud.models.json_io import dataclass_from_dict
+
+
+class SkillRegistry:
+    """Load skill metadata from JSON and dispatch handlers."""
+
+    def __init__(self, rng: Optional[Random] = None) -> None:
+        self.skills: Dict[str, Skill] = {}
+        self.handlers: Dict[str, Callable] = {}
+        self.rng = rng or Random()
+
+    def load(self, path: Path) -> None:
+        """Load skill definitions from a JSON file."""
+        with path.open() as fp:
+            data = json.load(fp)
+        module = import_module("mud.skills.handlers")
+        for entry in data:
+            skill_json = dataclass_from_dict(SkillJson, entry)
+            skill = Skill.from_json(skill_json)
+            handler = getattr(module, skill.function)
+            self.skills[skill.name] = skill
+            self.handlers[skill.name] = handler
+
+    def get(self, name: str) -> Skill:
+        return self.skills[name]
+
+    def use(self, caster, name: str, target=None):
+        """Execute a skill and handle resource costs and failure.
+
+        Parity: If the caster has a learned percentage for this skill in
+        `caster.skills[name]` (0..100), success is determined by a ROM-style
+        percent roll (number_percent) against that learned value. If no
+        learned value is present, fall back to `failure_rate` as before.
+        """
+        skill = self.get(name)
+        if caster.mana < skill.mana_cost:
+            raise ValueError("not enough mana")
+
+        cooldowns = getattr(caster, "cooldowns", {})
+        if cooldowns.get(name, 0) > 0:
+            raise ValueError("skill on cooldown")
+
+        caster.mana -= skill.mana_cost
+        # ROM parity: prefer per-character learned% when available
+        learned = None
+        try:
+            learned = caster.skills.get(name)  # 0..100
+        except Exception:
+            # Characters without a `skills` mapping should not error
+            learned = None
+
+        if learned is not None:
+            # Success when roll <= learned (ROM practice mechanics)
+            if rng_mm.number_percent() > int(learned):
+                cooldowns[name] = skill.cooldown
+                caster.cooldowns = cooldowns
+                return False
+        else:
+            # Fallback: use failure_rate gate (legacy behavior)
+            # Convert float failure_rate (0.0..1.0) to percentage threshold 0..100
+            failure_threshold = int(round(skill.failure_rate * 100))
+            if rng_mm.number_percent() <= failure_threshold:
+                cooldowns[name] = skill.cooldown
+                caster.cooldowns = cooldowns
+                return False
+            # Success path (roll > threshold): execute handler
+
+        result = self.handlers[name](caster, target)
+        cooldowns[name] = skill.cooldown
+        caster.cooldowns = cooldowns
+        return result
+
+    def tick(self, character) -> None:
+        """Reduce active cooldowns on a character by one tick."""
+        cooldowns = getattr(character, "cooldowns", {})
+        for key in list(cooldowns):
+            cooldowns[key] -= 1
+            if cooldowns[key] <= 0:
+                del cooldowns[key]
+        character.cooldowns = cooldowns
+
+
+skill_registry = SkillRegistry()
+
+
+def load_skills(path: Path) -> None:
+    skill_registry.load(path)

mud/spawning/__init__.py

@@ -0,0 +1 @@
+

mud/spawning/mob_spawner.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from typing import Optional
+
+from mud.registry import mob_registry
+from .templates import MobInstance
+
+
+def spawn_mob(vnum: int) -> Optional[MobInstance]:
+    proto = mob_registry.get(vnum)
+    if not proto:
+        return None
+    mob = MobInstance.from_prototype(proto)
+    return mob

mud/spawning/obj_spawner.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from typing import Optional
+
+from mud.registry import obj_registry
+from mud.models.object import Object
+
+
+def spawn_object(vnum: int) -> Optional[Object]:
+    proto = obj_registry.get(vnum)
+    if not proto:
+        return None
+    inst = Object(instance_id=None, prototype=proto)
+    # Copy prototype values for runtime mutation compatibility
+    try:
+        inst.value = list(getattr(proto, 'value', [0, 0, 0, 0, 0]))
+    except Exception:
+        inst.value = [0, 0, 0, 0, 0]
+    return inst

mud/spawning/reset_handler.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+import logging
+from typing import Dict, List, Optional
+
+from mud.models.area import Area
+from mud.models.constants import ITEM_INVENTORY
+from mud.registry import room_registry, area_registry
+from .mob_spawner import spawn_mob
+from .obj_spawner import spawn_object
+from .templates import MobInstance
+from mud.utils import rng_mm
+
+RESET_TICKS = 3
+
+
+def _compute_object_level(obj: object, mob: object) -> int:
+    """Approximate ROM object level computation for G/E resets.
+
+    Mirrors src/db.c case 'G'/'E' for shopkeepers and equips (simplified):
+    - WAND: 10..20
+    - STAFF: 15..25
+    - ARMOR: 5..15
+    - WEAPON: 5..15
+    - TREASURE: 10..20
+    - Default: 0
+    For new-format objects, or unrecognized types, return 0.
+    """
+    try:
+        item_type = int(getattr(getattr(obj, 'prototype', None), 'item_type', 0))
+    except Exception:
+        item_type = 0
+    from mud.models.constants import ItemType
+    if item_type == int(ItemType.WAND):
+        return rng_mm.number_range(10, 20)
+    if item_type == int(ItemType.STAFF):
+        return rng_mm.number_range(15, 25)
+    if item_type == int(ItemType.ARMOR):
+        return rng_mm.number_range(5, 15)
+    if item_type == int(ItemType.WEAPON):
+        return rng_mm.number_range(5, 15)
+    if item_type == int(ItemType.TREASURE):
+        return rng_mm.number_range(10, 20)
+    return 0
+
+
+def apply_resets(area: Area) -> None:
+    """Populate rooms based on simplified reset data."""
+    last_mob = None
+    last_obj: Optional[object] = None
+    # Track spawned objects per prototype vnum to support simple 'P' lookups
+    spawned_objects: Dict[int, List[object]] = {}
+    for reset in area.resets:
+        cmd = reset.command.upper()
+        if cmd == 'M':
+            mob_vnum = reset.arg2 or 0
+            room_vnum = reset.arg4 or 0
+            mob = spawn_mob(mob_vnum)
+            room = room_registry.get(room_vnum)
+            if mob and room:
+                room.add_mob(mob)
+                last_mob = mob
+                last_obj = None
+            else:
+                logging.warning('Invalid M reset %s -> %s', mob_vnum, room_vnum)
+        elif cmd == 'O':
+            obj_vnum = reset.arg2 or 0
+            room_vnum = reset.arg4 or 0
+            obj = spawn_object(obj_vnum)
+            room = room_registry.get(room_vnum)
+            if obj and room:
+                room.add_object(obj)
+                # Update last object instance and index by vnum
+                last_obj = obj
+                spawned_objects.setdefault(obj_vnum, []).append(obj)
+            else:
+                logging.warning('Invalid O reset %s -> %s', obj_vnum, room_vnum)
+        elif cmd == 'G':
+            obj_vnum = reset.arg2 or 0
+            limit = int(reset.arg3 or 1)
+            if not last_mob:
+                logging.warning('Invalid G reset %s (no LastMob)', obj_vnum)
+                continue
+            # Respect simple per-mob limit for this vnum
+            existing = [o for o in getattr(last_mob, 'inventory', [])
+                        if getattr(getattr(o, 'prototype', None), 'vnum', None) == obj_vnum]
+            if len(existing) >= limit:
+                continue
+            obj = spawn_object(obj_vnum)
+            if obj:
+                obj.level = _compute_object_level(obj, last_mob)
+                # Shopkeepers receive inventory copies
+                # Detect shopkeeper by registry since pShop not wired on prototype
+                try:
+                    from mud.registry import shop_registry
+                    is_shopkeeper = getattr(getattr(last_mob, 'prototype', None), 'vnum', None) in shop_registry
+                except Exception:
+                    is_shopkeeper = False
+                
+                if is_shopkeeper:
+                    if hasattr(obj.prototype, 'extra_flags'):
+                        from mud.models.constants import ExtraFlag
+                        if isinstance(obj.prototype.extra_flags, str):
+                            # Legacy .are format uses flag letters - convert to proper flags
+                            from mud.models.constants import convert_flags_from_letters
+                            current_flags = convert_flags_from_letters(obj.prototype.extra_flags, ExtraFlag)
+                            obj.prototype.extra_flags = current_flags | ITEM_INVENTORY
+                        else:
+                            obj.prototype.extra_flags |= ITEM_INVENTORY
+                last_mob.add_to_inventory(obj)
+                last_obj = obj
+                spawned_objects.setdefault(obj_vnum, []).append(obj)
+            else:
+                logging.warning('Invalid G reset %s', obj_vnum)
+        elif cmd == 'E':
+            obj_vnum = reset.arg2 or 0
+            limit = int(reset.arg3 or 1)
+            slot = reset.arg4 or 0
+            if not last_mob:
+                logging.warning('Invalid E reset %s (no LastMob)', obj_vnum)
+                continue
+            existing = [o for o in getattr(last_mob, 'inventory', [])
+                        if getattr(getattr(o, 'prototype', None), 'vnum', None) == obj_vnum]
+            if len(existing) >= limit:
+                continue
+            obj = spawn_object(obj_vnum)
+            if obj:
+                obj.level = _compute_object_level(obj, last_mob)
+                try:
+                    from mud.registry import shop_registry
+                    is_shopkeeper = getattr(getattr(last_mob, 'prototype', None), 'vnum', None) in shop_registry
+                except Exception:
+                    is_shopkeeper = False
+                if is_shopkeeper:
+                    if hasattr(obj.prototype, 'extra_flags'):
+                        from mud.models.constants import ExtraFlag
+                        if isinstance(obj.prototype.extra_flags, str):
+                            # Legacy .are format uses flag letters - convert to proper flags
+                            from mud.models.constants import convert_flags_from_letters
+                            current_flags = convert_flags_from_letters(obj.prototype.extra_flags, ExtraFlag)
+                            obj.prototype.extra_flags = current_flags | ITEM_INVENTORY
+                        else:
+                            obj.prototype.extra_flags |= ITEM_INVENTORY
+                last_mob.equip(obj, slot)
+                last_obj = obj
+                spawned_objects.setdefault(obj_vnum, []).append(obj)
+            else:
+                logging.warning('Invalid E reset %s', obj_vnum)
+        elif cmd == 'P':
+            obj_vnum = reset.arg2 or 0
+            container_vnum = reset.arg4 or 0
+            count = max(1, int(reset.arg3 or 1))  # how many to place
+            if container_vnum <= 0:
+                logging.warning('Invalid P reset %s -> %s', obj_vnum, container_vnum)
+                continue
+            # Prefer the last created object instance if it matches the container vnum
+            container_obj: Optional[object] = None
+            if last_obj and getattr(getattr(last_obj, 'prototype', None), 'vnum', None) == container_vnum:
+                container_obj = last_obj
+            # Otherwise, fall back to the most recent spawned container by vnum
+            if not container_obj:
+                lst = spawned_objects.get(container_vnum) or []
+                container_obj = lst[-1] if lst else None
+            if not container_obj:
+                logging.warning('Invalid P reset %s -> %s (no container instance)', obj_vnum, container_vnum)
+                continue
+            # Determine existing count inside
+            existing = [o for o in getattr(container_obj, 'contained_items', [])
+                        if getattr(getattr(o, 'prototype', None), 'vnum', None) == obj_vnum]
+            to_make = max(0, count - len(existing))
+            for _ in range(to_make):
+                obj = spawn_object(obj_vnum)
+                if not obj:
+                    break
+                getattr(container_obj, 'contained_items').append(obj)
+                spawned_objects.setdefault(obj_vnum, []).append(obj)
+            # After population, set last_obj to the container (mirrors ROM behavior)
+            # Lock-state fix: reset container instance's value[1] to prototype's value[1]
+            try:
+                container_obj.value[1] = container_obj.prototype.value[1]
+            except Exception:
+                pass
+            last_obj = container_obj
+        elif cmd == 'R':
+            room_vnum = reset.arg1 or 0
+            max_dirs = int(reset.arg2 or 0)
+            room = room_registry.get(room_vnum)
+            if not room or not room.exits:
+                logging.warning("Invalid R reset %s", room_vnum)
+                continue
+            n = min(max_dirs, len(room.exits))
+            # Fisher–Yates-like partial shuffle matching ROM loop
+            for d0 in range(0, max(0, n - 1)):
+                d1 = rng_mm.number_range(d0, n - 1)
+                room.exits[d0], room.exits[d1] = room.exits[d1], room.exits[d0]
+
+
+def reset_area(area: Area) -> None:
+    """Clear existing spawns and reapply resets for an area."""
+    for room in room_registry.values():
+        if room.area is area:
+            room.contents.clear()
+            room.people = [p for p in room.people if not isinstance(p, MobInstance)]
+    apply_resets(area)
+
+
+def reset_tick() -> None:
+    """Advance area ages and trigger resets when empty."""
+    for area in area_registry.values():
+        area.nplayer = sum(
+            1
+            for room in room_registry.values()
+            if room.area is area
+            for p in room.people
+            if not isinstance(p, MobInstance)
+        )
+        if area.nplayer > 0:
+            area.age = 0
+            continue
+        area.age += 1
+        if area.age >= RESET_TICKS:
+            reset_area(area)
+            area.age = 0

mud/spawning/templates.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from mud.models.object import Object
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mud.models.mob import MobIndex
+    from mud.models.obj import ObjIndex
+    from mud.models.object import Object
+
+
+@dataclass
+class ObjectInstance:
+    """Runtime instance of an object."""
+    name: Optional[str]
+    item_type: int
+    prototype: ObjIndex
+    short_descr: Optional[str] = None
+    location: Optional['Room'] = None
+    contained_items: List['ObjectInstance'] = field(default_factory=list)
+
+    def move_to_room(self, room: 'Room') -> None:
+        if self.location and hasattr(self.location, 'contents'):
+            if self in self.location.contents:
+                self.location.contents.remove(self)
+        room.contents.append(self)
+        self.location = room
+
+
+@dataclass
+class MobInstance:
+    """Runtime instance of a mob (NPC)."""
+    name: Optional[str]
+    level: int
+    current_hp: int
+    prototype: MobIndex
+    inventory: List[Object] = field(default_factory=list)
+    room: Optional['Room'] = None
+    # Minimal encumbrance fields to interoperate with move_character
+    carry_weight: int = 0
+    carry_number: int = 0
+
+    @classmethod
+    def from_prototype(cls, proto: MobIndex) -> 'MobInstance':
+        return cls(name=proto.short_descr or proto.player_name,
+                   level=proto.level,
+                   current_hp=proto.hit[1],
+                   prototype=proto)
+
+    def move_to_room(self, room: 'Room') -> None:
+        if self.room and self in self.room.people:
+            self.room.people.remove(self)
+        room.people.append(self)
+        self.room = room
+
+    def add_to_inventory(self, obj: Object) -> None:
+        self.inventory.append(obj)
+
+    def equip(self, obj: Object, slot: int) -> None:  # stub
+        self.add_to_inventory(obj)

mud/spec_funs.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+from typing import Any, Callable
+from mud.utils import rng_mm
+
+spec_fun_registry: dict[str, Callable[..., Any]] = {}
+
+def register_spec_fun(name: str, func: Callable[..., Any]) -> None:
+    """Register *func* under *name*, storing key in lowercase."""
+    spec_fun_registry[name.lower()] = func
+
+def get_spec_fun(name: str) -> Callable[..., Any] | None:
+    """Return a spec_fun for *name* using case-insensitive lookup."""
+    return spec_fun_registry.get(name.lower())
+
+
+def run_npc_specs() -> None:
+    """Invoke registered spec_funs for NPCs in all rooms.
+
+    For each NPC (MobInstance) present in any room, if its prototype has a
+    non-empty ``spec_fun`` name and a function is registered under that name,
+    call it with the mob instance.
+    """
+    from mud.registry import room_registry
+
+    for room in list(room_registry.values()):
+        for entity in list(getattr(room, "people", [])):
+            proto = getattr(entity, "prototype", None)
+            name = getattr(proto, "spec_fun", None)
+            if not name:
+                continue
+            func = get_spec_fun(name)
+            if func is None:
+                continue
+            try:
+                func(entity)
+            except Exception:
+                # Spec fun failures must not break the tick loop
+                continue
+
+
+# --- Minimal ROM-like spec functions (rng_mm parity) ---
+
+def spec_cast_adept(mob: Any) -> bool:
+    """Simplified Adept spec that uses ROM RNG.
+
+    ROM's `spec_cast_adept` periodically casts helpful spells on players.
+    For parity of RNG usage, we roll `number_percent()` and return True when
+    the roll is small. This function exists primarily to validate that the
+    Mitchell–Moore RNG wiring matches ROM semantics.
+    """
+    roll = rng_mm.number_percent()
+    # Return True on low roll to signal an action occurred (simplified).
+    return roll <= 25
+
+
+# Convenience registration name matching ROM conventions
+register_spec_fun("spec_cast_adept", spec_cast_adept)

mud/time.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import List
+
+
+class Sunlight(IntEnum):
+    DARK = 0
+    RISE = 1
+    LIGHT = 2
+    SET = 3
+
+
+@dataclass
+class TimeInfo:
+    hour: int = 0
+    day: int = 0
+    month: int = 0
+    year: int = 0
+    sunlight: Sunlight = Sunlight.DARK
+
+    def advance_hour(self) -> List[str]:
+        """Advance time by one hour and return broadcast messages."""
+        messages: List[str] = []
+        self.hour += 1
+        if self.hour >= 24:
+            self.hour = 0
+            self.day += 1
+            if self.day >= 35:
+                self.day = 0
+                self.month += 1
+                if self.month >= 17:
+                    self.month = 0
+                    self.year += 1
+        if self.hour == 5:
+            self.sunlight = Sunlight.LIGHT
+            messages.append("The sun rises in the east.")
+        elif self.hour == 19:
+            self.sunlight = Sunlight.SET
+            messages.append("The sun slowly disappears in the west.")
+        elif self.hour == 20:
+            self.sunlight = Sunlight.DARK
+            messages.append("The night has begun.")
+        return messages
+
+
+time_info = TimeInfo()

mud/utils/rng_mm.py

@@ -0,0 +1,123 @@
+"""Mitchell–Moore RNG for ROM parity.
+
+Implements ROM's RNG surface with C-style gating:
+- number_mm(): Mitchell–Moore generator (OLD_RAND branch in ROM) — returns a
+  non‑negative int with lower bits used by callers.
+- number_percent(): returns 1..100 inclusive using bitmask + while-gate.
+- number_range(a,b): ROM power-of-two mask with while-gate to avoid bias.
+- number_bits(width): lower ``width`` bits of ``number_mm()``.
+- dice(n,size): sum of ``number_range(1,size)`` repeated ``n`` times.
+
+References:
+- C src/db.c:number_mm/number_percent/number_range/number_bits/dice
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import time
+import os
+from typing import List
+
+
+MASK_30 = (1 << 30) - 1
+
+
+@dataclass
+class _MMState:
+    state: List[int]
+    i1: int
+    i2: int
+
+
+_mm: _MMState | None = None
+
+
+def _init_state(seed: int) -> _MMState:
+    # Mirrors ROM init_mm() when OLD_RAND is defined
+    state = [0] * 55
+    i1 = 55 - 55  # 0
+    i2 = 55 - 24  # 31
+    state[0] = seed & MASK_30
+    state[1] = 1
+    for i in range(2, 55):
+        state[i] = (state[i - 1] + state[i - 2]) & MASK_30
+    return _MMState(state=state, i1=i1, i2=i2)
+
+
+def _ensure_mm() -> _MMState:
+    global _mm
+    if _mm is None:
+        # Default seed: time ^ pid like ROM's srandom(time ^ getpid) branch
+        seed = int(time.time()) ^ os.getpid()
+        _mm = _init_state(seed)
+    return _mm
+
+
+def seed_mm(seed: int) -> None:
+    """Seed the Mitchell–Moore generator deterministically."""
+    global _mm
+    _mm = _init_state(int(seed))
+
+
+def number_mm() -> int:
+    """ROM Mitchell–Moore output with 6 LSBs discarded (>> 6 in callers).
+
+    We return the full value; public helpers mask/shift per ROM usage.
+    """
+    mm = _ensure_mm()
+    iRand = (mm.state[mm.i1] + mm.state[mm.i2]) & MASK_30
+    mm.state[mm.i1] = iRand
+    mm.i1 += 1
+    if mm.i1 == 55:
+        mm.i1 = 0
+    mm.i2 += 1
+    if mm.i2 == 55:
+        mm.i2 = 0
+    # Return with 6 LSBs discarded to mirror ROM behavior.
+    return iRand >> 6
+
+
+def number_percent() -> int:
+    """Return 1..100 inclusive using ROM's 7-bit mask + while-gate."""
+    # while ((percent = number_mm() & (128 - 1)) > 99);
+    # return 1 + percent;
+    percent = number_mm() & (128 - 1)
+    while percent > 99:
+        percent = number_mm() & (128 - 1)
+    return 1 + percent
+
+
+def number_range(a: int, b: int) -> int:
+    """Return integer in [a, b] inclusive using power-of-two mask + gate."""
+    if a == 0 and b == 0:
+        return 0
+    if a > b:
+        a, b = b, a
+    to = b - a + 1
+    if to <= 1:
+        return a
+    power = 2
+    while power < to:
+        power <<= 1
+    # while ((number = number_mm () & (power - 1)) >= to);
+    number = number_mm() & (power - 1)
+    while number >= to:
+        number = number_mm() & (power - 1)
+    return a + number
+
+
+def number_bits(width: int) -> int:
+    if width <= 0:
+        return 0
+    return number_mm() & ((1 << width) - 1)
+
+
+def dice(number: int, size: int) -> int:
+    if size == 0:
+        return 0
+    if size == 1:
+        return number
+    total = 0
+    for _ in range(number):
+        total += number_range(1, size)
+    return total