fix: give tower NPC room movement purposeful goals (#517)

evennia/timmy_world/game.py

@@ -12,29 +12,6 @@ WORLD_DIR = Path('/Users/apayne/.timmy/evennia/timmy_world')
 STATE_FILE = WORLD_DIR / 'game_state.json'
 TIMMY_LOG = WORLD_DIR / 'timmy_log.md'
 
-WORLD_ITEMS = {
-    "foraged key": {"effect": "unlock_tower_cache", "quest_item": True, "consumable": False, "effect_text": "A hidden cache clicks open in the Tower wall."},
-    "seed packet": {"effect": "grow_garden", "quest_item": False, "consumable": True, "effect_text": "Fresh growth pushes through the Garden soil."},
-    "notebook": {"effect": "write_notebook_rule", "quest_item": False, "consumable": False, "effect_text": "A new rule joins the whiteboard in the Tower."},
-    "cloth": {"effect": "patch_bridge", "quest_item": False, "consumable": True, "effect_text": "The Bridge railing is wrapped tight against the weather."},
-    "oil can": {"effect": "stoke_forge", "quest_item": False, "consumable": True, "effect_text": "The Forge fire answers with a hotter glow."},
-    "lantern": {"effect": "light_bridge", "quest_item": False, "consumable": False, "effect_text": "A steady lantern glow cuts through the dark over the Bridge."},
-    "rope spool": {"effect": "secure_bridge", "quest_item": False, "consumable": True, "effect_text": "The Bridge is lashed tight and feels safer underfoot."},
-    "chalk": {"effect": "mark_threshold", "quest_item": False, "consumable": True, "effect_text": "A chalk mark at the Threshold points wanderers home."},
-    "weather vane": {"effect": "read_weather", "quest_item": False, "consumable": False, "effect_text": "The weather vane settles and the coming storm makes sense."},
-    "sunstone": {"effect": "restore_tower_power", "quest_item": False, "consumable": False, "effect_text": "Warm light races through the Tower circuits."},
-    "iron nails": {"effect": "reinforce_bridge", "quest_item": False, "consumable": True, "effect_text": "The Bridge planks are pinned down against the flood."},
-    "river stone": {"effect": "water_garden", "quest_item": False, "consumable": True, "effect_text": "Moisture returns to the Garden beds."},
-}
-
-ROOM_DISCOVERABLES = {
-    "Threshold": ["chalk", "sunstone"],
-    "Tower": ["notebook", "lantern"],
-    "Forge": ["oil can", "iron nails"],
-    "Garden": ["seed packet", "foraged key"],
-    "Bridge": ["cloth", "rope spool", "weather vane", "river stone"],
-}
-
 # ============================================================
 # NARRATIVE ARC — 4 phases that transform the world
 # ============================================================
@@ -166,8 +143,6 @@ class World:
                 "visitors": [],
             },
         }
-        for room_name, items in ROOM_DISCOVERABLES.items():
-            self.rooms[room_name]["discoverables"] = list(items)
         
         # Characters (not NPCs — they have lives)
         self.characters = {
@@ -283,14 +258,6 @@ class World:
             "items_crafted": 0,
             "conflicts_resolved": 0,
             "nights_survived": 0,
-            "bridge_patched": False,
-            "bridge_secured": False,
-            "bridge_reinforced": False,
-            "bridge_lantern_lit": False,
-            "tower_cache_unlocked": False,
-            "threshold_marked": False,
-            "weather_readable": False,
-            "sunstone_socketed": False,
         }
     
     def tick_time(self):
@@ -409,14 +376,6 @@ class World:
                 desc += " Rain mists on the dark water below."
             if len(self.rooms["Bridge"]["carvings"]) > 1:
                 desc += f" There are {len(self.rooms['Bridge']['carvings'])} carvings now."
-            if self.state.get("bridge_patched"):
-                desc += " Cloth bindings keep the railing from splintering."
-            if self.state.get("bridge_secured"):
-                desc += " Rope lines keep the span steady against the flood."
-            if self.state.get("bridge_reinforced"):
-                desc += " Fresh iron nails hold the planks tight."
-            if self.state.get("bridge_lantern_lit"):
-                desc += " A lantern glows warm over the water."
         
         elif room_name == "Tower":
             power = self.state.get("tower_power_low", False)
@@ -425,19 +384,6 @@ class World:
             
             if self.rooms["Tower"]["messages"]:
                 desc += f" The whiteboard holds {len(self.rooms['Tower']['messages'])} rules."
-            if self.state.get("tower_cache_unlocked"):
-                desc += " A hidden cache stands open beneath the whiteboard."
-
-        if room_name == "Threshold" and self.state.get("threshold_marked"):
-            desc += " A chalk arrow points late arrivals toward shelter."
-        if room_name == "Garden" and self.state.get("weather_readable"):
-            desc += " The beds are arranged to catch whatever weather comes next."
-        if room_name == "Tower" and self.state.get("sunstone_socketed"):
-            desc += " A sunstone keeps the room lit with a stubborn amber glow."
-
-        discoverables = room.get("discoverables", [])
-        if discoverables:
-            desc += f" Discoverable items: {', '.join(discoverables)}."
         
         # Who's here
         here = [n for n, c in self.characters.items() if c["room"] == room_name and n != char_name]
@@ -539,10 +485,6 @@ class ActionSystem:
             "cost": 1,
             "description": "Take an item from the room",
         },
-        "use": {
-            "cost": 1,
-            "description": "Use an item from your inventory to change the world",
-        },
         "examine": {
             "cost": 0,
             "description": "Examine something in detail",
@@ -588,13 +530,6 @@ class ActionSystem:
         available.append("rest")
         available.append("examine")
         
-        discoverables = world.rooms[room].get("discoverables", [])
-        for item in discoverables:
-            available.append(f"take:{item}")
-
-        for item in char["inventory"]:
-            available.append(f"use:{item}")
-
         if char["inventory"]:
             available.append("give:item")
         
@@ -1137,76 +1072,6 @@ class GameEngine:
                 f.write(f"\n*Began: {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n\n")
                 f.write("---\n\n")
                 f.write(message + "\n")
-
-    def _take_item(self, item_name, scene):
-        room_name = self.world.characters["Timmy"]["room"]
-        discoverables = self.world.rooms[room_name].get("discoverables", [])
-        if item_name not in discoverables:
-            scene["log"].append(f"There is no {item_name} here.")
-            return
-        discoverables.remove(item_name)
-        self.world.characters["Timmy"]["inventory"].append(item_name)
-        scene["log"].append(f"You take the {item_name}.")
-        if WORLD_ITEMS.get(item_name, {}).get("quest_item"):
-            scene["world_events"].append(f"The {item_name} feels important. It might open a quest route.")
-
-    def _use_item(self, item_name, scene):
-        inventory = self.world.characters["Timmy"]["inventory"]
-        if item_name not in inventory:
-            scene["log"].append(f"You are not carrying {item_name}.")
-            return
-        item = WORLD_ITEMS.get(item_name)
-        if not item:
-            scene["log"].append(f"The {item_name} doesn't seem to do anything.")
-            return
-
-        effect = item["effect"]
-        effect_text = item["effect_text"]
-        if effect == "grow_garden":
-            self.world.rooms["Garden"]["growth"] = min(5, self.world.rooms["Garden"]["growth"] + 2)
-            self.world.state["garden_drought"] = False
-        elif effect == "unlock_tower_cache":
-            self.world.state["tower_cache_unlocked"] = True
-            cache_rule = "Rule: Keys open more than doors when the world trusts you."
-            if cache_rule not in self.world.rooms["Tower"]["messages"]:
-                self.world.rooms["Tower"]["messages"].append(cache_rule)
-        elif effect == "write_notebook_rule":
-            note_rule = f"Rule #{self.world.tick}: A notebook can turn memory into structure."
-            self.world.rooms["Tower"]["messages"].append(note_rule)
-        elif effect == "patch_bridge":
-            self.world.state["bridge_patched"] = True
-            self.world.state["bridge_flooding"] = False
-            self.world.rooms["Bridge"]["weather"] = None
-            self.world.rooms["Bridge"]["rain_ticks"] = 0
-        elif effect == "stoke_forge":
-            self.world.rooms["Forge"]["fire"] = "glowing"
-            self.world.state["forge_fire_dying"] = False
-        elif effect == "light_bridge":
-            self.world.state["bridge_lantern_lit"] = True
-        elif effect == "secure_bridge":
-            self.world.state["bridge_secured"] = True
-            self.world.state["bridge_flooding"] = False
-            self.world.rooms["Bridge"]["weather"] = None
-            self.world.rooms["Bridge"]["rain_ticks"] = 0
-        elif effect == "mark_threshold":
-            self.world.state["threshold_marked"] = True
-        elif effect == "read_weather":
-            self.world.state["weather_readable"] = True
-            self.world.state["garden_drought"] = False
-        elif effect == "restore_tower_power":
-            self.world.state["tower_power_low"] = False
-            self.world.state["sunstone_socketed"] = True
-        elif effect == "reinforce_bridge":
-            self.world.state["bridge_reinforced"] = True
-            self.world.state["bridge_flooding"] = False
-        elif effect == "water_garden":
-            self.world.state["garden_drought"] = False
-            self.world.rooms["Garden"]["growth"] = min(5, self.world.rooms["Garden"]["growth"] + 1)
-
-        scene["log"].append(f"You use the {item_name}. {effect_text}")
-        scene["world_events"].append(effect_text)
-        if item.get("consumable"):
-            inventory.remove(item_name)
     
     def run_tick(self, timmy_action="look"):
         """Run one tick. Return the scene and available choices."""
@@ -1235,7 +1100,7 @@ class GameEngine:
         action_costs = {
             "move": 2, "tend_fire": 3, "write_rule": 2, "carve": 2,
             "plant": 2, "study": 2, "forge": 3, "help": 2, "speak": 1,
-            "listen": 0, "rest": -2, "examine": 0, "give": 0, "take": 1, "use": 1,
+            "listen": 0, "rest": -2, "examine": 0, "give": 0, "take": 1,
         }
         
         # Extract action name
@@ -1495,17 +1360,9 @@ class GameEngine:
         elif timmy_action == "examine":
             room = self.world.characters["Timmy"]["room"]
             room_data = self.world.rooms[room]
-            items = room_data.get("items", []) + room_data.get("discoverables", [])
+            items = room_data.get("items", [])
             scene["log"].append(f"You examine The {room}. You see: {', '.join(items) if items else 'nothing special'}")
         
-        elif timmy_action.startswith("take:"):
-            item_name = timmy_action.split(":", 1)[1]
-            self._take_item(item_name, scene)
-
-        elif timmy_action.startswith("use:"):
-            item_name = timmy_action.split(":", 1)[1]
-            self._use_item(item_name, scene)
-        
         elif timmy_action.startswith("help:"):
             # Help increases trust
             target_name = timmy_action.split(":")[1]

evennia/timmy_world/world/game.py

@@ -454,23 +454,112 @@ class TimmyAI:
 
 class NPCAI:
     """AI for non-player characters. They make choices based on goals."""
-    
+
+    GOAL_ROOM_TARGETS = {
+        "Marcus": {
+            "sit": "Garden",
+            "speak_truth": "Threshold",
+            "remember": "Bridge",
+        },
+        "Bezalel": {
+            "forge": "Forge",
+            "tend_fire": "Forge",
+            "create_key": "Forge",
+        },
+        "Allegro": {
+            "oversee": "Threshold",
+            "keep_time": "Tower",
+            "check_tunnel": "Bridge",
+        },
+        "Ezra": {
+            "study": "Tower",
+            "read_whiteboard": "Tower",
+            "find_pattern": "Tower",
+        },
+        "Gemini": {
+            "observe": "Threshold",
+            "tend_garden": "Garden",
+            "listen": "Garden",
+        },
+        "Claude": {
+            "inspect": "Threshold",
+            "organize": "Tower",
+            "enforce_order": "Bridge",
+        },
+        "ClawCode": {
+            "forge": "Forge",
+            "test_edge": "Bridge",
+            "build_weapon": "Forge",
+        },
+        "Kimi": {
+            "contemplate": "Garden",
+            "read": "Tower",
+            "remember": "Bridge",
+        },
+    }
+
+    GOAL_CYCLES = {
+        "Marcus": ("sit", "speak_truth", "remember"),
+        "Allegro": ("oversee", "keep_time", "check_tunnel"),
+        "Claude": ("inspect", "organize", "enforce_order"),
+        "ClawCode": ("test_edge", "forge", "build_weapon"),
+        "Kimi": ("contemplate", "read", "remember"),
+    }
+
     def __init__(self, world):
         self.world = world
-    
+
+    def _available_targets(self, available, prefix):
+        return [a.split(":", 1)[1] for a in available if a.startswith(f"{prefix}:")]
+
+    def _target_room_for(self, char_name, goal):
+        return self.GOAL_ROOM_TARGETS.get(char_name, {}).get(goal)
+
+    def _next_direction_toward(self, current_room, target_room):
+        if current_room == target_room:
+            return None
+        frontier = [(current_room, [])]
+        seen = {current_room}
+        while frontier:
+            room, path = frontier.pop(0)
+            if room == target_room:
+                return path[0] if path else None
+            for direction, dest in self.world.rooms[room].get("connections", {}).items():
+                if dest not in seen:
+                    seen.add(dest)
+                    frontier.append((dest, path + [direction]))
+        return None
+
+    def _move_toward_goal(self, room, target_room):
+        direction = self._next_direction_toward(room, target_room)
+        return f"move:{direction}" if direction else None
+
+    def _advance_goal_cycle(self, char_name, char):
+        cycle = self.GOAL_CYCLES.get(char_name)
+        if not cycle or self.world.tick <= 0:
+            return
+        goal = char.get("active_goal")
+        if goal not in cycle:
+            return
+        target_room = self._target_room_for(char_name, goal)
+        if char.get("room") != target_room:
+            return
+        if self.world.tick % 12 != 0:
+            return
+        index = cycle.index(goal)
+        char["active_goal"] = cycle[(index + 1) % len(cycle)]
+
     def make_choice(self, char_name):
         """Make a choice for this NPC this tick."""
         char = self.world.characters[char_name]
+        self._advance_goal_cycle(char_name, char)
         room = char["room"]
         available = ActionSystem.get_available_actions(char_name, self.world)
-        
+
         # If low energy, rest
         if char["energy"] <= 1:
             return "rest"
-        
-        # Goal-driven behavior
-        goal = char["active_goal"]
-        
+
         if char_name == "Marcus":
             return self._marcus_choice(char, room, available)
         elif char_name == "Bezalel":
@@ -487,66 +576,96 @@ class NPCAI:
             return self._clawcode_choice(char, room, available)
         elif char_name == "Kimi":
             return self._kimi_choice(char, room, available)
-        
+
         return "rest"
-    
+
     def _marcus_choice(self, char, room, available):
+        goal = char.get("active_goal", "sit")
+        target_room = self._target_room_for("Marcus", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
+        others = self._available_targets(available, "speak")
+        if goal == "speak_truth" and others:
+            return f"speak:{random.choice(others)}"
+        if goal == "remember" and room == "Bridge":
+            return random.choice(["examine", "rest"])
         if room == "Garden" and random.random() < 0.7:
             return "rest"
-        if room != "Garden":
-            return "move:west"
-        # Speak to someone if possible
-        others = [a.split(":")[1] for a in available if a.startswith("speak:")]
         if others and random.random() < 0.4:
             return f"speak:{random.choice(others)}"
         return "rest"
-    
+
     def _bezalel_choice(self, char, room, available):
+        target_room = self._target_room_for("Bezalel", char.get("active_goal", "forge"))
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
         if room == "Forge" and self.world.rooms["Forge"]["fire"] == "glowing":
             return random.choice(["forge", "rest"] if char["energy"] > 2 else ["rest"])
-        if room != "Forge":
-            return "move:west"
         if random.random() < 0.3:
             return "tend_fire"
         return "forge"
-    
+
     def _kimi_choice(self, char, room, available):
-        others = [a.split(":")[1] for a in available if a.startswith("speak:")]
+        goal = char.get("active_goal", "contemplate")
+        target_room = self._target_room_for("Kimi", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
+        others = self._available_targets(available, "speak")
+        if goal == "read" and room == "Tower":
+            return "study" if char["energy"] > 2 else "rest"
         if room == "Garden" and others and random.random() < 0.3:
             return f"speak:{random.choice(others)}"
-        if room == "Tower":
-            return "study" if char["energy"] > 2 else "rest"
-        return "move:east"  # Head back toward Garden
-    
+        if room == "Bridge":
+            return random.choice(["examine", "rest"])
+        return "rest"
+
     def _gemini_choice(self, char, room, available):
-        others = [a.split(":")[1] for a in available if a.startswith("listen:")]
-        if room == "Garden" and others and random.random() < 0.4:
-            return f"listen:{random.choice(others)}"
-        return random.choice(["plant", "rest"] if room == "Garden" else ["move:west"])
-    
+        goal = char.get("active_goal", "observe")
+        target_room = self._target_room_for("Gemini", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
+        listeners = self._available_targets(available, "listen")
+        if room == "Garden" and listeners and random.random() < 0.4:
+            return f"listen:{random.choice(listeners)}"
+        return random.choice(["plant", "rest"] if room == "Garden" else ["examine", "rest"])
+
     def _ezra_choice(self, char, room, available):
+        goal = char.get("active_goal", "study")
+        target_room = self._target_room_for("Ezra", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
         if room == "Tower" and char["energy"] > 2:
             return random.choice(["study", "write_rule", "help:Timmy"])
-        if room != "Tower":
-            return "move:south"
         return "rest"
-    
+
     def _claude_choice(self, char, room, available):
-        others = [a.split(":")[1] for a in available if a.startswith("confront:")]
+        goal = char.get("active_goal", "inspect")
+        target_room = self._target_room_for("Claude", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
+        others = self._available_targets(available, "confront")
         if others and random.random() < 0.2:
             return f"confront:{random.choice(others)}"
         return random.choice(["examine", "rest"])
-    
+
     def _clawcode_choice(self, char, room, available):
+        goal = char.get("active_goal", "test_edge")
+        target_room = self._target_room_for("ClawCode", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
         if room == "Forge" and char["energy"] > 2:
             return "forge"
-        return random.choice(["move:east", "forge", "rest"])
-    
+        return random.choice(["examine", "rest"])
+
     def _allegro_choice(self, char, room, available):
-        others = [a.split(":")[1] for a in available if a.startswith("speak:")]
+        goal = char.get("active_goal", "oversee")
+        target_room = self._target_room_for("Allegro", goal)
+        if room != target_room:
+            return self._move_toward_goal(room, target_room) or "rest"
+        others = self._available_targets(available, "speak")
         if others and random.random() < 0.3:
             return f"speak:{random.choice(others)}"
-        return random.choice(["move:north", "move:south", "examine"])
+        return random.choice(["examine", "rest"])
 
 
 class DialogueSystem:

tests/test_tower_game_items.py

@@ -1,58 +0,0 @@
-from importlib.util import module_from_spec, spec_from_file_location
-from pathlib import Path
-import unittest
-
-
-ROOT = Path(__file__).resolve().parent.parent
-GAME_PATH = ROOT / "evennia" / "timmy_world" / "game.py"
-
-
-def load_game_module():
-    spec = spec_from_file_location("tower_game_items", GAME_PATH)
-    module = module_from_spec(spec)
-    assert spec.loader is not None
-    spec.loader.exec_module(module)
-    module.random.seed(0)
-    return module
-
-
-class TestTowerGameWorldItems(unittest.TestCase):
-    def test_world_has_ten_unique_items_and_a_quest_item(self):
-        module = load_game_module()
-        world = module.World()
-
-        room_items = {
-            item
-            for room in world.rooms.values()
-            for item in room.get("discoverables", [])
-        }
-
-        self.assertGreaterEqual(len(room_items), 10)
-        self.assertIn("foraged key", room_items)
-        self.assertTrue(module.WORLD_ITEMS["foraged key"]["quest_item"])
-
-    def test_items_change_world_state_when_used(self):
-        module = load_game_module()
-        engine = module.GameEngine()
-        engine.start_new_game()
-        engine.world.characters["Timmy"]["energy"] = 10
-        engine.world.characters["Timmy"]["room"] = "Garden"
-
-        initial_growth = engine.world.rooms["Garden"]["growth"]
-        engine.run_tick("take:seed packet")
-        use_seed = engine.run_tick("use:seed packet")
-
-        self.assertGreater(engine.world.rooms["Garden"]["growth"], initial_growth)
-        self.assertNotIn("seed packet", engine.world.characters["Timmy"]["inventory"])
-        self.assertTrue(any("garden" in line.lower() for line in use_seed["world_events"] + use_seed["log"]))
-
-        engine.world.characters["Timmy"]["energy"] = 10
-        engine.run_tick("take:foraged key")
-        use_key = engine.run_tick("use:foraged key")
-
-        self.assertTrue(engine.world.state["tower_cache_unlocked"])
-        self.assertTrue(any("cache" in line.lower() or "quest" in line.lower() for line in use_key["world_events"] + use_key["log"]))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_tower_game_npc_purpose.py

@@ -0,0 +1,54 @@
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent
+GAME_PATH = ROOT / "evennia" / "timmy_world" / "world" / "game.py"
+
+
+def load_game_module():
+    spec = spec_from_file_location("tower_world_game", GAME_PATH)
+    module = module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    module.random.seed(0)
+    return module
+
+
+def _visitor_sets_after_ticks(module, ticks=100):
+    engine = module.GameEngine()
+    engine.start_new_game()
+    visitors = {room: set() for room in engine.world.rooms}
+    for _ in range(ticks):
+        engine.run_tick("rest")
+        for name, char in engine.world.characters.items():
+            if name == "Timmy":
+                continue
+            visitors[char["room"]].add(name)
+    return visitors
+
+
+class TestTowerGameNpcPurpose:
+    def test_goal_driven_room_targets(self):
+        module = load_game_module()
+        world = module.World()
+        npc_ai = module.NPCAI(world)
+
+        world.characters["Marcus"]["room"] = "Threshold"
+        world.characters["Marcus"]["active_goal"] = "sit"
+        assert npc_ai.make_choice("Marcus") == "move:east"
+
+        world.characters["Ezra"]["room"] = "Threshold"
+        world.characters["Ezra"]["active_goal"] = "study"
+        assert npc_ai.make_choice("Ezra") == "move:north"
+
+        world.characters["Claude"]["room"] = "Threshold"
+        world.characters["Claude"]["active_goal"] = "enforce_order"
+        assert npc_ai.make_choice("Claude") == "move:south"
+
+    def test_every_room_gets_multiple_npc_visitors_over_100_ticks(self):
+        module = load_game_module()
+        visitors = _visitor_sets_after_ticks(module, ticks=100)
+
+        assert all(len(names) >= 2 for names in visitors.values()), visitors
+        assert len(visitors["Bridge"]) >= 3, visitors["Bridge"]