Delete game/not--engine.py

game/not--engine.py

@@ -1,808 +0,0 @@
-"""
-Core Myco gameplay — LLM is the primary game engine.
-"""
-import os
-import re
-import random
-import threading
-import traceback
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-# Local imports
-from game.catalog import load_mushrooms
-from game.state import collection_contains, welcome_history
-
-# Global singletons
-DEFAULT_MODEL_ID = "google/gemma-3-1b-it"
-_model = None
-_tokenizer = None
-_lock = threading.Lock()
-
-# Define device (CPU by default)
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"[Myco] Engine initializing on: {DEVICE.upper()}")
-
-def _get_model_and_tokenizer():
-    global _model, _tokenizer
-    if _model is not None and _tokenizer is not None:
-        return _model, _tokenizer
-
-    with _lock:
-        if _model is not None and _tokenizer is not None:
-            return _model, _tokenizer
-
-        model_id = os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
-        token = os.getenv("HF_BUILD_SMALL_HACKATHON_TOKEN")
-
-        try:
-            print(f"[Myco] Loading model: {model_id}...")
-            _tokenizer = AutoTokenizer.from_pretrained(model_id, token=token)
-            
-            # Load with CPU-safe settings
-            _model = AutoModelForCausalLM.from_pretrained(
-                model_id,
-                token=token,
-                torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
-                device_map=DEVICE,
-                trust_remote_code=True
-            )
-            return _model, _tokenizer
-        except Exception as exc:
-            print(f"[Myco] Load error: {exc}")
-            return None, None
-
-
-def _get_pipeline():
-    """Bridge function to resolve NameError for the pipeline."""
-    model, tokenizer = _get_model_and_tokenizer()
-    return model
-
-
-def _run_pipeline(pipe_ignored, messages):
-    """Handles inference on the active device (CPU or GPU)."""
-    model, tokenizer = _get_model_and_tokenizer()
-    if model is None:
-        return "The forest is silent. (Model loading failed)"
-
-    formatted_prompt = tokenizer.apply_chat_template(
-        messages, tokenize=False, add_generation_prompt=True
-    )
-
-    inputs = tokenizer(formatted_prompt, return_tensors="pt").to(DEVICE)
-
-    with torch.no_grad():
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=256,
-            do_sample=True,
-            temperature=0.7,
-            pad_token_id=tokenizer.eos_token_id
-        )
-
-    input_length = inputs.input_ids.shape[1]
-    generated_tokens = outputs[0][input_length:]
-    return tokenizer.decode(generated_tokens, skip_special_tokens=True)
-
-
-# --- Ensure you have this global list accessible in engine.py ---
-POISONOUS_MUSHROOM_NAMES = {
-    "Ghost Gill", "Pepper Pixie", "Ruby Knuckle", "Clockwork Chanterelle",
-}
-
-# ---------------------------------------------------------------------------
-# Template Helper (Fixes the Gemma TemplateError)
-# ---------------------------------------------------------------------------
-def _format_messages_for_template(system_prompt: str, user_prompt: str, history_turns: list = None) -> list:
-    """
-    Formats messages securely for models with strict chat templates (like Gemma).
-    - Starts the conversation with a 'user' turn containing the system prompt.
-    - Maps 'assistant' role tags directly to 'model'.
-    - Implements alternative processing to merge consecutive same-role text blocks.
-    """
-    # Gemma doesn't support the 'system' role, so we inject it as the first 'user' prompt
-    raw_turns = [{"role": "user", "content": system_prompt}]
-    
-    if history_turns:
-        for entry in history_turns:
-            role = entry.get("role", "assistant")
-            if role == "assistant":
-                role = "model"
-            elif role == "system":
-                continue # Strip extraneous system tags
-            
-            content = entry.get("content", "")
-            if isinstance(content, str) and content.strip():
-                raw_turns.append({"role": role, "content": content})
-                
-    # Add the current payload action
-    raw_turns.append({"role": "user", "content": user_prompt})
-    
-    # Deduplicate consecutive roles (guarantees perfect strict user/model rotation)
-    alternated_turns = []
-    for turn in raw_turns:
-        if alternated_turns and alternated_turns[-1]["role"] == turn["role"]:
-            alternated_turns[-1]["content"] += f"\n\n{turn['content']}"
-        else:
-            alternated_turns.append(turn)
-            
-    return alternated_turns
-
-# ---------------------------------------------------------------------------
-# Game Constants
-# ---------------------------------------------------------------------------
-JSON_PROMPT_SUFFIX = (
-    "\n\nRespond with a single JSON object only. No prose before or after it. "
-    'Example: {"action":"pick","target":"Ruby Knuckle","thought":"It seems safe."}'
-)
-
-RARITY_WEIGHTS = {"Common": 64, "Rare": 24, "Legendary": 8}
-RARITY_SCORE   = {"Common": 10, "Rare": 35, "Legendary": 100}
-PLAYER_HEALTH  = 3
-POISON_PENALTY = -25
-POISONOUS      = {"Ghost Gill", "Pepper Pixie", "Ruby Knuckle", "Clockwork Chanterelle"}
-
-SYSTEM_PROMPT = """You are Myco, a tiny sentient mushroom companion and forest guide.
-You are curious, warm, slightly anxious about poisonous mushrooms, and deeply connected
-to the forest mystery. You speak in short, vivid sentences. You never break character.
-You react emotionally to discoveries — with awe for Legendary mushrooms, caution for
-poisonous ones, and gentle wonder for Common ones. You hint at the deeper mystery of
-the vanished forest and the MycoDex that seems to remember things it shouldn't."""
-
-FOREST_EVENTS = [
-    {"title": "A Quiet Clearing",   "emoji": "🌿", "mood": "calm"},
-    {"title": "Wind Between Trees", "emoji": "🕯️", "mood": "afraid"},
-]
-
-MYSTERY_CHAPTERS = [
-    {"threshold": 0, "title": "The Wrong Memory",    "clue": "Myco recognises the path before you move."},
-    {"threshold": 1, "title": "The Traveler's Song", "clue": "A stranger's lullaby appears in the MycoDex margin."},
-    {"threshold": 2, "title": "The Door Under Roots","clue": "Rare spores point to a door nobody built."},
-    {"threshold": 3, "title": "The MycoDex Seed",    "clue": "The MycoDex grows warm like a living cap."},
-    {"threshold": 5, "title": "The Impossible Bloom","clue": "The Impossible Mushroom was never outside the book."},
-]
-
-RARITY_CLUES = {
-    "Common":    "The cap leans toward the path, like it wants to be remembered.",
-    "Rare":      "Silver spores circle it in a pattern only old forest stories describe.",
-    "Legendary": "The whole clearing goes quiet — this mushroom hides part of the Elder Map.",
-}
-
-
-# ---------------------------------------------------------------------------
-# Utility: extract JSON or return text
-# ---------------------------------------------------------------------------
-def _extract_json_or_text(generated_text: str) -> str | None:
-    if not generated_text:
-        return None
-    text = str(generated_text).strip()
-
-    simple_matches = re.findall(r"\{.*?\}|\[.*?\]", text, flags=re.DOTALL)
-    if simple_matches:
-        for candidate in reversed(simple_matches):
-            try:
-                parsed = json.loads(candidate)
-                return json.dumps(parsed, separators=(",", ":"), ensure_ascii=False)
-            except Exception:
-                continue
-
-    return text or None
-
-
-# ---------------------------------------------------------------------------
-# Status
-# ---------------------------------------------------------------------------
-def companion_model_id():
-    return os.getenv("MYCO_MODEL_ID", DEFAULT_MODEL_ID)
-
-
-def companion_status():
-    pipe  = _get_pipeline()
-    model = companion_model_id()
-    if pipe:
-        return f"🧠 Myco AI active ({model})"
-    return f"⚠️ Myco AI fallback mode ({model} failed)"
-
-
-def hf_companion_status():
-    return companion_status()
-
-
-# ---------------------------------------------------------------------------
-# LLM call — single-turn
-# ---------------------------------------------------------------------------
-def _llm(prompt: str, context: dict | None = None) -> str | None:
-    pipe = _get_pipeline()
-    if not pipe:
-        return None
-
-    ctx = context or {}
-    mushroom_line = ""
-    if ctx.get("name"):
-        poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS else ""
-        mushroom_line = (
-            f"Current mushroom: {ctx['name']} ({ctx.get('rarity','?')} rarity){poison_flag}. "
-            f"Habitat: {ctx.get('habitat','?')}. Lore: {ctx.get('lore','?')}. "
-            f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}. "
-            f"Danger: {ctx.get('danger','Unknown')}."
-        )
-
-    collection_line = f"MycoDex entries: {ctx.get('collection_count', 0)}."
-    mystery_line    = f"Active mystery chapter: {ctx.get('mystery_title', 'The Wrong Memory')}."
-    score_line      = f"Player score: {ctx.get('score', 0)} spores. Health: {ctx.get('health', 3)}/3."
-
-    system = f"{SYSTEM_PROMPT}\n\n{mushroom_line}\n{collection_line}\n{mystery_line}\n{score_line}"
-
-    # Safe layout handling for strict model templates
-    messages = _format_messages_for_template(system, prompt + JSON_PROMPT_SUFFIX)
-
-    try:
-        outputs = _run_pipeline(pipe, messages)
-        print("========== MYCO OUTPUT ==========")
-        print(outputs)
-        print("=================================")
-
-        if isinstance(outputs, list) and outputs:
-            first     = outputs[0]
-            generated = first.get("generated_text", "") if isinstance(first, dict) else str(first)
-        else:
-            generated = str(outputs)
-
-        if isinstance(generated, list):
-            last = generated[-1]
-            text = last.get("content") if isinstance(last, dict) else str(last)
-        else:
-            text = str(generated)
-
-        return _extract_json_or_text(text)
-    except Exception as exc:
-        print(f"[Myco] Inference error: {exc}")
-        traceback.print_exc()
-        return None
-
-
-# ---------------------------------------------------------------------------
-# LLM call — multi-turn chat
-# ---------------------------------------------------------------------------
-def _llm_with_history(history: list, user_message: str, context: dict) -> str | None:
-    """Chat function with strict ANTI-JSON guardrails."""
-    pipe = _get_pipeline()
-    if not pipe:
-        return None
-
-    ctx           = context or {}
-    mushroom_line = ""
-    if ctx.get("name"):
-        poison_flag   = " ⚠️ POISONOUS" if ctx.get("name") in POISONOUS_MUSHROOM_NAMES else ""
-        mushroom_line = (
-            f"Current mushroom: {ctx['name']} ({ctx.get('rarity','?')}){poison_flag}. "
-            f"Lore: {ctx.get('lore','?')}. "
-            f"Edible: {ctx.get('edible','Unknown')}. Magic: {ctx.get('magic','Unknown')}."
-        )
-
-    # The new strict anti-JSON prompt
-    system = (
-        f"{SYSTEM_PROMPT}\n\n"
-        f"{mushroom_line}\n"
-        f"MycoDex entries: {ctx.get('collection_count', 0)}. "
-        f"Mystery: {ctx.get('mystery_title', 'The Wrong Memory')}. "
-        f"Score: {ctx.get('score', 0)} spores. Health: {ctx.get('health', 3)}/3.\n\n"
-        "--- CRITICAL CHAT INSTRUCTION ---\n"
-        "You are chatting organically with the player. Speak ONLY in regular text dialogue.\n"
-        "❌ DO NOT output any JSON structures, game actions, keys, or thoughts blocks (like {\"action\": ...}).\n"
-        "❌ NEVER wrap your dialogue in a ```json markdown block.\n"
-        "Just talk to them like a supportive mushroom companion!"
-    )
-
-    messages = _format_messages_for_template(system, user_message, history[-6:])
-
-    try:
-        reply = _run_pipeline(pipe, messages)
-        print("========== MYCO OUTPUT ==========")
-        print(reply)
-        print("=================================")
-        return reply
-    except Exception as exc:
-        print(f"[Myco] Inference error: {exc}")
-        traceback.print_exc()
-        return None
-
-
-# ---------------------------------------------------------------------------
-# Context builder
-# ---------------------------------------------------------------------------
-def _ctx(current: dict | None, collection: list) -> dict:
-    count   = len(collection)
-    chapter = MYSTERY_CHAPTERS[0]
-    for c in MYSTERY_CHAPTERS:
-        if count >= c["threshold"]:
-            chapter = c
-    score  = _score_collection(collection)
-    health = _health(current, collection)
-    ctx: dict = {
-        "collection_count": count,
-        "mystery_title":    chapter["title"],
-        "mystery_clue":     chapter["clue"],
-        "score":            score,
-        "health":           health,
-    }
-    if current:
-        ctx.update({
-            "name":    current.get("name", ""),
-            "rarity":  current.get("rarity", "Common"),
-            "habitat": current.get("habitat", ""),
-            "lore":    current.get("lore", ""),
-            "edible":  current.get("edible", "Unknown"),
-            "magic":   current.get("magic", "Unknown"),
-            "danger":  current.get("danger", "Unknown"),
-        })
-    return ctx
-
-
-# ---------------------------------------------------------------------------
-# Fallbacks
-# ---------------------------------------------------------------------------
-def _fallback_discover(current: dict) -> str:
-    name   = current.get("name", "something")
-    rarity = current.get("rarity", "Common")
-    poison = current.get("name", "") in POISONOUS
-    if poison:
-        return f"Wait — {name}! I've seen this before... something feels very wrong. Don't touch it yet."
-    if rarity == "Legendary":
-        return f"Oh! Oh! A {name}! The whole clearing just went silent. This is from the Elder Map!"
-    if rarity == "Rare":
-        return f"A {name}... I can feel it humming. Something rare is here — maybe magical."
-    return f"A {name}! Found near {current.get('habitat','the forest')}. Let me sense it first."
-
-
-def _fallback_pick(current: dict) -> str:
-    if _is_poisonous(current):
-        return "💀 That was poisonous! I tried to stop you... the forest goes dark."
-    return f"Got {current.get('name','it')}! +{RARITY_SCORE.get(current.get('rarity','Common'),10)} spores!"
-
-
-def _fallback_study(current: dict) -> str:
-    return f"I studied it carefully. Magic field updated. The clue: {RARITY_CLUES.get(current.get('rarity','Common'), '')}"
-
-
-def _fallback_collect(current: dict) -> str:
-    return f"Added {current.get('name','it')} to the MycoDex! The pages feel warmer."
-
-
-def _fallback_whisper(current: dict) -> str:
-    return "I followed the whisper... and remembered a path I've never walked. The mystery deepens."
-
-
-def _fallback_chat(current: dict | None) -> str:
-    if current:
-        return f"I feel something strange about {current.get('name','this')}... stay close to me."
-    return "The forest is full of secrets. Move to a clearing and search — I'll watch for danger."
-
-
-# ---------------------------------------------------------------------------
-# Mushroom helpers
-# ---------------------------------------------------------------------------
-def _choose_mushroom(catalog):
-    """Safely picks a mushroom, with a fallback if the catalog is empty."""
-    # 1. Ensure catalog is not empty
-    if not catalog:
-        print("CRITICAL: Mushroom catalog is empty! Using a fallback mushroom.")
-        # Create a simple fallback object if none exist
-        class FallbackMushroom:
-            def __init__(self):
-                self.name = "Common Moss Cap"
-                self.rarity = "common"
-                self.lore = "A simple mushroom that grew when the forest ran out of ideas."
-        return FallbackMushroom()
-
-    # 2. Safely get mushrooms and weights
-    mushrooms = list(catalog.values())
-    weights = [getattr(m, 'weight', 1.0) for m in mushrooms]
-    
-    # 3. Perform the choice
-    try:
-        return random.choices(mushrooms, weights=weights, k=1)[0]
-    except Exception as e:
-        print(f"Error in random.choices: {e}")
-        return mushrooms[0] # Return the first available as a last resort
-
-def _is_poisonous(current: dict) -> bool:
-    return current.get("name", "") in POISONOUS or current.get("danger") == "Poisonous"
-
-
-def _score_value(current: dict) -> int:
-    return RARITY_SCORE.get(current.get("rarity", "Common"), 10)
-
-
-def _score_collection(collection: list) -> int:
-    total = 0
-    for e in collection:
-        if e.get("game_over") == "Yes":
-            continue
-        total += int(e.get("score_delta") or _score_value(e))
-    return max(0, total)
-
-
-def _health(current: dict | None, collection: list) -> int:
-    if current and current.get("game_over") == "Yes":
-        return 0
-    deaths = sum(1 for e in collection if e.get("game_over") == "Yes")
-    return max(0, PLAYER_HEALTH - deaths)
-
-
-def _mystery_state(count: int) -> dict:
-    chapter, next_ch = MYSTERY_CHAPTERS[0], None
-    for c in MYSTERY_CHAPTERS:
-        if count >= c["threshold"]:
-            chapter = c
-        elif next_ch is None:
-            next_ch = c
-    next_line = (
-        f"{next_ch['threshold'] - count} discoveries until {next_ch['title']}."
-        if next_ch else "The Impossible Bloom is near. Follow the whisper."
-    )
-    return {
-        "mystery_title": chapter["title"],
-        "mystery_clue":  chapter["clue"],
-        "mystery_next":  next_line,
-    }
-
-
-def _story_event(count: int) -> dict:
-    return FOREST_EVENTS[count % len(FOREST_EVENTS)]
-
-
-def _build_current(mushroom, collection: list) -> dict:
-    count   = len(collection)
-    current = mushroom.to_dict()
-    current["poison"]      = "Yes" if mushroom.name in POISONOUS else "No"
-    current["score_total"] = str(_score_collection(collection))
-    current["health"]      = str(_health(current, collection))
-    current["score_delta"] = "0"
-    current["clue"]        = RARITY_CLUES.get(mushroom.rarity, RARITY_CLUES["Common"])
-    if count == 0:
-        current["clue"] = f"First clue: {mushroom.name} marks the beginning of the Spore Door trail."
-    event = _story_event(count)
-    current.update({
-        "event_title":  event["title"],
-        "event_emoji":  event["emoji"],
-        "myco_mood":    event["mood"],
-        "reward_text":  "Discover, then pick or collect.",
-    })
-    current.update(_mystery_state(count))
-    return current
-
-
-def _append(history: list, role: str, content: str) -> list:
-    return [*history, {"role": role, "content": content}]
-
-
-def _safe_history(h) -> list:
-    return list(h or welcome_history())
-
-
-def _safe_collection(c) -> list:
-    return list(c or [])
-
-
-# ---------------------------------------------------------------------------
-# Public game actions
-# ---------------------------------------------------------------------------
-def discover_mushroom(catalog):
-    """Instantly spawns 2-4 mushrooms with robust fallback fields to prevent UI crashes."""
-    num_mushrooms = random.randint(2, 4)
-    active_mushrooms = []
-    used_tiles = set()
-    
-    # Keep track of the last mushroom instance so we can return a valid object 
-    # to any legacy code expecting a real mushroom instance
-    last_mushroom_obj = None 
-    
-    for _ in range(num_mushrooms):
-        mushroom = _choose_mushroom(catalog)
-        last_mushroom_obj = mushroom
-        
-        mush_x, mush_y = random.randint(0, 2), random.randint(0, 2)
-        while (mush_x, mush_y) in used_tiles:
-            mush_x, mush_y = random.randint(0, 2), random.randint(0, 2)
-        used_tiles.add((mush_x, mush_y))
-        
-        # We fill EVERY possible key that dex_markdown or status bars might read
-        active_mushrooms.append({
-            "name": mushroom.name,
-            "rarity": mushroom.rarity,
-            "habitat": getattr(mushroom, "habitat", "Glow Undergrowth"),
-            "lore": getattr(mushroom, "lore", "A rapid micro-sprout spawned during a bloom."),
-            "edible": getattr(mushroom, "edible", "Unknown"),
-            "magic": getattr(mushroom, "magic", "Unknown"),
-            "danger": getattr(mushroom, "danger", "Unknown"),
-            "poison": "Yes" if mushroom.name in POISONOUS_MUSHROOM_NAMES else "No",
-            "mush_x": mush_x,
-            "mush_y": mush_y,
-            "picked": "No",
-            "clue": "Harvested instantly!",
-            "studied": "No"
-        })
-        
-    # Build a current state dictionary packed with fallback HUD variables
-    current = {
-        "name": "Mushroom Patch",
-        "rarity": "Multiple",
-        "poison": "No",
-        "active_mushrooms": active_mushrooms,
-        "game_over": "No",
-        "picked": "No",
-        "studied": "No",
-        "encounter": f"Boom! {num_mushrooms} mushrooms sprouted! Move Myco to collect them!",
-        "event_title": "Spore Influx",
-        "event_emoji": "✨",
-        "mystery_title": "The Wrong Memory",
-        "score_total": "0",
-        "health": "3",
-        "reward_text": "Run around the map to clear the board!"
-    }
-    
-    # Return the real mushroom object instead of None to prevent 'NoneType' errors
-    return last_mushroom_obj, current, []
-
-
-def myco_reply(message=None, history=None, current=None, collection=None, position=None):
-    """Player chats with Myco. LLM responds in character with full context."""
-    print("MYCO_REPLY CALLED, message:", repr(message))
-    hist  = _safe_history(history)
-    coll  = _safe_collection(collection)
-    clean = (message or "").strip()
-    if not clean:
-        return "", hist
-
-    ctx   = _ctx(current, coll)
-    reply = _llm_with_history(hist, clean, ctx)
-    if not reply:
-        reply = _fallback_chat(current)
-
-    return "", _append(hist, "user", clean) + [{"role": "assistant", "content": reply}]
-
-
-companion_reply = myco_reply
-
-
-def collect_current(current=None, collection=None, history=None):
-    """Collect mushroom into MycoDex. LLM narrates the entry."""
-    coll = _safe_collection(collection)
-    hist = _safe_history(history)
-
-    if current is None:
-        return coll, _append(hist, "assistant", "We need to find a mushroom first!")
-
-    if collection_contains(coll, current["name"]):
-        return coll, _append(hist, "assistant", f"{current['name']} is already in the MycoDex!")
-
-    score_delta  = _score_value(current)
-    score_total  = _score_collection(coll) + score_delta
-    collected    = {
-        **current,
-        "score_delta": str(score_delta),
-        "score_total": str(score_total),
-        "health":      str(_health(current, coll)),
-        "reward_text": f"+{score_delta} spores",
-    }
-    updated_coll = [*coll, collected]
-    ctx          = _ctx(current, coll)
-
-    prompt = (
-        f"The player just added {current['name']} ({current.get('rarity','Common')}) to the MycoDex! "
-        f"+{score_delta} spores. Total score: {score_total}. "
-        f"MycoDex now has {len(updated_coll)} entries. "
-        "Celebrate this moment. Add a small lore detail or mystery hint."
-    )
-    reply = _llm(prompt, ctx) or _fallback_collect(current)
-    return updated_coll, _append(hist, "assistant", reply)
-
-
-def pick_current(current=None, collection=None, history=None):
-    """Pick mushroom as game item. Poison = game over. LLM narrates dramatically."""
-    coll = _safe_collection(collection)
-    hist = _safe_history(history)
-
-    if current is None:
-        return coll, None, _append(hist, "assistant", "Find a mushroom first before picking!")
-
-    ctx = _ctx(current, coll)
-
-    if _is_poisonous(current):
-        score_total = max(0, _score_collection(coll) + POISON_PENALTY)
-        game_over   = {
-            **current,
-            "danger":      "Poisonous",
-            "game_over":   "Yes",
-            "health":      "0",
-            "score_delta": str(POISON_PENALTY),
-            "score_total": str(score_total),
-            "reward_text": f"Poison! {POISON_PENALTY} spores · Game Over",
-        }
-        prompt = (
-            f"DRAMATIC MOMENT: The player picked {current['name']} which is POISONOUS! "
-            f"Game Over! Score drops by 25 to {score_total}. Health → 0. "
-            "React with shock, sadness, and a dramatic farewell. Make it memorable."
-        )
-        reply = _llm(prompt, ctx) or _fallback_pick(current)
-        return coll, game_over, _append(hist, "assistant", f"💀 {reply}")
-
-    score_delta  = _score_value(current)
-    score_total  = _score_collection(coll) + score_delta
-    picked       = {
-        **current,
-        "picked":      "Yes",
-        "danger":      "Safe",
-        "score_delta": str(score_delta),
-        "score_total": str(score_total),
-        "health":      str(_health(current, coll)),
-        "reward_text": f"+{score_delta} spores",
-    }
-
-    if collection_contains(coll, picked["name"]):
-        return coll, picked, _append(hist, "assistant", f"{picked['name']} already picked!")
-
-    updated_coll = [*coll, picked]
-    prompt = (
-        f"The player safely picked {current['name']} ({current.get('rarity','Common')})! "
-        f"+{score_delta} spores. Total: {score_total}. "
-        "Celebrate! Make it feel like a platformer power-up moment."
-    )
-    reply = _llm(prompt, ctx) or _fallback_pick(current)
-    return updated_coll, picked, _append(hist, "assistant", f"🍄 {reply}")
-
-
-def follow_whisper(current=None, collection=None, history=None):
-    """Follow the forest whisper. LLM reveals mystery fragments."""
-    coll = _safe_collection(collection)
-    hist = _safe_history(history)
-
-    if current is None:
-        return None, _append(hist, "assistant",
-            "Myco cups one ear. The forest only whispers near mushrooms — search a clearing first.")
-
-    ctx = _ctx(current, coll)
-
-    if _is_poisonous(current) and current.get("studied") != "Yes":
-        game_over = {
-            **current,
-            "danger":      "Poisonous",
-            "game_over":   "Yes",
-            "health":      "0",
-            "score_total": str(max(0, _score_collection(coll) + POISON_PENALTY)),
-        }
-        prompt = (
-            f"The player followed a whisper but it led to POISON from {current['name']}! Game Over! "
-            "React with horror and a haunting mystery revelation."
-        )
-        reply = _llm(prompt, ctx) or "💀 The whisper belonged to poison... Myco screams."
-        return game_over, _append(hist, "assistant", reply)
-
-    mystery = _mystery_state(len(coll) + 1)
-    prompt  = (
-        f"The player followed a forest whisper near {current.get('name','a mushroom')}. "
-        f"Mystery chapter revealed: {mystery['mystery_title']}. Clue: {mystery['mystery_clue']}. "
-        "Reveal this mystery fragment dramatically. "
-        "Make Myco gasp or tremble. Hint that the MycoDex is alive and regrowing the lost forest."
-    )
-    reply    = _llm(prompt, ctx) or _fallback_whisper(current)
-    revealed = {**current, **mystery, "whisper_followed": "Yes"}
-    return revealed, _append(hist, "assistant", f"🌌 {reply}")
-
-
-def study_current(current=None, history=None):
-    """Study mushroom. LLM gives a careful field observation."""
-    hist = _safe_history(history)
-
-    if current is None:
-        return None, _append(hist, "assistant", "Nothing to study yet — find a mushroom first!")
-
-    prompt = (
-        f"Study the mushroom {current.get('name','unknown')} carefully. "
-        "Provide a concise field observation and one hint about its magic or danger."
-    )
-    reply = _llm(prompt, _ctx(current, [])) or _fallback_study(current)
-    return reply, _append(hist, "assistant", reply)
-
-
-def eat_current(current=None, collection=None, history=None):
-    """Eating mushrooms raw is always blocked. This dynamic response is now fully driven by Myco AI."""
-    coll = _safe_collection(collection)
-    hist = _safe_history(history)
-
-    if current is None:
-        return coll, _append(hist, "assistant", "There's nothing here to eat!")
-
-    ctx = _ctx(current, coll)
-    prompt = (
-        f"The player is attempting to directly EAT the raw mushroom: {current.get('name','unknown')}. "
-        "This is highly forbidden, unsafe, and unidentified! React as Myco with absolute dynamic panic, "
-        "gently scold them in character for trying something so dangerous, and assertively tell them "
-        "they need to Study it instead of eating it!"
-    )
-    
-    # Classic static text fallback just in case inference drops
-    fallback_reply = (
-        f"No no no! {current.get('name','That')} could be dangerous raw! "
-        "I'll never let you eat an unidentified mushroom. Study it first!"
-    )
-    
-    reply = _llm(prompt, ctx) or fallback_reply
-    return coll, _append(hist, "assistant", reply)
-
-
-def check_auto_pickup(new_pos_x, new_pos_y, current, collection):
-    """Arcade collision rules that cleanly update score text safely."""
-    if not current or current.get("game_over") == "Yes" or current.get("picked") == "Yes":
-        return current, collection
-
-    mushrooms = current.get("active_mushrooms", [])
-    all_picked = True
-    
-    for m in mushrooms:
-        if m.get("picked") == "No":
-            # Check if Myco stepped on this coordinate
-            if new_pos_x == m["mush_x"] and new_pos_y == m["mush_y"]:
-                if m["poison"] == "Yes":
-                    current["game_over"] = "Yes"
-                    current["encounter"] = f"💀 Oh no! Myco stepped directly onto a toxic {m['name']}!"
-                    current["event_title"] = "Poison Shock!"
-                    return current, collection
-                else:
-                    m["picked"] = "Yes"
-                    current["encounter"] = f"💥 Blip! Collected a rare {m['name']}!"
-                    
-                    # Safely tick up scores inside the state without crashing types
-                    current_score = int(current.get("score_total", "0")) + 15
-                    current["score_total"] = str(current_score)
-                    current["reward_text"] = f"+15 Spores from {m['name']}!"
-                    
-                    collection.append(m)
-            else:
-                # This one hasn't been collected yet
-                all_picked = False
-                
-    if all_picked and mushrooms:
-        current["picked"] = "Yes"
-        current["encounter"] = "Area clear! Click Search Clearing to spawn the next cluster."
-        current["event_title"] = "Clearing Purified"
-        
-    return current, collection
-    
-
-# Myco narrative
-def get_myco_narrative(current=None):
-    # 1. Personality Prompt - Made more aggressive
-    prompt = (
-        "You are Myco, a tiny, emotional mushroom companion. "
-        "Speak in one or two short sentences about the forest. "
-        "ABSOLUTELY NO JSON. NO BRACKETS. NO THOUGHT BLOCKS. "
-        "Speak like a person, not a computer."
-    )
-    
-    context = {"name": current.get("name", "mystery"), "rarity": current.get("rarity", "common")} if current else {}
-    
-    # 2. Get the response
-    reply = _llm(prompt, context=context)
-    
-    if not reply:
-        return "The forest feels deep today... ✨"
-
-    # 3. Aggressive Clean-up: If it contains JSON, strip it away
-    # This regex removes anything inside {} or []
-    cleaned_reply = re.sub(r'\{.*\}|\[.*\]', '', reply)
-    
-    # Remove keys like "thought": or "thought"
-    cleaned_reply = re.sub(r'"thought":|thought:', '', cleaned_reply, flags=re.IGNORECASE)
-    
-    # Remove extra quotes and whitespace
-    cleaned_reply = cleaned_reply.replace('"', '').strip()
-    
-    # If the clean-up resulted in an empty string, fallback
-    if not cleaned_reply:
-        return "The forest feels deep today... ✨"
-
-    return cleaned_reply
-    
-