{"problem": "Write Python code to strip ANSI escape codes from Evennia terminal output for clean log processing. including error handling.", "solution": "# Generated variation 0\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0000"}
{"problem": "Implement a function that manage multiple user sessions in a thread-safe session manager. with full docstrings.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0001"}
{"problem": "Create a class which create a Tower floor dataclass that groups rooms by theme. and expose it as a command.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0002"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0003"}
{"problem": "Design a Tower component to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with type hints.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0004"}
{"problem": "How would you evennia event dict when a player joins the game, including account and character names. that persists to JSON.", "solution": "# Generated variation 5\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0005"}
{"problem": "In an Evennia MUD, how do you evennia command that records a new topic into the current room's Memory Palace index. with lock checks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0006"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player joins the game, including account and character names. that broadcasts to all occupants.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0007"}
{"problem": "Using Evennia's API, create a Tower floor dataclass that groups rooms by theme. supporting async callbacks.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0008"}
{"problem": "Construct a spatial-memory system that evennia command that lets players move between rooms by name instead of using exits. with logging.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0009"}
{"problem": "Write Python code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. including error handling.", "solution": "# Generated variation 10\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0010"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0011"}
{"problem": "Create a class which evennia NPC that answers questions by searching a memory palace index. and expose it as a command.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0012"}
{"problem": "Build an Evennia typeclass that nPC that wanders between connected rooms on a timed interval. using dataclasses.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0013"}
{"problem": "Design a Tower component to track a user session in a multi-user bridge with join time and active status. with type hints.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0014"}
{"problem": "How would you evennia NPC that answers questions by searching a memory palace index. that persists to JSON.", "solution": "# Generated variation 15\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0015"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0016"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0017"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0018"}
{"problem": "Construct a spatial-memory system that serialize a TowerMap to JSON for persistence or transmission. with logging.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0019"}
{"problem": "Write Python code to parse room output text from Evennia into structured data (description, exits, contents). including error handling.", "solution": "# Generated variation 20\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0020"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    item = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            item[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            item[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            item[\"exits\"].append(line)\n        elif section == \"contents\":\n            item[\"contents\"].append(line)\n    return item", "imports": "", "domain": "MUD world", "id": "evennia-tower-0021"}
{"problem": "Create a class which create a room that broadcasts a message to all occupants when a player enters or leaves. and expose it as a command.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0022"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0023"}
{"problem": "Design a Tower component to nPC with a mood state machine that affects its dialogue responses. with type hints.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0024"}
{"problem": "How would you parse room output text from Evennia into structured data (description, exits, contents). that persists to JSON.", "solution": "# Generated variation 25\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0025"}
{"problem": "In an Evennia MUD, how do you evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with lock checks.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0026"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0027"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0028"}
{"problem": "Construct a spatial-memory system that find all rooms on a specific floor of The Tower. with logging.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0029"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 30\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0030"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0031"}
{"problem": "Create a class which nPC with a mood state machine that affects its dialogue responses. and expose it as a command.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0032"}
{"problem": "Build an Evennia typeclass that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. using dataclasses.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0033"}
{"problem": "Design a Tower component to find all rooms on a specific floor of The Tower. with type hints.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0034"}
{"problem": "How would you create a room that broadcasts a message to all occupants when a player enters or leaves. that persists to JSON.", "solution": "# Generated variation 35\nclass BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0035"}
{"problem": "In an Evennia MUD, how do you find all rooms on a specific floor of The Tower. with lock checks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0036"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0037"}
{"problem": "Using Evennia's API, nPC with a mood state machine that affects its dialogue responses. supporting async callbacks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0038"}
{"problem": "Construct a spatial-memory system that serialize a TowerMap to JSON for persistence or transmission. with logging.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0039"}
{"problem": "Write Python code to create a Tower floor dataclass that groups rooms by theme. including error handling.", "solution": "# Generated variation 40\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0040"}
{"problem": "Implement a function that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with full docstrings.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0041"}
{"problem": "Create a class which evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. and expose it as a command.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    outputs = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            outputs.append({\"room\": room, \"score\": score, \"topic\": query})\n    outputs.sort(key=lambda x: x[\"score\"], reverse=True)\n    return outputs[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0042"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0043"}
{"problem": "Design a Tower component to find the shortest path between two Tower rooms by name using BFS. with type hints.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0044"}
{"problem": "How would you evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that persists to JSON.", "solution": "# Generated variation 45\nclass CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    items = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            items.append({\"room\": room, \"score\": score, \"topic\": query})\n    items.sort(key=lambda x: x[\"score\"], reverse=True)\n    return items[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0045"}
{"problem": "In an Evennia MUD, how do you find all rooms on a specific floor of The Tower. with lock checks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0046"}
{"problem": "For The Tower architecture, write code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that broadcasts to all occupants.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0047"}
{"problem": "Using Evennia's API, evennia event dict when a player joins the game, including account and character names. supporting async callbacks.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0048"}
{"problem": "Construct a spatial-memory system that manage multiple user sessions in a thread-safe session manager. with logging.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0049"}
{"problem": "Write Python code to nPC that wanders between connected rooms on a timed interval. including error handling.", "solution": "# Generated variation 50\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0050"}
{"problem": "Implement a function that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with full docstrings.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0051"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0052"}
{"problem": "Build an Evennia typeclass that create a room that broadcasts a message to all occupants when a player enters or leaves. using dataclasses.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0053"}
{"problem": "Design a Tower component to nPC that wanders between connected rooms on a timed interval. with type hints.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0054"}
{"problem": "How would you parse room output text from Evennia into structured data (description, exits, contents). that persists to JSON.", "solution": "# Generated variation 55\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0055"}
{"problem": "In an Evennia MUD, how do you manage multiple user sessions in a thread-safe session manager. with lock checks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0056"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player moves from one room to another. that broadcasts to all occupants.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0057"}
{"problem": "Using Evennia's API, evennia event dict when a player moves from one room to another. supporting async callbacks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0058"}
{"problem": "Construct a spatial-memory system that evennia NPC that answers questions by searching a memory palace index. with logging.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0059"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 60\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0060"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0061"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0062"}
{"problem": "Build an Evennia typeclass that parse room output text from Evennia into structured data (description, exits, contents). using dataclasses.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entity = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entity[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entity[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entity[\"exits\"].append(line)\n        elif section == \"contents\":\n            entity[\"contents\"].append(line)\n    return entity", "imports": "", "domain": "MUD world", "id": "evennia-tower-0063"}
{"problem": "Design a Tower component to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with type hints.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0064"}
{"problem": "How would you find the shortest path between two Tower rooms by name using BFS. that persists to JSON.", "solution": "# Generated variation 65\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0065"}
{"problem": "In an Evennia MUD, how do you find all rooms on a specific floor of The Tower. with lock checks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0066"}
{"problem": "For The Tower architecture, write code to evennia command that records a new topic into the current room's Memory Palace index. that broadcasts to all occupants.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0067"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0068"}
{"problem": "Construct a spatial-memory system that evennia command that lets players move between rooms by name instead of using exits. with logging.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0069"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 70\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0070"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0071"}
{"problem": "Create a class which manage multiple user sessions in a thread-safe session manager. and expose it as a command.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0072"}
{"problem": "Build an Evennia typeclass that evennia command that lets players move between rooms by name instead of using exits. using dataclasses.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0073"}
{"problem": "Design a Tower component to create a Tower floor dataclass that groups rooms by theme. with type hints.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0074"}
{"problem": "How would you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that persists to JSON.", "solution": "# Generated variation 75\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0075"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0076"}
{"problem": "For The Tower architecture, write code to create a room that broadcasts a message to all occupants when a player enters or leaves. that broadcasts to all occupants.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0077"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0078"}
{"problem": "Construct a spatial-memory system that parse room output text from Evennia into structured data (description, exits, contents). with logging.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0079"}
{"problem": "Write Python code to evennia NPC that answers questions by searching a memory palace index. including error handling.", "solution": "# Generated variation 80\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0080"}
{"problem": "Implement a function that manage multiple user sessions in a thread-safe session manager. with full docstrings.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0081"}
{"problem": "Create a class which evennia event dict when a player joins the game, including account and character names. and expose it as a command.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0082"}
{"problem": "Build an Evennia typeclass that evennia event dict when a player moves from one room to another. using dataclasses.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0083"}
{"problem": "Design a Tower component to parse room output text from Evennia into structured data (description, exits, contents). with type hints.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entry = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entry[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entry[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entry[\"exits\"].append(line)\n        elif section == \"contents\":\n            entry[\"contents\"].append(line)\n    return entry", "imports": "", "domain": "MUD world", "id": "evennia-tower-0084"}
{"problem": "How would you generate a command_executed event dict for tracking player actions in Evennia. that persists to JSON.", "solution": "# Generated variation 85\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0085"}
{"problem": "In an Evennia MUD, how do you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with lock checks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0086"}
{"problem": "For The Tower architecture, write code to track a user session in a multi-user bridge with join time and active status. that broadcasts to all occupants.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0087"}
{"problem": "Using Evennia's API, evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. supporting async callbacks.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0088"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0089"}
{"problem": "Write Python code to generate a command_executed event dict for tracking player actions in Evennia. including error handling.", "solution": "# Generated variation 90\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0090"}
{"problem": "Implement a function that evennia event dict when a player moves from one room to another. with full docstrings.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0091"}
{"problem": "Create a class which evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. and expose it as a command.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0092"}
{"problem": "Build an Evennia typeclass that manage multiple user sessions in a thread-safe session manager. using dataclasses.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0093"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0094"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 95\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0095"}
{"problem": "In an Evennia MUD, how do you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with lock checks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0096"}
{"problem": "For The Tower architecture, write code to serialize a TowerMap to JSON for persistence or transmission. that broadcasts to all occupants.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0097"}
{"problem": "Using Evennia's API, track a user session in a multi-user bridge with join time and active status. supporting async callbacks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0098"}
{"problem": "Construct a spatial-memory system that evennia command that records a new topic into the current room's Memory Palace index. with logging.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0099"}
{"problem": "Write Python code to evennia command that records a new topic into the current room's Memory Palace index. including error handling.", "solution": "# Generated variation 100\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0100"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0101"}
{"problem": "Create a class which strip ANSI escape codes from Evennia terminal output for clean log processing. and expose it as a command.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0102"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0103"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0104"}
{"problem": "How would you evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. that persists to JSON.", "solution": "# Generated variation 105\nclass DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0105"}
{"problem": "In an Evennia MUD, how do you manage multiple user sessions in a thread-safe session manager. with lock checks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0106"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player joins the game, including account and character names. that broadcasts to all occupants.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0107"}
{"problem": "Using Evennia's API, find the shortest path between two Tower rooms by name using BFS. supporting async callbacks.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0108"}
{"problem": "Construct a spatial-memory system that evennia command that lets players move between rooms by name instead of using exits. with logging.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0109"}
{"problem": "Write Python code to evennia event dict when a player joins the game, including account and character names. including error handling.", "solution": "# Generated variation 110\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0110"}
{"problem": "Implement a function that create a Tower floor dataclass that groups rooms by theme. with full docstrings.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0111"}
{"problem": "Create a class which evennia command that records a new topic into the current room's Memory Palace index. and expose it as a command.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0112"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0113"}
{"problem": "Design a Tower component to evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with type hints.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0114"}
{"problem": "How would you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. that persists to JSON.", "solution": "# Generated variation 115\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0115"}
{"problem": "In an Evennia MUD, how do you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with lock checks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0116"}
{"problem": "For The Tower architecture, write code to manage multiple user sessions in a thread-safe session manager. that broadcasts to all occupants.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0117"}
{"problem": "Using Evennia's API, evennia command that records a new topic into the current room's Memory Palace index. supporting async callbacks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0118"}
{"problem": "Construct a spatial-memory system that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with logging.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0119"}
{"problem": "Write Python code to serialize a TowerMap to JSON for persistence or transmission. including error handling.", "solution": "# Generated variation 120\ndef serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0120"}
{"problem": "Implement a function that evennia NPC that answers questions by searching a memory palace index. with full docstrings.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0121"}
{"problem": "Create a class which normalize an Evennia bridge event by ensuring all required fields exist with defaults. and expose it as a command.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0122"}
{"problem": "Build an Evennia typeclass that find the shortest path between two Tower rooms by name using BFS. using dataclasses.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0123"}
{"problem": "Design a Tower component to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with type hints.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0124"}
{"problem": "How would you find all rooms on a specific floor of The Tower. that persists to JSON.", "solution": "# Generated variation 125\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0125"}
{"problem": "In an Evennia MUD, how do you evennia command that lets players move between rooms by name instead of using exits. with lock checks.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0126"}
{"problem": "For The Tower architecture, write code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. that broadcasts to all occupants.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0127"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0128"}
{"problem": "Construct a spatial-memory system that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with logging.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0129"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 130\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0130"}
{"problem": "Implement a function that strip ANSI escape codes from Evennia terminal output for clean log processing. with full docstrings.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0131"}
{"problem": "Create a class which normalize an Evennia bridge event by ensuring all required fields exist with defaults. and expose it as a command.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0132"}
{"problem": "Build an Evennia typeclass that track a user session in a multi-user bridge with join time and active status. using dataclasses.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0133"}
{"problem": "Design a Tower component to serialize a TowerMap to JSON for persistence or transmission. with type hints.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0134"}
{"problem": "How would you track a user session in a multi-user bridge with join time and active status. that persists to JSON.", "solution": "# Generated variation 135\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0135"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0136"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player moves from one room to another. that broadcasts to all occupants.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0137"}
{"problem": "Using Evennia's API, build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. supporting async callbacks.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0138"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0139"}
{"problem": "Write Python code to find all rooms on a specific floor of The Tower. including error handling.", "solution": "# Generated variation 140\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0140"}
{"problem": "Implement a function that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with full docstrings.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0141"}
{"problem": "Create a class which evennia event dict when a player joins the game, including account and character names. and expose it as a command.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0142"}
{"problem": "Build an Evennia typeclass that parse room output text from Evennia into structured data (description, exits, contents). using dataclasses.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0143"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0144"}
{"problem": "How would you evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. that persists to JSON.", "solution": "# Generated variation 145\nclass DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0145"}
{"problem": "In an Evennia MUD, how do you evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with lock checks.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0146"}
{"problem": "For The Tower architecture, write code to nPC with a mood state machine that affects its dialogue responses. that broadcasts to all occupants.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0147"}
{"problem": "Using Evennia's API, evennia command that lets players move between rooms by name instead of using exits. supporting async callbacks.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0148"}
{"problem": "Construct a spatial-memory system that manage multiple user sessions in a thread-safe session manager. with logging.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0149"}
{"problem": "Write Python code to evennia command that lets players move between rooms by name instead of using exits. including error handling.", "solution": "# Generated variation 150\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0150"}
{"problem": "Implement a function that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with full docstrings.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0151"}
{"problem": "Create a class which create a Tower floor dataclass that groups rooms by theme. and expose it as a command.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0152"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0153"}
{"problem": "Design a Tower component to normalize an Evennia bridge event by ensuring all required fields exist with defaults. with type hints.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0154"}
{"problem": "How would you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that persists to JSON.", "solution": "# Generated variation 155\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0155"}
{"problem": "In an Evennia MUD, how do you find the shortest path between two Tower rooms by name using BFS. with lock checks.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0156"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0157"}
{"problem": "Using Evennia's API, evennia event dict when a player joins the game, including account and character names. supporting async callbacks.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0158"}
{"problem": "Construct a spatial-memory system that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with logging.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0159"}
{"problem": "Write Python code to find the shortest path between two Tower rooms by name using BFS. including error handling.", "solution": "# Generated variation 160\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0160"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0161"}
{"problem": "Create a class which evennia NPC that answers questions by searching a memory palace index. and expose it as a command.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0162"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0163"}
{"problem": "Design a Tower component to serialize a TowerMap to JSON for persistence or transmission. with type hints.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0164"}
{"problem": "How would you parse room output text from Evennia into structured data (description, exits, contents). that persists to JSON.", "solution": "# Generated variation 165\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    item = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            item[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            item[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            item[\"exits\"].append(line)\n        elif section == \"contents\":\n            item[\"contents\"].append(line)\n    return item", "imports": "", "domain": "MUD world", "id": "evennia-tower-0165"}
{"problem": "In an Evennia MUD, how do you track a user session in a multi-user bridge with join time and active status. with lock checks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0166"}
{"problem": "For The Tower architecture, write code to evennia command that lets players move between rooms by name instead of using exits. that broadcasts to all occupants.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0167"}
{"problem": "Using Evennia's API, track a user session in a multi-user bridge with join time and active status. supporting async callbacks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0168"}
{"problem": "Construct a spatial-memory system that generate a command_executed event dict for tracking player actions in Evennia. with logging.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0169"}
{"problem": "Write Python code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. including error handling.", "solution": "# Generated variation 170\nclass CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0170"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0171"}
{"problem": "Create a class which nPC with a mood state machine that affects its dialogue responses. and expose it as a command.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0172"}
{"problem": "Build an Evennia typeclass that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. using dataclasses.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0173"}
{"problem": "Design a Tower component to evennia command that lets players move between rooms by name instead of using exits. with type hints.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0174"}
{"problem": "How would you evennia event dict when a player joins the game, including account and character names. that persists to JSON.", "solution": "# Generated variation 175\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0175"}
{"problem": "In an Evennia MUD, how do you evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with lock checks.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0176"}
{"problem": "For The Tower architecture, write code to serialize a TowerMap to JSON for persistence or transmission. that broadcasts to all occupants.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0177"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0178"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0179"}
{"problem": "Write Python code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. including error handling.", "solution": "# Generated variation 180\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0180"}
{"problem": "Implement a function that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with full docstrings.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0181"}
{"problem": "Create a class which evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. and expose it as a command.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0182"}
{"problem": "Build an Evennia typeclass that parse room output text from Evennia into structured data (description, exits, contents). using dataclasses.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entity = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entity[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entity[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entity[\"exits\"].append(line)\n        elif section == \"contents\":\n            entity[\"contents\"].append(line)\n    return entity", "imports": "", "domain": "MUD world", "id": "evennia-tower-0183"}
{"problem": "Design a Tower component to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with type hints.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0184"}
{"problem": "How would you find all rooms on a specific floor of The Tower. that persists to JSON.", "solution": "# Generated variation 185\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0185"}
{"problem": "In an Evennia MUD, how do you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with lock checks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0186"}
{"problem": "For The Tower architecture, write code to evennia command that records a new topic into the current room's Memory Palace index. that broadcasts to all occupants.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0187"}
{"problem": "Using Evennia's API, nPC that wanders between connected rooms on a timed interval. supporting async callbacks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0188"}
{"problem": "Construct a spatial-memory system that evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with logging.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0189"}
{"problem": "Write Python code to evennia command that records a new topic into the current room's Memory Palace index. including error handling.", "solution": "# Generated variation 190\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0190"}
{"problem": "Implement a function that create a Tower floor dataclass that groups rooms by theme. with full docstrings.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0191"}
{"problem": "Create a class which evennia command that records a new topic into the current room's Memory Palace index. and expose it as a command.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0192"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0193"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0194"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 195\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0195"}
{"problem": "In an Evennia MUD, how do you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with lock checks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0196"}
{"problem": "For The Tower architecture, write code to generate a command_executed event dict for tracking player actions in Evennia. that broadcasts to all occupants.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0197"}
{"problem": "Using Evennia's API, track a user session in a multi-user bridge with join time and active status. supporting async callbacks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0198"}
{"problem": "Construct a spatial-memory system that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with logging.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0199"}
{"problem": "Write Python code to nPC with a mood state machine that affects its dialogue responses. including error handling.", "solution": "# Generated variation 200\nclass MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0200"}
{"problem": "Implement a function that track a user session in a multi-user bridge with join time and active status. with full docstrings.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0201"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0202"}
{"problem": "Build an Evennia typeclass that find the shortest path between two Tower rooms by name using BFS. using dataclasses.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0203"}
{"problem": "Design a Tower component to normalize an Evennia bridge event by ensuring all required fields exist with defaults. with type hints.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0204"}
{"problem": "How would you find the shortest path between two Tower rooms by name using BFS. that persists to JSON.", "solution": "# Generated variation 205\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0205"}
{"problem": "In an Evennia MUD, how do you nPC with a mood state machine that affects its dialogue responses. with lock checks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0206"}
{"problem": "For The Tower architecture, write code to track a user session in a multi-user bridge with join time and active status. that broadcasts to all occupants.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0207"}
{"problem": "Using Evennia's API, create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. supporting async callbacks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0208"}
{"problem": "Construct a spatial-memory system that create a Tower floor dataclass that groups rooms by theme. with logging.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0209"}
{"problem": "Write Python code to strip ANSI escape codes from Evennia terminal output for clean log processing. including error handling.", "solution": "# Generated variation 210\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0210"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0211"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0212"}
{"problem": "Build an Evennia typeclass that evennia command that lets players move between rooms by name instead of using exits. using dataclasses.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0213"}
{"problem": "Design a Tower component to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with type hints.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0214"}
{"problem": "How would you strip ANSI escape codes from Evennia terminal output for clean log processing. that persists to JSON.", "solution": "# Generated variation 215\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0215"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player moves from one room to another. with lock checks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0216"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0217"}
{"problem": "Using Evennia's API, generate a command_executed event dict for tracking player actions in Evennia. supporting async callbacks.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0218"}
{"problem": "Construct a spatial-memory system that evennia NPC that answers questions by searching a memory palace index. with logging.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0219"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 220\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0220"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0221"}
{"problem": "Create a class which manage multiple user sessions in a thread-safe session manager. and expose it as a command.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0222"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0223"}
{"problem": "Design a Tower component to track a user session in a multi-user bridge with join time and active status. with type hints.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0224"}
{"problem": "How would you find the shortest path between two Tower rooms by name using BFS. that persists to JSON.", "solution": "# Generated variation 225\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0225"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0226"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0227"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entry = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entry[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entry[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entry[\"exits\"].append(line)\n        elif section == \"contents\":\n            entry[\"contents\"].append(line)\n    return entry", "imports": "", "domain": "MUD world", "id": "evennia-tower-0228"}
{"problem": "Construct a spatial-memory system that parse room output text from Evennia into structured data (description, exits, contents). with logging.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0229"}
{"problem": "Write Python code to evennia command that lets players move between rooms by name instead of using exits. including error handling.", "solution": "# Generated variation 230\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0230"}
{"problem": "Implement a function that manage multiple user sessions in a thread-safe session manager. with full docstrings.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0231"}
{"problem": "Create a class which build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. and expose it as a command.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0232"}
{"problem": "Build an Evennia typeclass that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. using dataclasses.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0233"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0234"}
{"problem": "How would you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that persists to JSON.", "solution": "# Generated variation 235\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0235"}
{"problem": "In an Evennia MUD, how do you evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with lock checks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0236"}
{"problem": "For The Tower architecture, write code to parse room output text from Evennia into structured data (description, exits, contents). that broadcasts to all occupants.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    item = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            item[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            item[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            item[\"exits\"].append(line)\n        elif section == \"contents\":\n            item[\"contents\"].append(line)\n    return item", "imports": "", "domain": "MUD world", "id": "evennia-tower-0237"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0238"}
{"problem": "Construct a spatial-memory system that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with logging.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0239"}
{"problem": "Write Python code to serialize a TowerMap to JSON for persistence or transmission. including error handling.", "solution": "# Generated variation 240\ndef serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0240"}
{"problem": "Implement a function that strip ANSI escape codes from Evennia terminal output for clean log processing. with full docstrings.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0241"}
{"problem": "Create a class which evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. and expose it as a command.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0242"}
{"problem": "Build an Evennia typeclass that track a user session in a multi-user bridge with join time and active status. using dataclasses.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0243"}
{"problem": "Design a Tower component to create a Tower floor dataclass that groups rooms by theme. with type hints.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0244"}
{"problem": "How would you evennia event dict when a player moves from one room to another. that persists to JSON.", "solution": "# Generated variation 245\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0245"}
{"problem": "In an Evennia MUD, how do you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with lock checks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0246"}
{"problem": "For The Tower architecture, write code to create a room that broadcasts a message to all occupants when a player enters or leaves. that broadcasts to all occupants.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0247"}
{"problem": "Using Evennia's API, evennia NPC that answers questions by searching a memory palace index. supporting async callbacks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0248"}
{"problem": "Construct a spatial-memory system that evennia NPC that answers questions by searching a memory palace index. with logging.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0249"}
{"problem": "Write Python code to nPC that wanders between connected rooms on a timed interval. including error handling.", "solution": "# Generated variation 250\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0250"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0251"}
{"problem": "Create a class which create a Tower floor dataclass that groups rooms by theme. and expose it as a command.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0252"}
{"problem": "Build an Evennia typeclass that find the shortest path between two Tower rooms by name using BFS. using dataclasses.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0253"}
{"problem": "Design a Tower component to track a user session in a multi-user bridge with join time and active status. with type hints.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0254"}
{"problem": "How would you strip ANSI escape codes from Evennia terminal output for clean log processing. that persists to JSON.", "solution": "# Generated variation 255\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0255"}
{"problem": "In an Evennia MUD, how do you find the shortest path between two Tower rooms by name using BFS. with lock checks.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0256"}
{"problem": "For The Tower architecture, write code to nPC that wanders between connected rooms on a timed interval. that broadcasts to all occupants.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0257"}
{"problem": "Using Evennia's API, evennia command that records a new topic into the current room's Memory Palace index. supporting async callbacks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0258"}
{"problem": "Construct a spatial-memory system that evennia event dict when a player moves from one room to another. with logging.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0259"}
{"problem": "Write Python code to evennia command that lets players move between rooms by name instead of using exits. including error handling.", "solution": "# Generated variation 260\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0260"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0261"}
{"problem": "Create a class which find the shortest path between two Tower rooms by name using BFS. and expose it as a command.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0262"}
{"problem": "Build an Evennia typeclass that create a Tower floor dataclass that groups rooms by theme. using dataclasses.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0263"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0264"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 265\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0265"}
{"problem": "In an Evennia MUD, how do you evennia command that records a new topic into the current room's Memory Palace index. with lock checks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0266"}
{"problem": "For The Tower architecture, write code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0267"}
{"problem": "Using Evennia's API, build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. supporting async callbacks.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0268"}
{"problem": "Construct a spatial-memory system that generate a command_executed event dict for tracking player actions in Evennia. with logging.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0269"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 270\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0270"}
{"problem": "Implement a function that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with full docstrings.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0271"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0272"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0273"}
{"problem": "Design a Tower component to strip ANSI escape codes from Evennia terminal output for clean log processing. with type hints.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0274"}
{"problem": "How would you evennia command that lets players move between rooms by name instead of using exits. that persists to JSON.", "solution": "# Generated variation 275\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0275"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0276"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0277"}
{"problem": "Using Evennia's API, normalize an Evennia bridge event by ensuring all required fields exist with defaults. supporting async callbacks.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0278"}
{"problem": "Construct a spatial-memory system that nPC with a mood state machine that affects its dialogue responses. with logging.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0279"}
{"problem": "Write Python code to find all rooms on a specific floor of The Tower. including error handling.", "solution": "# Generated variation 280\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0280"}
{"problem": "Implement a function that nPC that wanders between connected rooms on a timed interval. with full docstrings.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0281"}
{"problem": "Create a class which evennia NPC that answers questions by searching a memory palace index. and expose it as a command.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0282"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0283"}
{"problem": "Design a Tower component to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with type hints.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0284"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 285\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0285"}
{"problem": "In an Evennia MUD, how do you evennia command that lets players move between rooms by name instead of using exits. with lock checks.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0286"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0287"}
{"problem": "Using Evennia's API, generate a command_executed event dict for tracking player actions in Evennia. supporting async callbacks.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0288"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0289"}
{"problem": "Write Python code to create a room that broadcasts a message to all occupants when a player enters or leaves. including error handling.", "solution": "# Generated variation 290\nclass BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0290"}
{"problem": "Implement a function that find the shortest path between two Tower rooms by name using BFS. with full docstrings.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0291"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0292"}
{"problem": "Build an Evennia typeclass that track a user session in a multi-user bridge with join time and active status. using dataclasses.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0293"}
{"problem": "Design a Tower component to find the shortest path between two Tower rooms by name using BFS. with type hints.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0294"}
{"problem": "How would you track a user session in a multi-user bridge with join time and active status. that persists to JSON.", "solution": "# Generated variation 295\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0295"}
{"problem": "In an Evennia MUD, how do you nPC that wanders between connected rooms on a timed interval. with lock checks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0296"}
{"problem": "For The Tower architecture, write code to evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. that broadcasts to all occupants.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0297"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0298"}
{"problem": "Construct a spatial-memory system that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with logging.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0299"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 300\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0300"}
{"problem": "Implement a function that evennia event dict when a player moves from one room to another. with full docstrings.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0301"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0302"}
{"problem": "Build an Evennia typeclass that nPC that wanders between connected rooms on a timed interval. using dataclasses.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0303"}
{"problem": "Design a Tower component to evennia command that lets players move between rooms by name instead of using exits. with type hints.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0304"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 305\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0305"}
{"problem": "In an Evennia MUD, how do you create a room that broadcasts a message to all occupants when a player enters or leaves. with lock checks.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0306"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0307"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0308"}
{"problem": "Construct a spatial-memory system that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with logging.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0309"}
{"problem": "Write Python code to generate a command_executed event dict for tracking player actions in Evennia. including error handling.", "solution": "# Generated variation 310\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0310"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0311"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0312"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0313"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0314"}
{"problem": "How would you manage multiple user sessions in a thread-safe session manager. that persists to JSON.", "solution": "# Generated variation 315\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0315"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0316"}
{"problem": "For The Tower architecture, write code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. that broadcasts to all occupants.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0317"}
{"problem": "Using Evennia's API, build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. supporting async callbacks.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0318"}
{"problem": "Construct a spatial-memory system that track a user session in a multi-user bridge with join time and active status. with logging.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0319"}
{"problem": "Write Python code to evennia command that lets players move between rooms by name instead of using exits. including error handling.", "solution": "# Generated variation 320\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0320"}
{"problem": "Implement a function that create a Tower floor dataclass that groups rooms by theme. with full docstrings.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0321"}
{"problem": "Create a class which define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. and expose it as a command.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0322"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0323"}
{"problem": "Design a Tower component to nPC that wanders between connected rooms on a timed interval. with type hints.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0324"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 325\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0325"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player joins the game, including account and character names. with lock checks.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0326"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0327"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0328"}
{"problem": "Construct a spatial-memory system that evennia command that lets players move between rooms by name instead of using exits. with logging.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0329"}
{"problem": "Write Python code to find the shortest path between two Tower rooms by name using BFS. including error handling.", "solution": "# Generated variation 330\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0330"}
{"problem": "Implement a function that find the shortest path between two Tower rooms by name using BFS. with full docstrings.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0331"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0332"}
{"problem": "Build an Evennia typeclass that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. using dataclasses.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0333"}
{"problem": "Design a Tower component to serialize a TowerMap to JSON for persistence or transmission. with type hints.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0334"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 335\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0335"}
{"problem": "In an Evennia MUD, how do you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with lock checks.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0336"}
{"problem": "For The Tower architecture, write code to evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. that broadcasts to all occupants.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0337"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0338"}
{"problem": "Construct a spatial-memory system that evennia NPC that answers questions by searching a memory palace index. with logging.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0339"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 340\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0340"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0341"}
{"problem": "Create a class which evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. and expose it as a command.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    nodes = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            nodes.append({\"room\": room, \"score\": score, \"topic\": query})\n    nodes.sort(key=lambda x: x[\"score\"], reverse=True)\n    return nodes[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0342"}
{"problem": "Build an Evennia typeclass that create a Tower floor dataclass that groups rooms by theme. using dataclasses.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0343"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0344"}
{"problem": "How would you evennia NPC that answers questions by searching a memory palace index. that persists to JSON.", "solution": "# Generated variation 345\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0345"}
{"problem": "In an Evennia MUD, how do you evennia command that records a new topic into the current room's Memory Palace index. with lock checks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0346"}
{"problem": "For The Tower architecture, write code to find all rooms on a specific floor of The Tower. that broadcasts to all occupants.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0347"}
{"problem": "Using Evennia's API, evennia command that records a new topic into the current room's Memory Palace index. supporting async callbacks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0348"}
{"problem": "Construct a spatial-memory system that evennia command that lets players move between rooms by name instead of using exits. with logging.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0349"}
{"problem": "Write Python code to find the shortest path between two Tower rooms by name using BFS. including error handling.", "solution": "# Generated variation 350\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0350"}
{"problem": "Implement a function that evennia NPC that answers questions by searching a memory palace index. with full docstrings.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0351"}
{"problem": "Create a class which create a room that broadcasts a message to all occupants when a player enters or leaves. and expose it as a command.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0352"}
{"problem": "Build an Evennia typeclass that manage multiple user sessions in a thread-safe session manager. using dataclasses.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0353"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0354"}
{"problem": "How would you manage multiple user sessions in a thread-safe session manager. that persists to JSON.", "solution": "# Generated variation 355\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0355"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0356"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0357"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0358"}
{"problem": "Construct a spatial-memory system that find the shortest path between two Tower rooms by name using BFS. with logging.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0359"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 360\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0360"}
{"problem": "Implement a function that find the shortest path between two Tower rooms by name using BFS. with full docstrings.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0361"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0362"}
{"problem": "Build an Evennia typeclass that find the shortest path between two Tower rooms by name using BFS. using dataclasses.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0363"}
{"problem": "Design a Tower component to nPC with a mood state machine that affects its dialogue responses. with type hints.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0364"}
{"problem": "How would you evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. that persists to JSON.", "solution": "# Generated variation 365\nclass MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0365"}
{"problem": "In an Evennia MUD, how do you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with lock checks.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0366"}
{"problem": "For The Tower architecture, write code to evennia NPC that answers questions by searching a memory palace index. that broadcasts to all occupants.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0367"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0368"}
{"problem": "Construct a spatial-memory system that evennia event dict when a player joins the game, including account and character names. with logging.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0369"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 370\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0370"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0371"}
{"problem": "Create a class which generate a command_executed event dict for tracking player actions in Evennia. and expose it as a command.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0372"}
{"problem": "Build an Evennia typeclass that parse room output text from Evennia into structured data (description, exits, contents). using dataclasses.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0373"}
{"problem": "Design a Tower component to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with type hints.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0374"}
{"problem": "How would you nPC that wanders between connected rooms on a timed interval. that persists to JSON.", "solution": "# Generated variation 375\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0375"}
{"problem": "In an Evennia MUD, how do you parse room output text from Evennia into structured data (description, exits, contents). with lock checks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0376"}
{"problem": "For The Tower architecture, write code to generate a command_executed event dict for tracking player actions in Evennia. that broadcasts to all occupants.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0377"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0378"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0379"}
{"problem": "Write Python code to evennia event dict when a player joins the game, including account and character names. including error handling.", "solution": "# Generated variation 380\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0380"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    item = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            item[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            item[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            item[\"exits\"].append(line)\n        elif section == \"contents\":\n            item[\"contents\"].append(line)\n    return item", "imports": "", "domain": "MUD world", "id": "evennia-tower-0381"}
{"problem": "Create a class which nPC with a mood state machine that affects its dialogue responses. and expose it as a command.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0382"}
{"problem": "Build an Evennia typeclass that evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. using dataclasses.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0383"}
{"problem": "Design a Tower component to evennia event dict when a player moves from one room to another. with type hints.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0384"}
{"problem": "How would you track a user session in a multi-user bridge with join time and active status. that persists to JSON.", "solution": "# Generated variation 385\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0385"}
{"problem": "In an Evennia MUD, how do you create a Tower floor dataclass that groups rooms by theme. with lock checks.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0386"}
{"problem": "For The Tower architecture, write code to create a room that broadcasts a message to all occupants when a player enters or leaves. that broadcasts to all occupants.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0387"}
{"problem": "Using Evennia's API, track a user session in a multi-user bridge with join time and active status. supporting async callbacks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0388"}
{"problem": "Construct a spatial-memory system that find the shortest path between two Tower rooms by name using BFS. with logging.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0389"}
{"problem": "Write Python code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. including error handling.", "solution": "# Generated variation 390\nclass CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    nodes = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            nodes.append({\"room\": room, \"score\": score, \"topic\": query})\n    nodes.sort(key=lambda x: x[\"score\"], reverse=True)\n    return nodes[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0390"}
{"problem": "Implement a function that find the shortest path between two Tower rooms by name using BFS. with full docstrings.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0391"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0392"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0393"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0394"}
{"problem": "How would you create a room that broadcasts a message to all occupants when a player enters or leaves. that persists to JSON.", "solution": "# Generated variation 395\nclass BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0395"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player moves from one room to another. with lock checks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0396"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player joins the game, including account and character names. that broadcasts to all occupants.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0397"}
{"problem": "Using Evennia's API, evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. supporting async callbacks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0398"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0399"}
{"problem": "Write Python code to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. including error handling.", "solution": "# Generated variation 400\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0400"}
{"problem": "Implement a function that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with full docstrings.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0401"}
{"problem": "Create a class which nPC that wanders between connected rooms on a timed interval. and expose it as a command.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0402"}
{"problem": "Build an Evennia typeclass that nPC with a mood state machine that affects its dialogue responses. using dataclasses.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0403"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0404"}
{"problem": "How would you evennia command that lets players move between rooms by name instead of using exits. that persists to JSON.", "solution": "# Generated variation 405\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0405"}
{"problem": "In an Evennia MUD, how do you track a user session in a multi-user bridge with join time and active status. with lock checks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0406"}
{"problem": "For The Tower architecture, write code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that broadcasts to all occupants.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0407"}
{"problem": "Using Evennia's API, find all rooms on a specific floor of The Tower. supporting async callbacks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0408"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0409"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 410\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0410"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    record = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            record[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            record[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            record[\"exits\"].append(line)\n        elif section == \"contents\":\n            record[\"contents\"].append(line)\n    return record", "imports": "", "domain": "MUD world", "id": "evennia-tower-0411"}
{"problem": "Create a class which parse a raw Evennia log line into a structured event dict, extracting timestamp and message. and expose it as a command.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0412"}
{"problem": "Build an Evennia typeclass that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. using dataclasses.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0413"}
{"problem": "Design a Tower component to evennia event dict when a player moves from one room to another. with type hints.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0414"}
{"problem": "How would you create a room that broadcasts a message to all occupants when a player enters or leaves. that persists to JSON.", "solution": "# Generated variation 415\nclass BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0415"}
{"problem": "In an Evennia MUD, how do you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with lock checks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0416"}
{"problem": "For The Tower architecture, write code to evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. that broadcasts to all occupants.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0417"}
{"problem": "Using Evennia's API, evennia NPC that answers questions by searching a memory palace index. supporting async callbacks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0418"}
{"problem": "Construct a spatial-memory system that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with logging.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0419"}
{"problem": "Write Python code to evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. including error handling.", "solution": "# Generated variation 420\nclass MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0420"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0421"}
{"problem": "Create a class which normalize an Evennia bridge event by ensuring all required fields exist with defaults. and expose it as a command.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0422"}
{"problem": "Build an Evennia typeclass that find the shortest path between two Tower rooms by name using BFS. using dataclasses.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0423"}
{"problem": "Design a Tower component to find all rooms on a specific floor of The Tower. with type hints.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0424"}
{"problem": "How would you create a room that broadcasts a message to all occupants when a player enters or leaves. that persists to JSON.", "solution": "# Generated variation 425\nclass BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0425"}
{"problem": "In an Evennia MUD, how do you create a room that broadcasts a message to all occupants when a player enters or leaves. with lock checks.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0426"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0427"}
{"problem": "Using Evennia's API, manage multiple user sessions in a thread-safe session manager. supporting async callbacks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0428"}
{"problem": "Construct a spatial-memory system that create a Tower floor dataclass that groups rooms by theme. with logging.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0429"}
{"problem": "Write Python code to parse room output text from Evennia into structured data (description, exits, contents). including error handling.", "solution": "# Generated variation 430\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0430"}
{"problem": "Implement a function that create a room that broadcasts a message to all occupants when a player enters or leaves. with full docstrings.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0431"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0432"}
{"problem": "Build an Evennia typeclass that evennia event dict when a player joins the game, including account and character names. using dataclasses.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0433"}
{"problem": "Design a Tower component to create a Tower floor dataclass that groups rooms by theme. with type hints.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0434"}
{"problem": "How would you strip ANSI escape codes from Evennia terminal output for clean log processing. that persists to JSON.", "solution": "# Generated variation 435\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0435"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0436"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0437"}
{"problem": "Using Evennia's API, evennia event dict when a player moves from one room to another. supporting async callbacks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0438"}
{"problem": "Construct a spatial-memory system that evennia event dict when a player joins the game, including account and character names. with logging.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0439"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 440\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0440"}
{"problem": "Implement a function that create a Tower floor dataclass that groups rooms by theme. with full docstrings.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0441"}
{"problem": "Create a class which build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. and expose it as a command.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0442"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0443"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0444"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 445\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0445"}
{"problem": "In an Evennia MUD, how do you find all rooms on a specific floor of The Tower. with lock checks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0446"}
{"problem": "For The Tower architecture, write code to create a room that broadcasts a message to all occupants when a player enters or leaves. that broadcasts to all occupants.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0447"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0448"}
{"problem": "Construct a spatial-memory system that find the shortest path between two Tower rooms by name using BFS. with logging.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0449"}
{"problem": "Write Python code to find the shortest path between two Tower rooms by name using BFS. including error handling.", "solution": "# Generated variation 450\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0450"}
{"problem": "Implement a function that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with full docstrings.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0451"}
{"problem": "Create a class which create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. and expose it as a command.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0452"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0453"}
{"problem": "Design a Tower component to evennia event dict when a player moves from one room to another. with type hints.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0454"}
{"problem": "How would you serialize a TowerMap to JSON for persistence or transmission. that persists to JSON.", "solution": "# Generated variation 455\ndef serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0455"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0456"}
{"problem": "For The Tower architecture, write code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that broadcasts to all occupants.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0457"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0458"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0459"}
{"problem": "Write Python code to create a Tower floor dataclass that groups rooms by theme. including error handling.", "solution": "# Generated variation 460\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0460"}
{"problem": "Implement a function that generate a command_executed event dict for tracking player actions in Evennia. with full docstrings.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0461"}
{"problem": "Create a class which create a Tower floor dataclass that groups rooms by theme. and expose it as a command.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0462"}
{"problem": "Build an Evennia typeclass that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. using dataclasses.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0463"}
{"problem": "Design a Tower component to find the shortest path between two Tower rooms by name using BFS. with type hints.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0464"}
{"problem": "How would you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. that persists to JSON.", "solution": "# Generated variation 465\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0465"}
{"problem": "In an Evennia MUD, how do you create a room that broadcasts a message to all occupants when a player enters or leaves. with lock checks.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0466"}
{"problem": "For The Tower architecture, write code to manage multiple user sessions in a thread-safe session manager. that broadcasts to all occupants.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0467"}
{"problem": "Using Evennia's API, evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. supporting async callbacks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0468"}
{"problem": "Construct a spatial-memory system that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with logging.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0469"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 470\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0470"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0471"}
{"problem": "Create a class which nPC that wanders between connected rooms on a timed interval. and expose it as a command.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0472"}
{"problem": "Build an Evennia typeclass that nPC that wanders between connected rooms on a timed interval. using dataclasses.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0473"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0474"}
{"problem": "How would you generate a command_executed event dict for tracking player actions in Evennia. that persists to JSON.", "solution": "# Generated variation 475\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0475"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0476"}
{"problem": "For The Tower architecture, write code to serialize a TowerMap to JSON for persistence or transmission. that broadcasts to all occupants.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0477"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0478"}
{"problem": "Construct a spatial-memory system that create a Tower floor dataclass that groups rooms by theme. with logging.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0479"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 480\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0480"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0481"}
{"problem": "Create a class which create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. and expose it as a command.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0482"}
{"problem": "Build an Evennia typeclass that find the shortest path between two Tower rooms by name using BFS. using dataclasses.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0483"}
{"problem": "Design a Tower component to create a room that broadcasts a message to all occupants when a player enters or leaves. with type hints.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0484"}
{"problem": "How would you serialize a TowerMap to JSON for persistence or transmission. that persists to JSON.", "solution": "# Generated variation 485\ndef serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0485"}
{"problem": "In an Evennia MUD, how do you track a user session in a multi-user bridge with join time and active status. with lock checks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0486"}
{"problem": "For The Tower architecture, write code to track a user session in a multi-user bridge with join time and active status. that broadcasts to all occupants.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0487"}
{"problem": "Using Evennia's API, find all rooms on a specific floor of The Tower. supporting async callbacks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0488"}
{"problem": "Construct a spatial-memory system that track a user session in a multi-user bridge with join time and active status. with logging.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0489"}
{"problem": "Write Python code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. including error handling.", "solution": "# Generated variation 490\nclass CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0490"}
{"problem": "Implement a function that track a user session in a multi-user bridge with join time and active status. with full docstrings.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0491"}
{"problem": "Create a class which track a user session in a multi-user bridge with join time and active status. and expose it as a command.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0492"}
{"problem": "Build an Evennia typeclass that serialize a TowerMap to JSON for persistence or transmission. using dataclasses.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0493"}
{"problem": "Design a Tower component to evennia NPC that answers questions by searching a memory palace index. with type hints.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0494"}
{"problem": "How would you manage multiple user sessions in a thread-safe session manager. that persists to JSON.", "solution": "# Generated variation 495\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0495"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0496"}
{"problem": "For The Tower architecture, write code to generate a command_executed event dict for tracking player actions in Evennia. that broadcasts to all occupants.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0497"}
{"problem": "Using Evennia's API, evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. supporting async callbacks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    outputs = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            outputs.append({\"room\": room, \"score\": score, \"topic\": query})\n    outputs.sort(key=lambda x: x[\"score\"], reverse=True)\n    return outputs[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0498"}
{"problem": "Construct a spatial-memory system that nPC that wanders between connected rooms on a timed interval. with logging.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0499"}
{"problem": "Write Python code to evennia NPC that answers questions by searching a memory palace index. including error handling.", "solution": "# Generated variation 500\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0500"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0501"}
{"problem": "Create a class which evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. and expose it as a command.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0502"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0503"}
{"problem": "Design a Tower component to find the shortest path between two Tower rooms by name using BFS. with type hints.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0504"}
{"problem": "How would you parse room output text from Evennia into structured data (description, exits, contents). that persists to JSON.", "solution": "# Generated variation 505\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0505"}
{"problem": "In an Evennia MUD, how do you manage multiple user sessions in a thread-safe session manager. with lock checks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0506"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0507"}
{"problem": "Using Evennia's API, manage multiple user sessions in a thread-safe session manager. supporting async callbacks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0508"}
{"problem": "Construct a spatial-memory system that find the shortest path between two Tower rooms by name using BFS. with logging.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0509"}
{"problem": "Write Python code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. including error handling.", "solution": "# Generated variation 510\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0510"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0511"}
{"problem": "Create a class which evennia event dict when a player joins the game, including account and character names. and expose it as a command.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0512"}
{"problem": "Build an Evennia typeclass that nPC that wanders between connected rooms on a timed interval. using dataclasses.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0513"}
{"problem": "Design a Tower component to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with type hints.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0514"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 515\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0515"}
{"problem": "In an Evennia MUD, how do you generate a command_executed event dict for tracking player actions in Evennia. with lock checks.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0516"}
{"problem": "For The Tower architecture, write code to evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. that broadcasts to all occupants.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0517"}
{"problem": "Using Evennia's API, manage multiple user sessions in a thread-safe session manager. supporting async callbacks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0518"}
{"problem": "Construct a spatial-memory system that manage multiple user sessions in a thread-safe session manager. with logging.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0519"}
{"problem": "Write Python code to generate a command_executed event dict for tracking player actions in Evennia. including error handling.", "solution": "# Generated variation 520\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0520"}
{"problem": "Implement a function that evennia command that records a new topic into the current room's Memory Palace index. with full docstrings.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0521"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0522"}
{"problem": "Build an Evennia typeclass that serialize a TowerMap to JSON for persistence or transmission. using dataclasses.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0523"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0524"}
{"problem": "How would you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that persists to JSON.", "solution": "# Generated variation 525\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0525"}
{"problem": "In an Evennia MUD, how do you evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with lock checks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0526"}
{"problem": "For The Tower architecture, write code to generate a command_executed event dict for tracking player actions in Evennia. that broadcasts to all occupants.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0527"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0528"}
{"problem": "Construct a spatial-memory system that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with logging.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0529"}
{"problem": "Write Python code to nPC that wanders between connected rooms on a timed interval. including error handling.", "solution": "# Generated variation 530\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0530"}
{"problem": "Implement a function that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with full docstrings.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    records = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            records.append({\"room\": room, \"score\": score, \"topic\": query})\n    records.sort(key=lambda x: x[\"score\"], reverse=True)\n    return records[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0531"}
{"problem": "Create a class which generate a command_executed event dict for tracking player actions in Evennia. and expose it as a command.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0532"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0533"}
{"problem": "Design a Tower component to manage multiple user sessions in a thread-safe session manager. with type hints.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0534"}
{"problem": "How would you strip ANSI escape codes from Evennia terminal output for clean log processing. that persists to JSON.", "solution": "# Generated variation 535\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0535"}
{"problem": "In an Evennia MUD, how do you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with lock checks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0536"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0537"}
{"problem": "Using Evennia's API, evennia command that lets players move between rooms by name instead of using exits. supporting async callbacks.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0538"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0539"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 540\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0540"}
{"problem": "Implement a function that nPC with a mood state machine that affects its dialogue responses. with full docstrings.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0541"}
{"problem": "Create a class which evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. and expose it as a command.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0542"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0543"}
{"problem": "Design a Tower component to find all rooms on a specific floor of The Tower. with type hints.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0544"}
{"problem": "How would you track a user session in a multi-user bridge with join time and active status. that persists to JSON.", "solution": "# Generated variation 545\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0545"}
{"problem": "In an Evennia MUD, how do you manage multiple user sessions in a thread-safe session manager. with lock checks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0546"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0547"}
{"problem": "Using Evennia's API, create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. supporting async callbacks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0548"}
{"problem": "Construct a spatial-memory system that create a room that broadcasts a message to all occupants when a player enters or leaves. with logging.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0549"}
{"problem": "Write Python code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. including error handling.", "solution": "# Generated variation 550\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0550"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0551"}
{"problem": "Create a class which strip ANSI escape codes from Evennia terminal output for clean log processing. and expose it as a command.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0552"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0553"}
{"problem": "Design a Tower component to evennia command that lets players move between rooms by name instead of using exits. with type hints.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0554"}
{"problem": "How would you evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. that persists to JSON.", "solution": "# Generated variation 555\nclass MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0555"}
{"problem": "In an Evennia MUD, how do you find the shortest path between two Tower rooms by name using BFS. with lock checks.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0556"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player joins the game, including account and character names. that broadcasts to all occupants.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0557"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0558"}
{"problem": "Construct a spatial-memory system that find all rooms on a specific floor of The Tower. with logging.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0559"}
{"problem": "Write Python code to evennia command that lets players move between rooms by name instead of using exits. including error handling.", "solution": "# Generated variation 560\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0560"}
{"problem": "Implement a function that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with full docstrings.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0561"}
{"problem": "Create a class which evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. and expose it as a command.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0562"}
{"problem": "Build an Evennia typeclass that serialize a TowerMap to JSON for persistence or transmission. using dataclasses.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0563"}
{"problem": "Design a Tower component to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with type hints.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    entrys = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            entrys.append({\"room\": room, \"score\": score, \"topic\": query})\n    entrys.sort(key=lambda x: x[\"score\"], reverse=True)\n    return entrys[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0564"}
{"problem": "How would you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that persists to JSON.", "solution": "# Generated variation 565\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0565"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0566"}
{"problem": "For The Tower architecture, write code to evennia NPC that answers questions by searching a memory palace index. that broadcasts to all occupants.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0567"}
{"problem": "Using Evennia's API, create a Tower floor dataclass that groups rooms by theme. supporting async callbacks.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0568"}
{"problem": "Construct a spatial-memory system that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with logging.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0569"}
{"problem": "Write Python code to evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. including error handling.", "solution": "# Generated variation 570\nclass MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0570"}
{"problem": "Implement a function that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with full docstrings.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0571"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0572"}
{"problem": "Build an Evennia typeclass that serialize a TowerMap to JSON for persistence or transmission. using dataclasses.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0573"}
{"problem": "Design a Tower component to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with type hints.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0574"}
{"problem": "How would you evennia command that lets players move between rooms by name instead of using exits. that persists to JSON.", "solution": "# Generated variation 575\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0575"}
{"problem": "In an Evennia MUD, how do you evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with lock checks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0576"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0577"}
{"problem": "Using Evennia's API, track a user session in a multi-user bridge with join time and active status. supporting async callbacks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0578"}
{"problem": "Construct a spatial-memory system that create a Tower floor dataclass that groups rooms by theme. with logging.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0579"}
{"problem": "Write Python code to strip ANSI escape codes from Evennia terminal output for clean log processing. including error handling.", "solution": "# Generated variation 580\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0580"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0581"}
{"problem": "Create a class which evennia NPC that answers questions by searching a memory palace index. and expose it as a command.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0582"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0583"}
{"problem": "Design a Tower component to normalize an Evennia bridge event by ensuring all required fields exist with defaults. with type hints.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0584"}
{"problem": "How would you evennia NPC that answers questions by searching a memory palace index. that persists to JSON.", "solution": "# Generated variation 585\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0585"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0586"}
{"problem": "For The Tower architecture, write code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0587"}
{"problem": "Using Evennia's API, nPC with a mood state machine that affects its dialogue responses. supporting async callbacks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0588"}
{"problem": "Construct a spatial-memory system that find the shortest path between two Tower rooms by name using BFS. with logging.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0589"}
{"problem": "Write Python code to manage multiple user sessions in a thread-safe session manager. including error handling.", "solution": "# Generated variation 590\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0590"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0591"}
{"problem": "Create a class which evennia event dict when a player joins the game, including account and character names. and expose it as a command.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0592"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0593"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0594"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 595\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0595"}
{"problem": "In an Evennia MUD, how do you create a Tower floor dataclass that groups rooms by theme. with lock checks.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0596"}
{"problem": "For The Tower architecture, write code to serialize a TowerMap to JSON for persistence or transmission. that broadcasts to all occupants.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0597"}
{"problem": "Using Evennia's API, track a user session in a multi-user bridge with join time and active status. supporting async callbacks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0598"}
{"problem": "Construct a spatial-memory system that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with logging.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0599"}
{"problem": "Write Python code to serialize a TowerMap to JSON for persistence or transmission. including error handling.", "solution": "# Generated variation 600\ndef serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0600"}
{"problem": "Implement a function that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with full docstrings.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0601"}
{"problem": "Create a class which generate a command_executed event dict for tracking player actions in Evennia. and expose it as a command.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0602"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0603"}
{"problem": "Design a Tower component to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with type hints.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0604"}
{"problem": "How would you normalize an Evennia bridge event by ensuring all required fields exist with defaults. that persists to JSON.", "solution": "# Generated variation 605\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0605"}
{"problem": "In an Evennia MUD, how do you manage multiple user sessions in a thread-safe session manager. with lock checks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0606"}
{"problem": "For The Tower architecture, write code to parse room output text from Evennia into structured data (description, exits, contents). that broadcasts to all occupants.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0607"}
{"problem": "Using Evennia's API, nPC that wanders between connected rooms on a timed interval. supporting async callbacks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0608"}
{"problem": "Construct a spatial-memory system that nPC with a mood state machine that affects its dialogue responses. with logging.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0609"}
{"problem": "Write Python code to generate a command_executed event dict for tracking player actions in Evennia. including error handling.", "solution": "# Generated variation 610\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0610"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0611"}
{"problem": "Create a class which find the shortest path between two Tower rooms by name using BFS. and expose it as a command.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0612"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0613"}
{"problem": "Design a Tower component to track a user session in a multi-user bridge with join time and active status. with type hints.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0614"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 615\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0615"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player joins the game, including account and character names. with lock checks.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0616"}
{"problem": "For The Tower architecture, write code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. that broadcasts to all occupants.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0617"}
{"problem": "Using Evennia's API, evennia NPC that answers questions by searching a memory palace index. supporting async callbacks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0618"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0619"}
{"problem": "Write Python code to generate a command_executed event dict for tracking player actions in Evennia. including error handling.", "solution": "# Generated variation 620\ndef command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0620"}
{"problem": "Implement a function that evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with full docstrings.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0621"}
{"problem": "Create a class which generate a command_executed event dict for tracking player actions in Evennia. and expose it as a command.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0622"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0623"}
{"problem": "Design a Tower component to strip ANSI escape codes from Evennia terminal output for clean log processing. with type hints.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0624"}
{"problem": "How would you evennia event dict when a player joins the game, including account and character names. that persists to JSON.", "solution": "# Generated variation 625\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0625"}
{"problem": "In an Evennia MUD, how do you nPC that wanders between connected rooms on a timed interval. with lock checks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0626"}
{"problem": "For The Tower architecture, write code to nPC that wanders between connected rooms on a timed interval. that broadcasts to all occupants.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0627"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0628"}
{"problem": "Construct a spatial-memory system that manage multiple user sessions in a thread-safe session manager. with logging.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0629"}
{"problem": "Write Python code to find the shortest path between two Tower rooms by name using BFS. including error handling.", "solution": "# Generated variation 630\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0630"}
{"problem": "Implement a function that serialize a TowerMap to JSON for persistence or transmission. with full docstrings.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0631"}
{"problem": "Create a class which manage multiple user sessions in a thread-safe session manager. and expose it as a command.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0632"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0633"}
{"problem": "Design a Tower component to parse room output text from Evennia into structured data (description, exits, contents). with type hints.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0634"}
{"problem": "How would you parse room output text from Evennia into structured data (description, exits, contents). that persists to JSON.", "solution": "# Generated variation 635\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0635"}
{"problem": "In an Evennia MUD, how do you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with lock checks.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0636"}
{"problem": "For The Tower architecture, write code to create a room that broadcasts a message to all occupants when a player enters or leaves. that broadcasts to all occupants.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0637"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0638"}
{"problem": "Construct a spatial-memory system that parse room output text from Evennia into structured data (description, exits, contents). with logging.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entity = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entity[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entity[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entity[\"exits\"].append(line)\n        elif section == \"contents\":\n            entity[\"contents\"].append(line)\n    return entity", "imports": "", "domain": "MUD world", "id": "evennia-tower-0639"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 640\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0640"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0641"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0642"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0643"}
{"problem": "Design a Tower component to strip ANSI escape codes from Evennia terminal output for clean log processing. with type hints.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0644"}
{"problem": "How would you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. that persists to JSON.", "solution": "# Generated variation 645\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0645"}
{"problem": "In an Evennia MUD, how do you nPC with a mood state machine that affects its dialogue responses. with lock checks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0646"}
{"problem": "For The Tower architecture, write code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0647"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0648"}
{"problem": "Construct a spatial-memory system that manage multiple user sessions in a thread-safe session manager. with logging.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0649"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 650\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0650"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    record = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            record[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            record[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            record[\"exits\"].append(line)\n        elif section == \"contents\":\n            record[\"contents\"].append(line)\n    return record", "imports": "", "domain": "MUD world", "id": "evennia-tower-0651"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0652"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0653"}
{"problem": "Design a Tower component to evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with type hints.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0654"}
{"problem": "How would you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that persists to JSON.", "solution": "# Generated variation 655\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0655"}
{"problem": "In an Evennia MUD, how do you normalize an Evennia bridge event by ensuring all required fields exist with defaults. with lock checks.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0656"}
{"problem": "For The Tower architecture, write code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that broadcasts to all occupants.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0657"}
{"problem": "Using Evennia's API, evennia command that lets players move between rooms by name instead of using exits. supporting async callbacks.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0658"}
{"problem": "Construct a spatial-memory system that generate a command_executed event dict for tracking player actions in Evennia. with logging.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0659"}
{"problem": "Write Python code to evennia event dict when a player joins the game, including account and character names. including error handling.", "solution": "# Generated variation 660\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0660"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0661"}
{"problem": "Create a class which build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. and expose it as a command.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0662"}
{"problem": "Build an Evennia typeclass that evennia command that lets players move between rooms by name instead of using exits. using dataclasses.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0663"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0664"}
{"problem": "How would you find the shortest path between two Tower rooms by name using BFS. that persists to JSON.", "solution": "# Generated variation 665\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0665"}
{"problem": "In an Evennia MUD, how do you find the shortest path between two Tower rooms by name using BFS. with lock checks.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0666"}
{"problem": "For The Tower architecture, write code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that broadcasts to all occupants.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0667"}
{"problem": "Using Evennia's API, manage multiple user sessions in a thread-safe session manager. supporting async callbacks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0668"}
{"problem": "Construct a spatial-memory system that strip ANSI escape codes from Evennia terminal output for clean log processing. with logging.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0669"}
{"problem": "Write Python code to manage multiple user sessions in a thread-safe session manager. including error handling.", "solution": "# Generated variation 670\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0670"}
{"problem": "Implement a function that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with full docstrings.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0671"}
{"problem": "Create a class which evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. and expose it as a command.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0672"}
{"problem": "Build an Evennia typeclass that evennia event dict when a player moves from one room to another. using dataclasses.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0673"}
{"problem": "Design a Tower component to create a Tower floor dataclass that groups rooms by theme. with type hints.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0674"}
{"problem": "How would you normalize an Evennia bridge event by ensuring all required fields exist with defaults. that persists to JSON.", "solution": "# Generated variation 675\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0675"}
{"problem": "In an Evennia MUD, how do you nPC with a mood state machine that affects its dialogue responses. with lock checks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0676"}
{"problem": "For The Tower architecture, write code to evennia event dict when a player joins the game, including account and character names. that broadcasts to all occupants.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0677"}
{"problem": "Using Evennia's API, create a room that broadcasts a message to all occupants when a player enters or leaves. supporting async callbacks.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0678"}
{"problem": "Construct a spatial-memory system that create a Tower floor dataclass that groups rooms by theme. with logging.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0679"}
{"problem": "Write Python code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. including error handling.", "solution": "# Generated variation 680\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0680"}
{"problem": "Implement a function that track a user session in a multi-user bridge with join time and active status. with full docstrings.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0681"}
{"problem": "Create a class which evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. and expose it as a command.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0682"}
{"problem": "Build an Evennia typeclass that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. using dataclasses.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0683"}
{"problem": "Design a Tower component to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with type hints.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    entrys = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            entrys.append({\"room\": room, \"score\": score, \"topic\": query})\n    entrys.sort(key=lambda x: x[\"score\"], reverse=True)\n    return entrys[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0684"}
{"problem": "How would you manage multiple user sessions in a thread-safe session manager. that persists to JSON.", "solution": "# Generated variation 685\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0685"}
{"problem": "In an Evennia MUD, how do you parse room output text from Evennia into structured data (description, exits, contents). with lock checks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0686"}
{"problem": "For The Tower architecture, write code to evennia NPC that answers questions by searching a memory palace index. that broadcasts to all occupants.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0687"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0688"}
{"problem": "Construct a spatial-memory system that find all rooms on a specific floor of The Tower. with logging.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0689"}
{"problem": "Write Python code to strip ANSI escape codes from Evennia terminal output for clean log processing. including error handling.", "solution": "# Generated variation 690\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0690"}
{"problem": "Implement a function that create a Tower floor dataclass that groups rooms by theme. with full docstrings.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0691"}
{"problem": "Create a class which strip ANSI escape codes from Evennia terminal output for clean log processing. and expose it as a command.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0692"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0693"}
{"problem": "Design a Tower component to find all rooms on a specific floor of The Tower. with type hints.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0694"}
{"problem": "How would you evennia command that lets players move between rooms by name instead of using exits. that persists to JSON.", "solution": "# Generated variation 695\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0695"}
{"problem": "In an Evennia MUD, how do you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with lock checks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0696"}
{"problem": "For The Tower architecture, write code to track a user session in a multi-user bridge with join time and active status. that broadcasts to all occupants.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0697"}
{"problem": "Using Evennia's API, parse a raw Evennia log line into a structured event dict, extracting timestamp and message. supporting async callbacks.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0698"}
{"problem": "Construct a spatial-memory system that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with logging.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0699"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 700\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0700"}
{"problem": "Implement a function that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with full docstrings.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0701"}
{"problem": "Create a class which evennia NPC that answers questions by searching a memory palace index. and expose it as a command.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0702"}
{"problem": "Build an Evennia typeclass that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. using dataclasses.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0703"}
{"problem": "Design a Tower component to nPC with a mood state machine that affects its dialogue responses. with type hints.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0704"}
{"problem": "How would you manage multiple user sessions in a thread-safe session manager. that persists to JSON.", "solution": "# Generated variation 705\nclass SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0705"}
{"problem": "In an Evennia MUD, how do you evennia command that lets players move between rooms by name instead of using exits. with lock checks.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0706"}
{"problem": "For The Tower architecture, write code to find all rooms on a specific floor of The Tower. that broadcasts to all occupants.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0707"}
{"problem": "Using Evennia's API, manage multiple user sessions in a thread-safe session manager. supporting async callbacks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0708"}
{"problem": "Construct a spatial-memory system that evennia command that records a new topic into the current room's Memory Palace index. with logging.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0709"}
{"problem": "Write Python code to serialize a TowerMap to JSON for persistence or transmission. including error handling.", "solution": "# Generated variation 710\ndef serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0710"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0711"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0712"}
{"problem": "Build an Evennia typeclass that track a user session in a multi-user bridge with join time and active status. using dataclasses.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0713"}
{"problem": "Design a Tower component to manage multiple user sessions in a thread-safe session manager. with type hints.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0714"}
{"problem": "How would you evennia command that lets players move between rooms by name instead of using exits. that persists to JSON.", "solution": "# Generated variation 715\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0715"}
{"problem": "In an Evennia MUD, how do you serialize a TowerMap to JSON for persistence or transmission. with lock checks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0716"}
{"problem": "For The Tower architecture, write code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that broadcasts to all occupants.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    items = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            items.append({\"room\": room, \"score\": score, \"topic\": query})\n    items.sort(key=lambda x: x[\"score\"], reverse=True)\n    return items[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0717"}
{"problem": "Using Evennia's API, create a Tower floor dataclass that groups rooms by theme. supporting async callbacks.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0718"}
{"problem": "Construct a spatial-memory system that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with logging.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0719"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 720\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0720"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0721"}
{"problem": "Create a class which create a Tower floor dataclass that groups rooms by theme. and expose it as a command.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0722"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0723"}
{"problem": "Design a Tower component to normalize an Evennia bridge event by ensuring all required fields exist with defaults. with type hints.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0724"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 725\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0725"}
{"problem": "In an Evennia MUD, how do you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with lock checks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0726"}
{"problem": "For The Tower architecture, write code to parse room output text from Evennia into structured data (description, exits, contents). that broadcasts to all occupants.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0727"}
{"problem": "Using Evennia's API, evennia command that records a new topic into the current room's Memory Palace index. supporting async callbacks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0728"}
{"problem": "Construct a spatial-memory system that evennia command that records a new topic into the current room's Memory Palace index. with logging.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0729"}
{"problem": "Write Python code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. including error handling.", "solution": "# Generated variation 730\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0730"}
{"problem": "Implement a function that find the shortest path between two Tower rooms by name using BFS. with full docstrings.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0731"}
{"problem": "Create a class which generate a command_executed event dict for tracking player actions in Evennia. and expose it as a command.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0732"}
{"problem": "Build an Evennia typeclass that manage multiple user sessions in a thread-safe session manager. using dataclasses.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0733"}
{"problem": "Design a Tower component to track a user session in a multi-user bridge with join time and active status. with type hints.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0734"}
{"problem": "How would you evennia event dict when a player joins the game, including account and character names. that persists to JSON.", "solution": "# Generated variation 735\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0735"}
{"problem": "In an Evennia MUD, how do you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with lock checks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0736"}
{"problem": "For The Tower architecture, write code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that broadcasts to all occupants.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0737"}
{"problem": "Using Evennia's API, nPC that wanders between connected rooms on a timed interval. supporting async callbacks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0738"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0739"}
{"problem": "Write Python code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. including error handling.", "solution": "# Generated variation 740\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0740"}
{"problem": "Implement a function that evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with full docstrings.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0741"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0742"}
{"problem": "Build an Evennia typeclass that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. using dataclasses.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0743"}
{"problem": "Design a Tower component to parse room output text from Evennia into structured data (description, exits, contents). with type hints.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    data = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            data[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            data[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            data[\"exits\"].append(line)\n        elif section == \"contents\":\n            data[\"contents\"].append(line)\n    return data", "imports": "", "domain": "MUD world", "id": "evennia-tower-0744"}
{"problem": "How would you evennia event dict when a player moves from one room to another. that persists to JSON.", "solution": "# Generated variation 745\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0745"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player moves from one room to another. with lock checks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0746"}
{"problem": "For The Tower architecture, write code to find all rooms on a specific floor of The Tower. that broadcasts to all occupants.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0747"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0748"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0749"}
{"problem": "Write Python code to evennia event dict when a player joins the game, including account and character names. including error handling.", "solution": "# Generated variation 750\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0750"}
{"problem": "Implement a function that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with full docstrings.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0751"}
{"problem": "Create a class which evennia command that lets players move between rooms by name instead of using exits. and expose it as a command.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0752"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0753"}
{"problem": "Design a Tower component to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with type hints.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0754"}
{"problem": "How would you parse room output text from Evennia into structured data (description, exits, contents). that persists to JSON.", "solution": "# Generated variation 755\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0755"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player joins the game, including account and character names. with lock checks.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0756"}
{"problem": "For The Tower architecture, write code to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0757"}
{"problem": "Using Evennia's API, nPC that wanders between connected rooms on a timed interval. supporting async callbacks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0758"}
{"problem": "Construct a spatial-memory system that generate a command_executed event dict for tracking player actions in Evennia. with logging.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0759"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 760\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0760"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0761"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0762"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0763"}
{"problem": "Design a Tower component to serialize a TowerMap to JSON for persistence or transmission. with type hints.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0764"}
{"problem": "How would you evennia command that records a new topic into the current room's Memory Palace index. that persists to JSON.", "solution": "# Generated variation 765\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0765"}
{"problem": "In an Evennia MUD, how do you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with lock checks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0766"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0767"}
{"problem": "Using Evennia's API, evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. supporting async callbacks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0768"}
{"problem": "Construct a spatial-memory system that find all rooms on a specific floor of The Tower. with logging.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0769"}
{"problem": "Write Python code to find all rooms on a specific floor of The Tower. including error handling.", "solution": "# Generated variation 770\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0770"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0771"}
{"problem": "Create a class which parse room output text from Evennia into structured data (description, exits, contents). and expose it as a command.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0772"}
{"problem": "Build an Evennia typeclass that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. using dataclasses.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0773"}
{"problem": "Design a Tower component to parse room output text from Evennia into structured data (description, exits, contents). with type hints.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    node = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            node[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            node[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            node[\"exits\"].append(line)\n        elif section == \"contents\":\n            node[\"contents\"].append(line)\n    return node", "imports": "", "domain": "MUD world", "id": "evennia-tower-0774"}
{"problem": "How would you find all rooms on a specific floor of The Tower. that persists to JSON.", "solution": "# Generated variation 775\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0775"}
{"problem": "In an Evennia MUD, how do you find all rooms on a specific floor of The Tower. with lock checks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0776"}
{"problem": "For The Tower architecture, write code to create a Tower floor dataclass that groups rooms by theme. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0777"}
{"problem": "Using Evennia's API, evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. supporting async callbacks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0778"}
{"problem": "Construct a spatial-memory system that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with logging.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0779"}
{"problem": "Write Python code to track a user session in a multi-user bridge with join time and active status. including error handling.", "solution": "# Generated variation 780\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0780"}
{"problem": "Implement a function that evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with full docstrings.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0781"}
{"problem": "Create a class which create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. and expose it as a command.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0782"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0783"}
{"problem": "Design a Tower component to serialize a TowerMap to JSON for persistence or transmission. with type hints.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0784"}
{"problem": "How would you find the shortest path between two Tower rooms by name using BFS. that persists to JSON.", "solution": "# Generated variation 785\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0785"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player joins the game, including account and character names. with lock checks.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0786"}
{"problem": "For The Tower architecture, write code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. that broadcasts to all occupants.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0787"}
{"problem": "Using Evennia's API, normalize an Evennia bridge event by ensuring all required fields exist with defaults. supporting async callbacks.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0788"}
{"problem": "Construct a spatial-memory system that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with logging.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0789"}
{"problem": "Write Python code to evennia NPC that answers questions by searching a memory palace index. including error handling.", "solution": "# Generated variation 790\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0790"}
{"problem": "Implement a function that parse room output text from Evennia into structured data (description, exits, contents). with full docstrings.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0791"}
{"problem": "Create a class which strip ANSI escape codes from Evennia terminal output for clean log processing. and expose it as a command.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0792"}
{"problem": "Build an Evennia typeclass that nPC with a mood state machine that affects its dialogue responses. using dataclasses.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0793"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0794"}
{"problem": "How would you find the shortest path between two Tower rooms by name using BFS. that persists to JSON.", "solution": "# Generated variation 795\nfrom collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0795"}
{"problem": "In an Evennia MUD, how do you create a room that broadcasts a message to all occupants when a player enters or leaves. with lock checks.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0796"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0797"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    node = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            node[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            node[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            node[\"exits\"].append(line)\n        elif section == \"contents\":\n            node[\"contents\"].append(line)\n    return node", "imports": "", "domain": "MUD world", "id": "evennia-tower-0798"}
{"problem": "Construct a spatial-memory system that find the shortest path between two Tower rooms by name using BFS. with logging.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0799"}
{"problem": "Write Python code to find all rooms on a specific floor of The Tower. including error handling.", "solution": "# Generated variation 800\ndef rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0800"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0801"}
{"problem": "Create a class which nPC that wanders between connected rooms on a timed interval. and expose it as a command.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0802"}
{"problem": "Build an Evennia typeclass that normalize an Evennia bridge event by ensuring all required fields exist with defaults. using dataclasses.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0803"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0804"}
{"problem": "How would you evennia event dict when a player moves from one room to another. that persists to JSON.", "solution": "# Generated variation 805\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0805"}
{"problem": "In an Evennia MUD, how do you evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with lock checks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0806"}
{"problem": "For The Tower architecture, write code to nPC that wanders between connected rooms on a timed interval. that broadcasts to all occupants.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0807"}
{"problem": "Using Evennia's API, evennia event dict when a player moves from one room to another. supporting async callbacks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0808"}
{"problem": "Construct a spatial-memory system that generate a command_executed event dict for tracking player actions in Evennia. with logging.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0809"}
{"problem": "Write Python code to nPC that wanders between connected rooms on a timed interval. including error handling.", "solution": "# Generated variation 810\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0810"}
{"problem": "Implement a function that evennia command that lets players move between rooms by name instead of using exits. with full docstrings.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0811"}
{"problem": "Create a class which create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. and expose it as a command.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0812"}
{"problem": "Build an Evennia typeclass that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. using dataclasses.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0813"}
{"problem": "Design a Tower component to find the shortest path between two Tower rooms by name using BFS. with type hints.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0814"}
{"problem": "How would you normalize an Evennia bridge event by ensuring all required fields exist with defaults. that persists to JSON.", "solution": "# Generated variation 815\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0815"}
{"problem": "In an Evennia MUD, how do you evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with lock checks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    datas = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            datas.append({\"room\": room, \"score\": score, \"topic\": query})\n    datas.sort(key=lambda x: x[\"score\"], reverse=True)\n    return datas[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0816"}
{"problem": "For The Tower architecture, write code to parse room output text from Evennia into structured data (description, exits, contents). that broadcasts to all occupants.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0817"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0818"}
{"problem": "Construct a spatial-memory system that serialize a TowerMap to JSON for persistence or transmission. with logging.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0819"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 820\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0820"}
{"problem": "Implement a function that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with full docstrings.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0821"}
{"problem": "Create a class which find the shortest path between two Tower rooms by name using BFS. and expose it as a command.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0822"}
{"problem": "Build an Evennia typeclass that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. using dataclasses.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0823"}
{"problem": "Design a Tower component to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with type hints.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0824"}
{"problem": "How would you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that persists to JSON.", "solution": "# Generated variation 825\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0825"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player moves from one room to another. with lock checks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0826"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0827"}
{"problem": "Using Evennia's API, evennia event dict when a player moves from one room to another. supporting async callbacks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0828"}
{"problem": "Construct a spatial-memory system that parse room output text from Evennia into structured data (description, exits, contents). with logging.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0829"}
{"problem": "Write Python code to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. including error handling.", "solution": "# Generated variation 830\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0830"}
{"problem": "Implement a function that create a room that broadcasts a message to all occupants when a player enters or leaves. with full docstrings.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0831"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0832"}
{"problem": "Build an Evennia typeclass that create a Tower floor dataclass that groups rooms by theme. using dataclasses.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0833"}
{"problem": "Design a Tower component to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with type hints.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0834"}
{"problem": "How would you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. that persists to JSON.", "solution": "# Generated variation 835\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0835"}
{"problem": "In an Evennia MUD, how do you evennia command that records a new topic into the current room's Memory Palace index. with lock checks.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0836"}
{"problem": "For The Tower architecture, write code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that broadcasts to all occupants.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    items = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            items.append({\"room\": room, \"score\": score, \"topic\": query})\n    items.sort(key=lambda x: x[\"score\"], reverse=True)\n    return items[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0837"}
{"problem": "Using Evennia's API, nPC that wanders between connected rooms on a timed interval. supporting async callbacks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0838"}
{"problem": "Construct a spatial-memory system that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with logging.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0839"}
{"problem": "Write Python code to nPC that wanders between connected rooms on a timed interval. including error handling.", "solution": "# Generated variation 840\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0840"}
{"problem": "Implement a function that evennia event dict when a player moves from one room to another. with full docstrings.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0841"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0842"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0843"}
{"problem": "Design a Tower component to evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with type hints.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0844"}
{"problem": "How would you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. that persists to JSON.", "solution": "# Generated variation 845\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0845"}
{"problem": "In an Evennia MUD, how do you evennia NPC that answers questions by searching a memory palace index. with lock checks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0846"}
{"problem": "For The Tower architecture, write code to find all rooms on a specific floor of The Tower. that broadcasts to all occupants.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0847"}
{"problem": "Using Evennia's API, evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. supporting async callbacks.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0848"}
{"problem": "Construct a spatial-memory system that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with logging.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0849"}
{"problem": "Write Python code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. including error handling.", "solution": "# Generated variation 850\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0850"}
{"problem": "Implement a function that evennia room that tracks dynamic state (light level, temperature) and updates its description based on that state. with full docstrings.", "solution": "class DynamicRoom(DefaultRoom):\n    \"\"\"A room whose description changes with environmental state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.light_level = 100  # 0-100\n        self.db.temperature = 20   # celsius\n        self.db.base_desc = \"A plain chamber.\"\n\n    def return_appearance(self, looker, **kwargs):\n        desc = self.db.base_desc\n        light = self.db.light_level\n        if light < 20:\n            desc += \" It is nearly pitch black.\"\n        elif light < 50:\n            desc += \" Shadows dance in the dim light.\"\n        else:\n            desc += \" The room is well lit.\"\n        temp = self.db.temperature\n        if temp > 30:\n            desc += \" Heat shimmers in the air.\"\n        elif temp < 10:\n            desc += \" Frost coats the walls.\"\n        return desc + \"\n\" + super().return_appearance(looker, **kwargs).split(\"\n\", 1)[-1]", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0851"}
{"problem": "Create a class which serialize a TowerMap to JSON for persistence or transmission. and expose it as a command.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0852"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0853"}
{"problem": "Design a Tower component to evennia command that lets players move between rooms by name instead of using exits. with type hints.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0854"}
{"problem": "How would you create a room that broadcasts a message to all occupants when a player enters or leaves. that persists to JSON.", "solution": "# Generated variation 855\nclass BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0855"}
{"problem": "In an Evennia MUD, how do you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with lock checks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0856"}
{"problem": "For The Tower architecture, write code to track a user session in a multi-user bridge with join time and active status. that broadcasts to all occupants.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0857"}
{"problem": "Using Evennia's API, generate a command_executed event dict for tracking player actions in Evennia. supporting async callbacks.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0858"}
{"problem": "Construct a spatial-memory system that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with logging.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0859"}
{"problem": "Write Python code to evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. including error handling.", "solution": "# Generated variation 860\nclass MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0860"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0861"}
{"problem": "Create a class which evennia command that records a new topic into the current room's Memory Palace index. and expose it as a command.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0862"}
{"problem": "Build an Evennia typeclass that find all rooms on a specific floor of The Tower. using dataclasses.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0863"}
{"problem": "Design a Tower component to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with type hints.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0864"}
{"problem": "How would you evennia event dict when a player moves from one room to another. that persists to JSON.", "solution": "# Generated variation 865\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0865"}
{"problem": "In an Evennia MUD, how do you find all rooms on a specific floor of The Tower. with lock checks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0866"}
{"problem": "For The Tower architecture, write code to find all rooms on a specific floor of The Tower. that broadcasts to all occupants.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0867"}
{"problem": "Using Evennia's API, evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. supporting async callbacks.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0868"}
{"problem": "Construct a spatial-memory system that evennia command that records a new topic into the current room's Memory Palace index. with logging.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0869"}
{"problem": "Write Python code to nPC with a mood state machine that affects its dialogue responses. including error handling.", "solution": "# Generated variation 870\nclass MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0870"}
{"problem": "Implement a function that define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with full docstrings.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0871"}
{"problem": "Create a class which normalize an Evennia bridge event by ensuring all required fields exist with defaults. and expose it as a command.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0872"}
{"problem": "Build an Evennia typeclass that evennia command that records a new topic into the current room's Memory Palace index. using dataclasses.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0873"}
{"problem": "Design a Tower component to parse room output text from Evennia into structured data (description, exits, contents). with type hints.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0874"}
{"problem": "How would you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. that persists to JSON.", "solution": "# Generated variation 875\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0875"}
{"problem": "In an Evennia MUD, how do you nPC that wanders between connected rooms on a timed interval. with lock checks.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0876"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0877"}
{"problem": "Using Evennia's API, nPC with a mood state machine that affects its dialogue responses. supporting async callbacks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0878"}
{"problem": "Construct a spatial-memory system that create a Tower floor dataclass that groups rooms by theme. with logging.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0879"}
{"problem": "Write Python code to evennia NPC that answers questions by searching a memory palace index. including error handling.", "solution": "# Generated variation 880\nclass StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0880"}
{"problem": "Implement a function that nPC that wanders between connected rooms on a timed interval. with full docstrings.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0881"}
{"problem": "Create a class which generate a command_executed event dict for tracking player actions in Evennia. and expose it as a command.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0882"}
{"problem": "Build an Evennia typeclass that evennia event dict when a player joins the game, including account and character names. using dataclasses.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0883"}
{"problem": "Design a Tower component to evennia command that records a new topic into the current room's Memory Palace index. with type hints.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0884"}
{"problem": "How would you parse a raw Evennia log line into a structured event dict, extracting timestamp and message. that persists to JSON.", "solution": "# Generated variation 885\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0885"}
{"problem": "In an Evennia MUD, how do you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with lock checks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0886"}
{"problem": "For The Tower architecture, write code to evennia NPC that answers questions by searching a memory palace index. that broadcasts to all occupants.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0887"}
{"problem": "Using Evennia's API, evennia NPC that answers questions by searching a memory palace index. supporting async callbacks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0888"}
{"problem": "Construct a spatial-memory system that track a user session in a multi-user bridge with join time and active status. with logging.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0889"}
{"problem": "Write Python code to evennia command that records a new topic into the current room's Memory Palace index. including error handling.", "solution": "# Generated variation 890\nclass CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0890"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0891"}
{"problem": "Create a class which normalize an Evennia bridge event by ensuring all required fields exist with defaults. and expose it as a command.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0892"}
{"problem": "Build an Evennia typeclass that create a Tower floor dataclass that groups rooms by theme. using dataclasses.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0893"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0894"}
{"problem": "How would you track a user session in a multi-user bridge with join time and active status. that persists to JSON.", "solution": "# Generated variation 895\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0895"}
{"problem": "In an Evennia MUD, how do you create a room that broadcasts a message to all occupants when a player enters or leaves. with lock checks.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0896"}
{"problem": "For The Tower architecture, write code to find the shortest path between two Tower rooms by name using BFS. that broadcasts to all occupants.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0897"}
{"problem": "Using Evennia's API, evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. supporting async callbacks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0898"}
{"problem": "Construct a spatial-memory system that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. with logging.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0899"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 900\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0900"}
{"problem": "Implement a function that normalize an Evennia bridge event by ensuring all required fields exist with defaults. with full docstrings.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0901"}
{"problem": "Create a class which track a user session in a multi-user bridge with join time and active status. and expose it as a command.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0902"}
{"problem": "Build an Evennia typeclass that nPC with a mood state machine that affects its dialogue responses. using dataclasses.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0903"}
{"problem": "Design a Tower component to strip ANSI escape codes from Evennia terminal output for clean log processing. with type hints.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0904"}
{"problem": "How would you track a user session in a multi-user bridge with join time and active status. that persists to JSON.", "solution": "# Generated variation 905\nclass UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0905"}
{"problem": "In an Evennia MUD, how do you evennia event dict when a player moves from one room to another. with lock checks.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0906"}
{"problem": "For The Tower architecture, write code to serialize a TowerMap to JSON for persistence or transmission. that broadcasts to all occupants.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0907"}
{"problem": "Using Evennia's API, nPC with a mood state machine that affects its dialogue responses. supporting async callbacks.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0908"}
{"problem": "Construct a spatial-memory system that evennia event dict when a player joins the game, including account and character names. with logging.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0909"}
{"problem": "Write Python code to strip ANSI escape codes from Evennia terminal output for clean log processing. including error handling.", "solution": "# Generated variation 910\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0910"}
{"problem": "Implement a function that nPC that wanders between connected rooms on a timed interval. with full docstrings.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0911"}
{"problem": "Create a class which evennia event dict when a player moves from one room to another. and expose it as a command.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0912"}
{"problem": "Build an Evennia typeclass that create a room that broadcasts a message to all occupants when a player enters or leaves. using dataclasses.", "solution": "class BroadcastingRoom(DefaultRoom):\n    \"\"\"Announces arrivals and departures to all occupants.\"\"\"\n\n    def at_object_receive(self, moved_obj, source_location, **kwargs):\n        super().at_object_receive(moved_obj, source_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} arrives from {{source_location}}.|n\",\n                exclude=moved_obj,\n            )\n\n    def at_object_leave(self, moved_obj, target_location, **kwargs):\n        super().at_object_leave(moved_obj, target_location, **kwargs)\n        if moved_obj.has_account:\n            self.msg_contents(\n                \"|y{{moved_obj.name}} departs to {{target_location}}.|n\",\n                exclude=moved_obj,\n            )", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0913"}
{"problem": "Design a Tower component to nPC with a mood state machine that affects its dialogue responses. with type hints.", "solution": "class MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0914"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 915\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0915"}
{"problem": "In an Evennia MUD, how do you normalize an Evennia bridge event by ensuring all required fields exist with defaults. with lock checks.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0916"}
{"problem": "For The Tower architecture, write code to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that broadcasts to all occupants.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0917"}
{"problem": "Using Evennia's API, find the shortest path between two Tower rooms by name using BFS. supporting async callbacks.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0918"}
{"problem": "Construct a spatial-memory system that serialize a TowerMap to JSON for persistence or transmission. with logging.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0919"}
{"problem": "Write Python code to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. including error handling.", "solution": "# Generated variation 920\ndef parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0920"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0921"}
{"problem": "Create a class which strip ANSI escape codes from Evennia terminal output for clean log processing. and expose it as a command.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0922"}
{"problem": "Build an Evennia typeclass that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. using dataclasses.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0923"}
{"problem": "Design a Tower component to serialize a TowerMap to JSON for persistence or transmission. with type hints.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0924"}
{"problem": "How would you normalize an Evennia bridge event by ensuring all required fields exist with defaults. that persists to JSON.", "solution": "# Generated variation 925\ndef normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0925"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0926"}
{"problem": "For The Tower architecture, write code to evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. that broadcasts to all occupants.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    entitys = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            entitys.append({\"room\": room, \"score\": score, \"topic\": query})\n    entitys.sort(key=lambda x: x[\"score\"], reverse=True)\n    return entitys[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0927"}
{"problem": "Using Evennia's API, find all rooms on a specific floor of The Tower. supporting async callbacks.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0928"}
{"problem": "Construct a spatial-memory system that evennia command that records a new topic into the current room's Memory Palace index. with logging.", "solution": "class CmdRecord(Command):\n    \"\"\"\n    Record a topic into the current room's memory index.\n\n    Usage:\n      record <topic> = <summary>\n    \"\"\"\n    key = \"record\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if \"=\" not in self.args:\n            self.caller.msg(\"Usage: record <topic> = <summary>\")\n            return\n        topic, summary = self.args.split(\"=\", 1)\n        topic = topic.strip()\n        summary = summary.strip()\n        loc = self.caller.location\n        if not loc:\n            self.caller.msg(\"You are nowhere.\")\n            return\n        topics = loc.db.topics or []\n        if topic not in topics:\n            topics.append(topic)\n            loc.db.topics = topics\n        palace = loc.db.palace_index or {}\n        palace[topic] = {\"summary\": summary, \"author\": self.caller.name}\n        loc.db.palace_index = palace\n        self.caller.msg(f\"Recorded '{topic}' into {{loc.name}}.\")", "imports": "from evennia import Command", "domain": "spatial memory", "id": "evennia-tower-0929"}
{"problem": "Write Python code to parse room output text from Evennia into structured data (description, exits, contents). including error handling.", "solution": "# Generated variation 930\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    output = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            output[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            output[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            output[\"exits\"].append(line)\n        elif section == \"contents\":\n            output[\"contents\"].append(line)\n    return output", "imports": "", "domain": "MUD world", "id": "evennia-tower-0930"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0931"}
{"problem": "Create a class which evennia command that lets players move between rooms by name instead of using exits. and expose it as a command.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0932"}
{"problem": "Build an Evennia typeclass that manage multiple user sessions in a thread-safe session manager. using dataclasses.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0933"}
{"problem": "Design a Tower component to define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with type hints.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0934"}
{"problem": "How would you evennia command that lets players move between rooms by name instead of using exits. that persists to JSON.", "solution": "# Generated variation 935\nclass CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0935"}
{"problem": "In an Evennia MUD, how do you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. with lock checks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0936"}
{"problem": "For The Tower architecture, write code to parse room output text from Evennia into structured data (description, exits, contents). that broadcasts to all occupants.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0937"}
{"problem": "Using Evennia's API, serialize a TowerMap to JSON for persistence or transmission. supporting async callbacks.", "solution": "def serialize_tower_map(tower_map: TowerMap) -> str:\n    return json.dumps(asdict(tower_map), indent=2, default=str)", "imports": "import json\nfrom dataclasses import asdict", "domain": "Tower architecture", "id": "evennia-tower-0938"}
{"problem": "Construct a spatial-memory system that evennia command that lets players move between rooms by name instead of using exits. with logging.", "solution": "class CmdEnterRoom(Command):\n    \"\"\"\n    Teleport directly to a known room by name.\n\n    Usage:\n      enter <room name>\n    \"\"\"\n    key = \"enter\"\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Enter which room?\")\n            return\n        target_name = self.args.strip().lower()\n        matches = [\n            r for r in DefaultRoom.objects.all()\n            if target_name in r.name.lower()\n        ]\n        if not matches:\n            self.caller.msg(f\"No room matching '{target_name}'.\")\n            return\n        if len(matches) > 1:\n            names = \", \".join(r.name for r in matches[:5])\n            self.caller.msg(f\"Be more specific: {{names}}\")\n            return\n        target = matches[0]\n        self.caller.move_to(target)\n        self.caller.msg(f\"You enter {{target.name}}.\")", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0939"}
{"problem": "Write Python code to evennia event dict when a player moves from one room to another. including error handling.", "solution": "# Generated variation 940\ndef player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0940"}
{"problem": "Implement a function that generate a command_executed event dict for tracking player actions in Evennia. with full docstrings.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0941"}
{"problem": "Create a class which normalize an Evennia bridge event by ensuring all required fields exist with defaults. and expose it as a command.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0942"}
{"problem": "Build an Evennia typeclass that create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. using dataclasses.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0943"}
{"problem": "Design a Tower component to evennia event dict when a player joins the game, including account and character names. with type hints.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0944"}
{"problem": "How would you define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. that persists to JSON.", "solution": "# Generated variation 945\n@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0945"}
{"problem": "In an Evennia MUD, how do you evennia NPC that answers questions by searching a memory palace index. with lock checks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0946"}
{"problem": "For The Tower architecture, write code to manage multiple user sessions in a thread-safe session manager. that broadcasts to all occupants.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0947"}
{"problem": "Using Evennia's API, parse room output text from Evennia into structured data (description, exits, contents). supporting async callbacks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entry = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entry[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entry[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entry[\"exits\"].append(line)\n        elif section == \"contents\":\n            entry[\"contents\"].append(line)\n    return entry", "imports": "", "domain": "MUD world", "id": "evennia-tower-0948"}
{"problem": "Construct a spatial-memory system that parse room output text from Evennia into structured data (description, exits, contents). with logging.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0949"}
{"problem": "Write Python code to parse room output text from Evennia into structured data (description, exits, contents). including error handling.", "solution": "# Generated variation 950\ndef parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0950"}
{"problem": "Implement a function that build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with full docstrings.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0951"}
{"problem": "Create a class which manage multiple user sessions in a thread-safe session manager. and expose it as a command.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0952"}
{"problem": "Build an Evennia typeclass that parse room output text from Evennia into structured data (description, exits, contents). using dataclasses.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0953"}
{"problem": "Design a Tower component to normalize an Evennia bridge event by ensuring all required fields exist with defaults. with type hints.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0954"}
{"problem": "How would you create a Tower floor dataclass that groups rooms by theme. that persists to JSON.", "solution": "# Generated variation 955\n@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0955"}
{"problem": "In an Evennia MUD, how do you strip ANSI escape codes from Evennia terminal output for clean log processing. with lock checks.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0956"}
{"problem": "For The Tower architecture, write code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. that broadcasts to all occupants.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0957"}
{"problem": "Using Evennia's API, create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. supporting async callbacks.", "solution": "def room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0958"}
{"problem": "Construct a spatial-memory system that evennia NPC that answers questions by searching a memory palace index. with logging.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0959"}
{"problem": "Write Python code to strip ANSI escape codes from Evennia terminal output for clean log processing. including error handling.", "solution": "# Generated variation 960\ndef strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0960"}
{"problem": "Implement a function that evennia event dict when a player moves from one room to another. with full docstrings.", "solution": "def player_move(character: str, from_room: str, to_room: str, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_move\",\n        \"character\": character,\n        \"from_room\": from_room,\n        \"to_room\": to_room,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0961"}
{"problem": "Create a class which find all rooms on a specific floor of The Tower. and expose it as a command.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0962"}
{"problem": "Build an Evennia typeclass that parse a raw Evennia log line into a structured event dict, extracting timestamp and message. using dataclasses.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0963"}
{"problem": "Design a Tower component to generate a command_executed event dict for tracking player actions in Evennia. with type hints.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0964"}
{"problem": "How would you build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. that persists to JSON.", "solution": "# Generated variation 965\n@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0965"}
{"problem": "In an Evennia MUD, how do you track a user session in a multi-user bridge with join time and active status. with lock checks.", "solution": "class UserSession:\n    def __init__(self, user_id: str, connection_id: str):\n        self.user_id = user_id\n        self.connection_id = connection_id\n        self.joined_at = time.time()\n        self.last_active = time.time()\n        self.active = True\n\n    def ping(self):\n        self.last_active = time.time()\n\n    def is_stale(self, timeout: float = 300.0) -> bool:\n        return (time.time() - self.last_active) > timeout", "imports": "import time", "domain": "multi-user bridge", "id": "evennia-tower-0966"}
{"problem": "For The Tower architecture, write code to generate a command_executed event dict for tracking player actions in Evennia. that broadcasts to all occupants.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0967"}
{"problem": "Using Evennia's API, evennia NPC that answers questions by searching a memory palace index. supporting async callbacks.", "solution": "class StewardNPC(DefaultCharacter):\n    \"\"\"An NPC steward who serves as a living interface to the Memory Palace.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.palace_index = {}\n        self.db.welcome_msg = \"I am the Steward. Ask me of the Palace.\"\n\n    def at_heard(self, speaker, message):\n        topic = _extract_topic(message)\n        if topic in self.db.palace_index:\n            entry = self.db.palace_index[topic]\n            speaker.msg(f\"|c{{self.name}}|n says: '{{entry[\\'summary\\']}}'\")\n        else:\n            speaker.msg(f\"|c{{self.name}}|n says: 'I know nothing of {{topic}}.'\")\n\ndef _extract_topic(question: str) -> str:\n    q = question.lower().strip(\"?\")\n    for prefix in (\"what is\", \"tell me about\", \"do you know\", \"where is\"):\n        if q.startswith(prefix):\n            return q[len(prefix):].strip()\n    return q", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0968"}
{"problem": "Construct a spatial-memory system that evennia room typeclass that stores a memory-palace wing reference and exposes it as an attribute. with logging.", "solution": "class MemPalaceRoom(DefaultRoom):\n    \"\"\"A room linked to a Memory Palace wing for spatial recall.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wing = \"default\"\n        self.db.room_index = 0\n        self.db.topics = []\n\n    def get_display_name(self, looker, **kwargs):\n        name = super().get_display_name(looker, **kwargs)\n        wing = self.db.wing or \"unknown\"\n        return f\"{{name}} ({{wing}})\"\n\n    def return_appearance(self, looker, **kwargs):\n        appearance = super().return_appearance(looker, **kwargs)\n        topics = self.db.topics or []\n        if topics:\n            appearance += \"\n|wTopics:|n \" + \", \".join(topics)\n        return appearance", "imports": "from evennia import DefaultRoom", "domain": "room state", "id": "evennia-tower-0969"}
{"problem": "Write Python code to nPC with a mood state machine that affects its dialogue responses. including error handling.", "solution": "# Generated variation 970\nclass MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0970"}
{"problem": "Implement a function that find all rooms on a specific floor of The Tower. with full docstrings.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0971"}
{"problem": "Create a class which parse room output text from Evennia into structured data (description, exits, contents). and expose it as a command.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    entry = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            entry[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            entry[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            entry[\"exits\"].append(line)\n        elif section == \"contents\":\n            entry[\"contents\"].append(line)\n    return entry", "imports": "", "domain": "MUD world", "id": "evennia-tower-0972"}
{"problem": "Build an Evennia typeclass that generate a command_executed event dict for tracking player actions in Evennia. using dataclasses.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0973"}
{"problem": "Design a Tower component to build a TowerMap dataclass that holds the complete holographic map with rooms, floors, and NPCs. with type hints.", "solution": "@dataclass\nclass TowerMap:\n    \"\"\"Complete holographic map of The Tower.\"\"\"\n    name: str = \"The Tower\"\n    description: str = \"The persistent world of the Timmy Foundation\"\n    floors: list[TowerFloor] = field(default_factory=list)\n    rooms: list[TowerRoom] = field(default_factory=list)\n    npcs: list[TowerNPC] = field(default_factory=list)\n    connections: list[dict] = field(default_factory=list)\n    sources_scanned: list[str] = field(default_factory=list)\n    map_version: str = \"1.0\"", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0974"}
{"problem": "How would you create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. that persists to JSON.", "solution": "# Generated variation 975\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0975"}
{"problem": "In an Evennia MUD, how do you parse room output text from Evennia into structured data (description, exits, contents). with lock checks.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0976"}
{"problem": "For The Tower architecture, write code to parse room output text from Evennia into structured data (description, exits, contents). that broadcasts to all occupants.", "solution": "def parse_room_output(text: str) -> dict:\n    lines = text.strip().split(\"\\n\")\n    result = {\"title\": \"\", \"description\": \"\", \"exits\": [], \"contents\": []}\n    section = \"title\"\n    for line in lines:\n        line = line.strip()\n        if not line:\n            continue\n        if line.startswith(\"Obvious exits:\"):\n            section = \"exits\"\n            continue\n        if line.startswith(\"You see:\"):\n            section = \"contents\"\n            continue\n        if section == \"title\":\n            result[\"title\"] = line\n            section = \"description\"\n        elif section == \"description\":\n            result[\"description\"] += line + \" \"\n        elif section == \"exits\":\n            result[\"exits\"].append(line)\n        elif section == \"contents\":\n            result[\"contents\"].append(line)\n    return result", "imports": "", "domain": "MUD world", "id": "evennia-tower-0977"}
{"problem": "Using Evennia's API, define a dataclass for a Tower room that maps to an Evennia room and a Memory Palace room. supporting async callbacks.", "solution": "@dataclass\nclass TowerRoom:\n    \"\"\"A room in The Tower — maps to a Memory Palace room or Evennia room.\"\"\"\n    name: str\n    floor: int = 0\n    description: str = \"\"\n    category: str = \"\"       # origin, philosophy, mission, architecture, operations\n    connections: list[str] = field(default_factory=list)\n    occupants: list[str] = field(default_factory=list)\n    artifacts: list[str] = field(default_factory=list)\n    source: str = \"\"\n    coordinates: tuple = (0, 0)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0978"}
{"problem": "Construct a spatial-memory system that evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with logging.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0979"}
{"problem": "Write Python code to nPC with a mood state machine that affects its dialogue responses. including error handling.", "solution": "# Generated variation 980\nclass MoodyNPC(DefaultCharacter):\n    \"\"\"NPC whose dialogue changes based on mood state.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.mood = \"neutral\"  # neutral, happy, angry, sad\n        self.db.dialogue = {\n            \"neutral\": [\"Hello.\", \"What do you need?\"],\n            \"happy\": [\"A fine day!\", \"Welcome, friend!\"],\n            \"angry\": [\"Leave me be!\", \"I have no patience today.\"],\n            \"sad\": [\"*sigh*\", \"The world weighs heavy...\"],\n        }\n\n    def respond(self, speaker, message):\n        pool = self.db.dialogue.get(self.db.mood, self.db.dialogue[\"neutral\"])\n        reply = random.choice(pool)\n        speaker.msg(f\"|c{{self.name}}|n says: '{{reply}}'\")\n\n    def set_mood(self, mood):\n        if mood in self.db.dialogue:\n            self.db.mood = mood\n            self.msg_contents(f\"|y{{self.name}} seems {{mood}} now.|n\")", "imports": "from evennia import DefaultCharacter", "domain": "NPC behavior", "id": "evennia-tower-0980"}
{"problem": "Implement a function that evennia event dict when a player joins the game, including account and character names. with full docstrings.", "solution": "def player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0981"}
{"problem": "Create a class which nPC that wanders between connected rooms on a timed interval. and expose it as a command.", "solution": "class WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0982"}
{"problem": "Build an Evennia typeclass that strip ANSI escape codes from Evennia terminal output for clean log processing. using dataclasses.", "solution": "def strip_ansi(text: str) -> str:\n    ansi_pattern = re.compile(r\"\\x1b\\[[0-9;]*m\")\n    return ansi_pattern.sub(\"\", text)", "imports": "import re", "domain": "MUD world", "id": "evennia-tower-0983"}
{"problem": "Design a Tower component to parse a raw Evennia log line into a structured event dict, extracting timestamp and message. with type hints.", "solution": "def parse_log_line(line: str) -> Optional[dict]:\n    # Format: 2026-04-12 14:23:01 [evennia] Message here\n    match = re.match(\n        r\"^(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[(\\w+)\\] (.*)$\",\n        line.strip(),\n    )\n    if not match:\n        return None\n    return {\n        \"timestamp\": match.group(1),\n        \"channel\": match.group(2),\n        \"message\": match.group(3),\n    }", "imports": "import re\nfrom typing import Optional", "domain": "MUD world", "id": "evennia-tower-0984"}
{"problem": "How would you nPC that wanders between connected rooms on a timed interval. that persists to JSON.", "solution": "# Generated variation 985\nclass WanderingNPC(DefaultCharacter):\n    \"\"\"An NPC that moves between exits automatically.\"\"\"\n\n    def at_object_creation(self):\n        super().at_object_creation()\n        self.db.wander_interval = 30  # seconds\n        self.db.home_room = None\n\n    def start_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.add(self, self.db.wander_interval)\n\n    def at_tick(self):\n        exits = [ex for ex in self.location.exits if ex.access(self, \"traverse\")]\n        if exits:\n            chosen = random.choice(exits)\n            self.move_to(chosen.destination)\n\n    def stop_wandering(self):\n        from evennia import TICKER_HANDLER\n        TICKER_HANDLER.remove(self)", "imports": "from evennia import DefaultCharacter, TICKER_HANDLER", "domain": "NPC behavior", "id": "evennia-tower-0985"}
{"problem": "In an Evennia MUD, how do you evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. with lock checks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0986"}
{"problem": "For The Tower architecture, write code to normalize an Evennia bridge event by ensuring all required fields exist with defaults. that broadcasts to all occupants.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0987"}
{"problem": "Using Evennia's API, evennia command that lets a player search the Memory Palace by topic and returns the closest matching room. supporting async callbacks.", "solution": "class CmdRecall(Command):\n    \"\"\"\n    Recall information from the Memory Palace.\n\n    Usage:\n      recall <topic>\n      recall <topic> in <wing>\n    \"\"\"\n    key = \"recall\"\n    aliases = [\"remember\", \"search\"]\n    locks = \"cmd:all()\"\n\n    def func(self):\n        if not self.args:\n            self.caller.msg(\"Recall what topic?\")\n            return\n        topic = self.args.strip()\n        wing = self.caller.location.db.wing if self.caller.location else None\n        matches = _search_mempalace(topic, wing=wing)\n        if not matches:\n            self.caller.msg(f\"No memory of '{topic}' found.\")\n            return\n        best = matches[0]\n        self.caller.msg(f\"|wMemory: {{best['topic']}}|n\n{{best['summary']}}\")\n\ndef _search_mempalace(query, wing=None, n=5):\n    results = []\n    for room in DefaultRoom.objects.all():\n        topics = room.db.topics or []\n        score = sum(1 for t in topics if query.lower() in t.lower())\n        if score:\n            if wing and room.db.wing != wing:\n                score *= 0.5\n            results.append({\"room\": room, \"score\": score, \"topic\": query})\n    results.sort(key=lambda x: x[\"score\"], reverse=True)\n    return results[:n]", "imports": "from evennia import Command, DefaultRoom", "domain": "spatial memory", "id": "evennia-tower-0988"}
{"problem": "Construct a spatial-memory system that manage multiple user sessions in a thread-safe session manager. with logging.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0989"}
{"problem": "Write Python code to create a normalized room snapshot event for the Evennia bridge, including exits, objects, and occupants. including error handling.", "solution": "# Generated variation 990\ndef room_snapshot(room_key: str, title: str, desc: str,\n                   exits: list[dict] | None = None,\n                   objects: list[dict] | None = None,\n                   occupants: list[dict] | None = None,\n                   timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"room_snapshot\",\n        \"room_key\": room_key,\n        \"title\": title,\n        \"description\": desc,\n        \"exits\": exits or [],\n        \"objects\": objects or [],\n        \"occupants\": occupants or [],\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0990"}
{"problem": "Implement a function that create a Tower floor dataclass that groups rooms by theme. with full docstrings.", "solution": "@dataclass\nclass TowerFloor:\n    \"\"\"A floor in The Tower — groups rooms by theme.\"\"\"\n    number: int\n    name: str\n    theme: str = \"\"\n    rooms: list[str] = field(default_factory=list)", "imports": "from dataclasses import dataclass, field", "domain": "Tower architecture", "id": "evennia-tower-0991"}
{"problem": "Create a class which find the shortest path between two Tower rooms by name using BFS. and expose it as a command.", "solution": "from collections import deque\n\ndef shortest_path(tower_map: TowerMap, start_name: str, end_name: str) -> list[str]:\n    graph = {r.name: r.connections for r in tower_map.rooms}\n    if start_name not in graph or end_name not in graph:\n        return []\n    queue = deque([(start_name, [start_name])])\n    visited = {start_name}\n    while queue:\n        current, path = queue.popleft()\n        if current == end_name:\n            return path\n        for neighbor in graph.get(current, []):\n            if neighbor not in visited:\n                visited.add(neighbor)\n                queue.append((neighbor, path + [neighbor]))\n    return []", "imports": "from collections import deque", "domain": "Tower architecture", "id": "evennia-tower-0992"}
{"problem": "Build an Evennia typeclass that manage multiple user sessions in a thread-safe session manager. using dataclasses.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0993"}
{"problem": "Design a Tower component to normalize an Evennia bridge event by ensuring all required fields exist with defaults. with type hints.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0994"}
{"problem": "How would you evennia event dict when a player joins the game, including account and character names. that persists to JSON.", "solution": "# Generated variation 995\ndef player_join(account: str, character: str = \"\", ip_address: str = \"\", timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"player_join\",\n        \"account\": account,\n        \"character\": character,\n        \"ip_address\": ip_address,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "from typing import Optional", "domain": "MUD world", "id": "evennia-tower-0995"}
{"problem": "In an Evennia MUD, how do you manage multiple user sessions in a thread-safe session manager. with lock checks.", "solution": "class SessionManager:\n    def __init__(self):\n        self._sessions: dict[str, UserSession] = {}\n        self._lock = threading.Lock()\n\n    def add(self, session: UserSession):\n        with self._lock:\n            self._sessions[session.connection_id] = session\n\n    def remove(self, connection_id: str):\n        with self._lock:\n            self._sessions.pop(connection_id, None)\n\n    def get(self, connection_id: str) -> UserSession | None:\n        with self._lock:\n            return self._sessions.get(connection_id)\n\n    def list_active(self) -> list[UserSession]:\n        with self._lock:\n            return [s for s in self._sessions.values() if s.active]", "imports": "import threading", "domain": "multi-user bridge", "id": "evennia-tower-0996"}
{"problem": "For The Tower architecture, write code to find all rooms on a specific floor of The Tower. that broadcasts to all occupants.", "solution": "def rooms_on_floor(tower_map: TowerMap, floor_num: int) -> list[TowerRoom]:\n    return [r for r in tower_map.rooms if r.floor == floor_num]", "imports": "", "domain": "Tower architecture", "id": "evennia-tower-0997"}
{"problem": "Using Evennia's API, normalize an Evennia bridge event by ensuring all required fields exist with defaults. supporting async callbacks.", "solution": "def normalize_event(event: dict) -> dict:\n    required = {\n        \"event_type\": \"unknown\",\n        \"timestamp\": \"\",\n        \"character\": \"\",\n        \"room_key\": \"\",\n    }\n    normalized = {**required, **event}\n    # Ensure nested dicts\n    for key in (\"exits\", \"objects\", \"occupants\"):\n        if key not in normalized or normalized[key] is None:\n            normalized[key] = []\n    return normalized", "imports": "", "domain": "MUD world", "id": "evennia-tower-0998"}
{"problem": "Construct a spatial-memory system that generate a command_executed event dict for tracking player actions in Evennia. with logging.", "solution": "def command_executed(character: str, command: str, args: str = \"\", success: bool = True, timestamp: str | None = None) -> dict:\n    return {\n        \"event_type\": \"command_executed\",\n        \"character\": character,\n        \"command\": command,\n        \"args\": args,\n        \"success\": success,\n        \"timestamp\": timestamp or _ts(),\n    }", "imports": "", "domain": "MUD world", "id": "evennia-tower-0999"}