Deploy Myco from CI

game/agent_controller.py

@@ -1,4 +1,8 @@
-# controller.py — full replacement
+"""
+MycoController — autonomous AI agent that drives background game actions.
+The controller uses engine._llm() to decide what to do, then delegates
+execution to the same engine functions the player uses.
+"""
 
 from . import engine
 import json
@@ -7,71 +11,114 @@ import json
 class MycoController:
     def __init__(self):
         self.position = [1, 1]
-        self.history = []
+        self.history  = []
 
-    def get_agent_decision(self, current_mushroom, collection):
-        # Build a real context so _llm has score/health/mystery data.
-        # This also prevents the system prompt from having blank lines.
+    # ------------------------------------------------------------------
+    # Decision layer — ask Gemma what to do next
+    # ------------------------------------------------------------------
+    def get_agent_decision(self, current_mushroom, collection) -> dict:
+        # Build a full context so Gemma has score/health/mystery data.
         ctx = engine._ctx(current_mushroom, list(collection or []))
 
+        mushroom_line = (
+            f"There is a {current_mushroom.get('rarity','?')} mushroom called "
+            f"{current_mushroom.get('name','?')} in the clearing."
+            if current_mushroom
+            else "The clearing is empty."
+        )
+
         prompt = (
-            f"Current position: {self.position}. "
-            f"Mushroom present: {'Yes' if current_mushroom else 'No'}. "
+            f"You are Myco, an autonomous forest agent. "
+            f"Current position: {self.position}. {mushroom_line} "
             f"Collection count: {ctx.get('collection_count', 0)}. "
-            f"Score: {ctx.get('score', 0)}. Health: {ctx.get('health', 3)}/3. "
-            "Decide the next action: move, search, study, collect, or wait. "
-            "If move, provide a target coordinate. "
+            f"Score: {ctx.get('score', 0)} spores. Health: {ctx.get('health', 3)}/3. "
+            f"Mystery chapter: {ctx.get('mystery_title', 'The Wrong Memory')}. "
+            "Decide the single best next action from: move, search, study, collect, wait. "
+            "If the clearing is empty, prefer 'search'. "
+            "If a mushroom is present and unstudied, prefer 'study'. "
+            "If studied and safe, prefer 'collect'. "
+            "If move, pick an adjacent grid coordinate within [0,2] x [0,2]. "
             'Respond ONLY in valid JSON: {"action":"...","target":[x,y],"thought":"..."}'
         )
 
         response = engine._llm(prompt, ctx)
 
         if not response:
+            print("[Myco Controller] LLM returned no data — defaulting to wait.")
             return {"action": "wait", "target": None, "thought": "Engine returned no data."}
 
         try:
             parsed = json.loads(response)
-            # Validate the action field exists and is a known value
-            if parsed.get("action") not in {"move", "search", "study", "collect", "wait"}:
-                raise ValueError(f"Unknown action: {parsed.get('action')}")
+            action = parsed.get("action", "wait")
+            if action not in {"move", "search", "study", "collect", "wait"}:
+                raise ValueError(f"Unknown action: {action!r}")
             return parsed
-        except Exception as e:
-            print(f"[Myco] Controller parse error: {e} — raw: {response!r}")
+        except Exception as exc:
+            print(f"[Myco Controller] Parse error: {exc} — raw: {response!r}")
             return {"action": "wait", "target": None, "thought": "Failed to parse response."}
 
-    def run_tick(self, current_mushroom, collection):
+    # ------------------------------------------------------------------
+    # Execution layer — carry out the decision using engine functions
+    # ------------------------------------------------------------------
+    def run_tick(self, current_mushroom, collection) -> dict:
+        """
+        Run one autonomous tick. Returns a result dict with:
+          action_taken, thought, and optionally data (new current/collection).
+        This is the ONLY entry point the UI should call — it keeps controller
+        state (self.history, self.position) in sync.
+        """
         decision = self.get_agent_decision(current_mushroom, collection)
-        action = decision.get("action", "wait")
-        result = {"action_taken": action, "thought": decision.get("thought", "")}
+        action   = decision.get("action", "wait")
+        result   = {
+            "action_taken": action,
+            "thought":      decision.get("thought", ""),
+            "data":         {},
+        }
 
         if action == "move":
             target = decision.get("target")
             if isinstance(target, list) and len(target) == 2:
-                self.position = target
+                x = max(0, min(2, int(target[0])))
+                y = max(0, min(2, int(target[1])))
+                self.position = [x, y]
+                result["data"]["position"] = self.position
             else:
-                result["thought"] = "Move action had no valid target coordinate."
+                result["thought"] = "Move had no valid target — staying put."
 
         elif action == "search":
-            mushroom, current, history = engine.discover_mushroom(collection)
-            result["data"] = {"mushroom": mushroom, "current": current}
+            mushroom, current, history = engine.discover_mushroom(list(collection or []))
+            self.history = history
+            result["data"] = {
+                "mushroom": mushroom,
+                "current":  current,
+                "history":  history,
+            }
+
+        elif action == "study":
+            if current_mushroom:
+                reply, history = engine.study_current(current_mushroom, self.history)
+                self.history   = history
+                result["data"] = {
+                    "study_reply": reply,
+                    "history":     history,
+                }
+            else:
+                result["thought"] = "Nothing to study — clearing is empty."
 
         elif action == "collect":
             if current_mushroom:
-                coll, hist = engine.collect_current(
+                coll, history  = engine.collect_current(
                     current_mushroom, list(collection or []), self.history
                 )
-                self.history = hist
-                result["data"] = {"collection": coll}
+                self.history   = history
+                result["data"] = {
+                    "collection": coll,
+                    "history":    history,
+                }
             else:
-                result["thought"] = "Nothing to collect — no mushroom in clearing."
+                result["thought"] = "Nothing to collect — clearing is empty."
 
-        elif action == "study":
-            if current_mushroom:
-                reply, hist = engine.study_current(current_mushroom, self.history)
-                self.history = hist
-                result["data"] = {"study_reply": reply}
-            else:
-                result["thought"] = "Nothing to study."
+        # action == "wait" needs no execution
 
         return result