Delete ui/demo_roam.py

ui/demo_roam.py

@@ -1,254 +0,0 @@
-"""
-demo_roam.py — Myco autonomous roaming demo.
-
-Myco walks the 3x3 grid by itself, spawning mushrooms and reacting to them.
-The LLM (engine._llm) is only called for narration, NOT for movement decisions.
-All movement and game logic is pure Python.
-
-Run:  python demo_roam.py
-"""
-
-import threading
-import time
-import random
-import copy
-import gradio as gr
-from typing import Any, cast
-
-from ui.renderers import (
-    forest_scene, dex_markdown, game_status_markdown,
-    mushroom_card, progress_markdown, EMPTY_DEX,
-)
-from game.engine import (
-    discover_mushroom, collect_current, study_current,
-    _is_poisonous, _score_collection,
-)
-from game.state import welcome_history
-
-# ---------------------------------------------------------------------------
-# Shared roam state — all mutations go through _STATE_LOCK
-# ---------------------------------------------------------------------------
-_STATE_LOCK = threading.Lock()
-
-STATE = {
-    "position":        (1, 1),
-    "current":         None,        # active mushroom dict
-    "active_mushrooms": [],          # list of mushroom dicts with mush_x, mush_y
-    "collection":      [],
-    "history":         list(welcome_history()),
-    "thought":         "The forest is waking up...",
-    "score":           0,
-    "health":          3,
-    "ticks":           0,
-    "visited":         set(),
-}
-
-POISONOUS = {"Ghost Gill", "Pepper Pixie", "Ruby Knuckle", "Clockwork Chanterelle"}
-
-# ---------------------------------------------------------------------------
-# Pure Python roam logic — NO LLM decisions
-# ---------------------------------------------------------------------------
-
-def _next_pos(x, y, visited):
-    candidates = []
-    for dx, dy in [(0,-1),(0,1),(-1,0),(1,0)]:
-        nx, ny = x+dx, y+dy
-        if 0 <= nx <= 2 and 0 <= ny <= 2:
-            weight = 1 if (nx,ny) in visited else 4
-            candidates.extend([(nx,ny)] * weight)
-    return random.choice(candidates) if candidates else (x, y)
-
-
-def _roam_tick():
-    """One autonomous tick — pure Python decision, optional LLM narration."""
-    with _STATE_LOCK:
-        x, y       = STATE["position"]
-        collection = list(STATE["collection"])
-        current    = STATE["current"]
-        mushrooms  = list(STATE["active_mushrooms"])
-        visited    = set(STATE["visited"])
-        ticks      = STATE["ticks"]
-        STATE["ticks"] += 1
-
-    # --- Decision logic ---
-    action = "move"
-
-    # If there's a mushroom at our position
-    at_pos = [m for m in mushrooms if int(m.get("mush_x",-1)) == x
-                                   and int(m.get("mush_y",-1)) == y
-                                   and m.get("picked") != "Yes"]
-    if at_pos:
-        m = at_pos[0]
-        if m.get("poison") == "Yes":
-            action = "flee"       # move away from poison
-        elif m.get("studied") != "Yes":
-            action = "study"
-        else:
-            action = "collect"
-
-    # If clearing is empty and we haven't searched here recently
-    elif (x, y) not in visited or ticks % 6 == 0:
-        action = "search"
-
-    # --- Execute ---
-    new_current  = current
-    new_mushrooms = mushrooms
-    new_collection = collection
-    new_history  = STATE["history"]
-    thought      = STATE["thought"]
-
-    if action == "move" or action == "flee":
-        nx, ny = _next_pos(x, y, visited)
-        with _STATE_LOCK:
-            STATE["position"] = (nx, ny)
-            STATE["visited"].add((nx, ny))
-        return
-
-    if action == "search":
-        try:
-            mushroom, new_current, new_history = discover_mushroom(collection)
-            # Assign a grid position for the roaming sprite
-            new_current["mush_x"] = x
-            new_current["mush_y"] = y
-            new_current["picked"] = "No"
-            new_mushrooms = [m for m in mushrooms if not (
-                int(m.get("mush_x",-1)) == x and int(m.get("mush_y",-1)) == y
-            )] + [new_current]
-            thought = f"Found {new_current.get('name','?')}! 🍄"
-        except Exception as e:
-            thought = "Something stirs in the moss..."
-
-    elif action == "study":
-        try:
-            studied_current, new_history = study_current(at_pos[0], STATE["history"])
-            if studied_current:
-                new_mushrooms = [studied_current if (
-                    m.get("name") == at_pos[0].get("name")
-                ) else m for m in mushrooms]
-                new_current = studied_current
-                thought = f"Studied {studied_current.get('name','?')}. ✨"
-        except Exception as e:
-            thought = "Myco examines the mushroom carefully..."
-
-    elif action == "collect":
-        try:
-            new_collection, new_history = collect_current(at_pos[0], collection, STATE["history"])
-            # Mark as picked in the mushrooms list
-            new_mushrooms = [
-                {**m, "picked": "Yes"} if m.get("name") == at_pos[0].get("name") else m
-                for m in mushrooms
-            ]
-            new_current = {**at_pos[0], "picked": "Yes"}
-            thought = f"Collected {at_pos[0].get('name','?')}! +{at_pos[0].get('score_delta','?')} spores 🎉"
-        except Exception as e:
-            thought = "Added to the MycoDex..."
-
-    # Move after acting
-    nx, ny = _next_pos(x, y, visited)
-
-    with _STATE_LOCK:
-        STATE["position"]          = (nx, ny)
-        STATE["visited"].add((nx, ny))
-        STATE["current"]           = new_current
-        STATE["active_mushrooms"]  = [m for m in new_mushrooms if m.get("picked") != "Yes"]
-        STATE["collection"]        = new_collection
-        STATE["history"]           = new_history[-20:] if new_history else []
-        STATE["thought"]           = thought
-
-
-def _roam_loop(interval=3.0):
-    while True:
-        try:
-            _roam_tick()
-        except Exception as e:
-            print(f"[Roam] tick error: {e}")
-        time.sleep(interval)
-
-
-def start_roaming(interval=3.0):
-    t = threading.Thread(target=_roam_loop, args=(interval,), daemon=True)
-    t.start()
-    print("[Roam] Myco is now roaming autonomously.")
-
-
-# ---------------------------------------------------------------------------
-# Gradio poll functions
-# ---------------------------------------------------------------------------
-
-def poll_scene():
-    with _STATE_LOCK:
-        pos       = STATE["position"]
-        current   = STATE["current"]
-        mushrooms = list(STATE["active_mushrooms"])
-        coll      = list(STATE["collection"])
-    return forest_scene(current, coll, pos, active_mushrooms=mushrooms)
-
-
-def poll_status():
-    with _STATE_LOCK:
-        pos     = STATE["position"]
-        current = STATE["current"]
-        coll    = list(STATE["collection"])
-    return game_status_markdown(current, coll, pos)
-
-
-def poll_thought():
-    with _STATE_LOCK:
-        return STATE["thought"]
-
-
-def poll_dex():
-    with _STATE_LOCK:
-        coll = list(STATE["collection"])
-    return dex_markdown(coll) if coll else EMPTY_DEX
-
-
-def poll_progress():
-    with _STATE_LOCK:
-        coll = list(STATE["collection"])
-    return progress_markdown(coll)
-
-
-# ---------------------------------------------------------------------------
-# Gradio UI
-# ---------------------------------------------------------------------------
-
-def build_roam_demo():
-    start_roaming(interval=3.0)
-
-    with gr.Blocks(title="Myco — Autonomous Roam Demo") as demo:
-        gr.HTML("""
-        <style>
-            .gradio-container { background: #1a1a2e !important; color: #f0ffe0; }
-            .progress-level, .progress-level-inner { display: none !important; }
-        </style>
-        """)
-
-        gr.Markdown("## 🍄 Myco — Autonomous Roam Demo")
-        gr.Markdown(
-            "Myco walks the 3×3 grid by itself every 3 seconds. "
-            "It searches clearings, studies mushrooms, and collects them — "
-            "all using pure Python logic. The LLM only adds narration text."
-        )
-
-        scene    = gr.HTML(poll_scene())
-        thought  = gr.Textbox(label="💬 Myco's thought", interactive=False, value=poll_thought())
-
-        with gr.Row():
-            status   = gr.Markdown(poll_status())
-            with gr.Column():
-                dex      = gr.Markdown(poll_dex())
-                progress = gr.Markdown(poll_progress())
-
-        # Poll every 1.5s — fast enough to feel live, not so fast it hammers the server
-        demo.load(fn=poll_scene,    outputs=scene,    every=1.5)
-        demo.load(fn=poll_status,   outputs=status,   every=1.5)
-        demo.load(fn=poll_thought,  outputs=thought,  every=1.5)
-        demo.load(fn=poll_dex,      outputs=dex,      every=3.0)
-        demo.load(fn=poll_progress, outputs=progress, every=3.0)
-
-    return demo
-
-if __name__ == "__main__":
-    demo = build_roam_demo()
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)