Deploy Myco from CI

game/demo_roam.py

@@ -0,0 +1,254 @@
+"""
+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, _move
+)
+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)