Deploy Myco from CI

game/engine.py

@@ -10,6 +10,12 @@ from game.state import collection_contains, mushroom_from_state, welcome_history
 
 DEFAULT_HF_MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
 HF_TOKEN_ENV_VARS = ("HF_TOKEN", "HF_API_TOKEN", "HF_BUILD_SMALL_HACKATHON_TOKEN")
+RARITY_WEIGHTS = {"Common": 64, "Rare": 24, "Legendary": 8}
+RARITY_CLUES = {
+    "Common": "The cap leans toward the path, like it wants to be remembered.",
+    "Rare": "Silver spores circle it in a pattern Myco has seen only in old forest stories.",
+    "Legendary": "The whole clearing goes quiet; this mushroom is hiding part of the Elder Map.",
+}
 
 
 def choose_mushroom(catalog=None):
@@ -17,15 +23,19 @@ def choose_mushroom(catalog=None):
     mushrooms = tuple(load_mushrooms() if catalog is None else catalog)
     if not mushrooms:
         raise ValueError("Myco needs at least one mushroom in the catalog.")
-    return random.choice(mushrooms)
+    weights = [RARITY_WEIGHTS.get(mushroom.rarity, 12) for mushroom in mushrooms]
+    return random.choices(mushrooms, weights=weights, k=1)[0]
 
 
 def discover_mushroom(collection=None, catalog=None):
     """Discover a mushroom and return the updated discovery state."""
     current_collection = _safe_collection(collection)
     mushroom = choose_mushroom(catalog)
+    discovery_count = len(current_collection)
     current = mushroom.to_dict()
-    message = _discovery_reaction(current, len(current_collection))
+    current["clue"] = _mystery_clue(current, discovery_count)
+    current["secret"] = _secret_signal(current, discovery_count)
+    message = _discovery_reaction(current, discovery_count)
     history = _append_assistant(welcome_history(), message)
     return mushroom, current, history
 
@@ -56,15 +66,17 @@ def _discovery_reaction(current, collection_count):
     mushroom = mushroom_from_state(current)
     prompt = (
         f"The player just discovered {mushroom.name}. "
-        "React as Myco and invite them to ask, study, collect, or avoid eating it."
+        f"Rarity: {mushroom.rarity}. Clue: {current.get('clue', 'No clue yet')}. "
+        "React as Myco, make the discovery feel mysterious, and invite them to ask, study, collect, or avoid eating it."
     )
     answer = _hf_companion_answer(prompt, current)
     if answer:
         return answer
 
     return (
-        f"We found a {mushroom.name}! Ask me about it, then decide whether to "
-        f"eat, collect, or study it. Your MycoDex has {collection_count} entries."
+        f"We found a {mushroom.name}! Myco kneels beside it and whispers: "
+        f"{current.get('clue', 'the forest is trying to tell us something')} "
+        f"Ask me about it, then Study or Collect. Your MycoDex has {collection_count} entries."
     )
 
 
@@ -138,7 +150,9 @@ def _hf_messages(message, current):
             f"Edible: {mushroom.edible}. "
             f"Magic: {mushroom.magic}. "
             f"Danger: {mushroom.danger}. "
-            f"Lore: {mushroom.lore}"
+            f"Lore: {mushroom.lore}. "
+            f"Clue: {current.get('clue', 'Unknown')}. "
+            f"Secret signal: {current.get('secret', 'Unknown')}"
         )
 
     return [
@@ -178,9 +192,10 @@ def collect_current(current=None, collection=None, history=None):
         )
 
     updated_collection = [*current_collection, current]
+    secret_note = current.get("secret", "The MycoDex pages rustle like leaves.")
     return updated_collection, _append_assistant(
         current_history,
-        f"Added {current['name']} to the MycoDex. Nice find!",
+        f"Added {current['name']} to the MycoDex. {secret_note} Keep exploring; the forest is arranging clues.",
     )
 
 
@@ -194,9 +209,11 @@ def study_current(current=None, history=None):
         )
 
     studied = {**current, "magic": _study_hint(current["rarity"]), "studied": "Yes"}
+    clue = studied.get("clue", "The clue is still forming in the moss.")
     message = (
         f"I studied the {current['name']} closely. New MycoDex note: "
-        f"magic is now marked as **{studied['magic']}**. Still no tasting without certainty!"
+        f"magic is now marked as **{studied['magic']}**. Clue: {clue} "
+        "Still no tasting without certainty!"
     )
     return studied, _append_assistant(current_history, message)
 
@@ -246,3 +263,29 @@ def _study_hint(rarity):
     if rarity == "Rare":
         return "Faint magical trace"
     return "Tiny spore shimmer"
+
+
+def _mystery_clue(current, collection_count):
+    """Return a clue that turns each discovery into a small mystery beat."""
+    rarity = current.get("rarity", "Common")
+    name = current.get("name", "this mushroom")
+    clue = RARITY_CLUES.get(rarity, RARITY_CLUES["Common"])
+    if collection_count == 0:
+        return f"First clue: {name} marks the beginning of the hidden Spore Door trail."
+    if rarity == "Legendary":
+        return f"Legendary clue: {name} reveals a glowing Elder Map fragment."
+    if rarity == "Rare":
+        return f"Rare clue: {name} points Myco toward a secret ring of mushrooms."
+    return clue
+
+
+def _secret_signal(current, collection_count):
+    """Return a memorable secret/reward hint for the MycoDex."""
+    rarity = current.get("rarity", "Common")
+    if rarity == "Legendary":
+        return "The MycoDex page blooms with a star-shaped seal."
+    if rarity == "Rare":
+        return "A silver margin note appears beside the sketch."
+    if collection_count + 1 in (1, 3, 7, 12):
+        return "A hidden path symbol flickers at the page corner."
+    return "The page smells faintly of rain and moss."

game/progression.py

@@ -12,6 +12,15 @@ class AreaUnlock:
     description: str
 
 
+@dataclass(frozen=True)
+class MysteryThread:
+    """A story clue revealed through exploration instead of generic XP."""
+
+    name: str
+    required_discoveries: int
+    clue: str
+
+
 AREA_UNLOCKS: tuple[AreaUnlock, ...] = (
     AreaUnlock("Mossy Trail", 0, "Myco's favorite beginner path, full of soft moss and gentle spores."),
     AreaUnlock("Crystal Grove", 10, "A glittering grove where rare caps grow beside singing stones."),
@@ -19,6 +28,13 @@ AREA_UNLOCKS: tuple[AreaUnlock, ...] = (
     AreaUnlock("Mushroom Elder", 50, "The hidden elder of the forest, waiting for a true MycoDex keeper."),
 )
 
+MYSTERY_THREADS: tuple[MysteryThread, ...] = (
+    MysteryThread("First Spore", 1, "A brown cap points toward an unseen door under the roots."),
+    MysteryThread("Whispering Ring", 3, "Three collected fungi form a ring that hums when Myco gets close."),
+    MysteryThread("Star Hollow", 7, "Rare mushrooms start leaving silver dust near the northern trees."),
+    MysteryThread("Elder Map", 12, "Legendary fungi reveal fragments of a map only Myco can read."),
+)
+
 
 def unlocked_areas(discovery_count: int) -> tuple[AreaUnlock, ...]:
     """Return every area unlocked by the current MycoDex count."""
@@ -36,3 +52,16 @@ def next_area(discovery_count: int) -> AreaUnlock | None:
         if discovery_count < area.required_discoveries:
             return area
     return None
+
+
+def revealed_mysteries(discovery_count: int) -> tuple[MysteryThread, ...]:
+    """Return story secrets revealed by the current MycoDex count."""
+    return tuple(thread for thread in MYSTERY_THREADS if discovery_count >= thread.required_discoveries)
+
+
+def next_mystery(discovery_count: int) -> MysteryThread | None:
+    """Return the next story secret the player is working toward."""
+    for thread in MYSTERY_THREADS:
+        if discovery_count < thread.required_discoveries:
+            return thread
+    return None

tests/test_myco_core.py

@@ -18,7 +18,7 @@ from game.engine import (
     hf_model_id,
     study_current,
 )
-from game.progression import current_area, next_area
+from game.progression import current_area, next_area, next_mystery, revealed_mysteries
 from ui.gradio_app import build_app, move_player
 from ui.renderers import (
     dex_markdown,
@@ -55,6 +55,8 @@ class MycoCoreTests(unittest.TestCase):
         self.assertEqual(history[0]["role"], "assistant")
         self.assertIn("forest-scene", scene)
         self.assertIn(mushroom.name, scene)
+        self.assertIn("clue", current)
+        self.assertIn("secret", current)
 
     def test_home_keeps_original_tree_and_mushroom_scene(self):
         home = home_forest_markdown()
@@ -212,6 +214,7 @@ class MycoCoreTests(unittest.TestCase):
 
         self.assertEqual(studied["studied"], "Yes")
         self.assertNotEqual(studied["magic"], "Unknown")
+        self.assertIn("Clue:", study_history[-1]["content"])
         self.assertIn("blocks", eat_history[-1]["content"])
 
     def test_movement_updates_forest_scene_position(self):
@@ -230,12 +233,18 @@ class MycoCoreTests(unittest.TestCase):
         self.assertIn(current["name"], dex_markdown([current]))
         self.assertIn("Forest Progress", progress_markdown([current]))
         self.assertIn("Forest Atlas", world_map_markdown([current]))
-        self.assertIn("First Find", world_map_markdown([current]))
+        self.assertIn("First Spore", world_map_markdown([current]))
         self.assertEqual(world_map_markdown([current]).count('class="map-card '), 4)
         self.assertIn("Quest Log", game_status_markdown(current, [current]))
+        self.assertIn("Mystery", game_status_markdown(current, [current]))
         self.assertIn(current["name"], game_status_markdown(current, [current]))
         self.assertEqual(current_area(0).name, "Mossy Trail")
         self.assertIsNotNone(next_area(0))
+        upcoming_mystery = next_mystery(0)
+        self.assertIsNotNone(upcoming_mystery)
+        assert upcoming_mystery is not None
+        self.assertEqual(upcoming_mystery.name, "First Spore")
+        self.assertEqual(revealed_mysteries(3)[-1].name, "Whispering Ring")
 
     def test_python_files_have_no_duplicate_functions_or_future_imports(self):
         future_import = "from __future__ import " + "annotations"

ui/gradio_app.py

@@ -35,8 +35,8 @@ HOME_MARKDOWN = """
 Myco is a tiny forest game portal. Open **🎮 Play** to search for mushrooms,
 visit **📖 MycoDex** to review progress, and use **🧭 Guide** for the loop.
 
-**Goal:** discover strange mushrooms, ask Myco what they might be, study them safely,
-and build a magical MycoDex collection.
+**Goal:** collect 3 mushroom clues to wake the Whispering Ring, then keep exploring for
+rare and legendary secrets that only Myco can interpret.
 """
 
 GUIDE_MARKDOWN = """
@@ -45,8 +45,8 @@ GUIDE_MARKDOWN = """
 1. Go to **🎮 Play**.
 2. Use the arrow buttons to move Myco around the 3x3 forest grid.
 3. Click **Explore the Forest** to reveal a mushroom in the current clearing.
-4. Ask Myco what it senses, then choose **Study**, **Collect**, or **Eat?**
-5. Check **📖 MycoDex** and **🗺️ World Map** to track discoveries and area unlocks.
+4. Ask Myco what it senses, then choose **Study** to reveal the clue or **Collect** to save it.
+5. Check **📖 MycoDex** and **🗺️ World Map** to track clues, secrets, and area unlocks.
 """
 
 
@@ -54,7 +54,11 @@ def mushroom_card_from_state(current):
     """Render a mushroom card from Gradio state."""
     if current is None:
         return mushroom_card(None)
-    return mushroom_card(Mushroom.from_dict(current))
+    return mushroom_card(
+        Mushroom.from_dict(current),
+        current.get("clue"),
+        current.get("secret"),
+    )
 
 
 def search_forest(collection, position):
@@ -64,7 +68,7 @@ def search_forest(collection, position):
     return (
         forest_scene(current, collection, player_position),
         game_status_markdown(current, collection, player_position),
-        mushroom_card(mushroom),
+        mushroom_card_from_state(current),
         current,
         history,
         dex_markdown(collection),

ui/renderers.py

@@ -2,7 +2,14 @@
 
 from html import escape
 
-from game.progression import AREA_UNLOCKS, current_area, next_area, unlocked_areas
+from game.progression import (
+    AREA_UNLOCKS,
+    current_area,
+    next_area,
+    next_mystery,
+    revealed_mysteries,
+    unlocked_areas,
+)
 from game.state import CollectionState, EMPTY_DEX, MushroomState
 from models.mushroom import Mushroom
 
@@ -40,13 +47,13 @@ def play_hook_markdown() -> str:
     return """
 <div class="play-hook">
   <p class="eyebrow">First 30 seconds</p>
-  <h2>Find one impossible mushroom.</h2>
+  <h2>Goal: collect 3 clues to wake the Whispering Ring.</h2>
   <div class="hook-steps">
-    <span>1 · Explore</span>
-    <span>2 · Ask Myco</span>
-    <span>3 · Study or Collect</span>
+    <span>1 · Move through the forest</span>
+    <span>2 · Discover a mushroom clue</span>
+    <span>3 · Ask Myco, Study, then Collect</span>
   </div>
-  <p>Myco is not a generic chatbot: it is the forest sense that reacts to each discovery, warns you away from danger, and turns the MycoDex into a tiny mystery.</p>
+  <p>Every mushroom is a clue. Rare and legendary finds reveal stranger secrets, and Myco reacts like a companion who is trying to solve the forest with you.</p>
 </div>
 """
 
@@ -136,17 +143,21 @@ def game_status_markdown(
     """Render the current objective like a compact game quest log."""
     count = len(_safe_collection(collection))
     pos_x, pos_y = _safe_position(position)
+    active_mystery = next_mystery(count)
+    mystery_line = _mystery_goal_line(active_mystery, count)
     if current is None:
-        objective = "Click **Explore the Forest**. The first surprise should happen immediately."
-        discovery = "No active discovery yet."
-        ai_job = "Myco's job: react to the next mushroom and make it feel alive."
+        objective = "Goal: collect **3 clue-mushrooms** to wake the **Whispering Ring**."
+        discovery = "No active discovery yet. Move Myco, then Explore the Forest."
+        ai_job = "Myco's job: notice clues you would miss alone."
+        clue_line = mystery_line
     else:
         name = current.get("name", "Mystery mushroom")
         studied = current.get("studied") == "Yes"
-        next_step = "Collect it in the MycoDex" if studied else "Ask Myco, then Study or Collect"
+        next_step = "Collect it to preserve the clue" if studied else "Ask Myco, then Study the clue"
         objective = f"Current objective: **{next_step}**."
         discovery = f"Active discovery: **{name}** · Rarity: **{current.get('rarity', 'Unknown')}**"
-        ai_job = "Myco's job: interpret the mushroom, not just answer questions."
+        clue_line = f"**Clue:** {current.get('clue', 'Myco is still listening.')}"
+        ai_job = "Myco's job: interpret clues, warn you away from danger, and make discoveries feel alive."
 
     return "\n".join(
         (
@@ -155,12 +166,14 @@ def game_status_markdown(
             f"**Map position:** ({pos_x + 1}, {pos_y + 1})",
             discovery,
             objective,
+            clue_line,
+            mystery_line,
             ai_job,
         )
     )
 
 
-def mushroom_card(mushroom: Mushroom | None) -> str:
+def mushroom_card(mushroom: Mushroom | None, clue: str | None = None, secret: str | None = None) -> str:
     """Render the current mushroom discovery as markdown."""
     if mushroom is None:
         return "### 🌲 Forest Clearing\nClick **Explore the Forest** to wake a strange fungus."
@@ -174,6 +187,8 @@ def mushroom_card(mushroom: Mushroom | None) -> str:
             f"* **Edible:** {mushroom.edible}",
             f"* **Magic:** {mushroom.magic}",
             f"* **Danger:** {mushroom.danger}",
+            f"* **Clue:** {clue or 'Study with Myco to reveal the clue.'}",
+            f"* **Secret signal:** {secret or 'Collect it to see how the MycoDex reacts.'}",
             "",
             "**Judge demo move:** Ask Myco what it senses, then Study before Collecting.",
         )
@@ -202,12 +217,9 @@ def world_map_markdown(collection: CollectionState | None) -> str:
             )
         )
 
-    achievements = (
-        _achievement_badge("First Find", count >= 1),
-        _achievement_badge("Rare Scout", count >= 10),
-        _achievement_badge("Moonlit Keeper", count >= 25),
-        _achievement_badge("Elder Friend", count >= 50),
-    )
+    secrets = tuple(_secret_badge(thread.name, count >= thread.required_discoveries) for thread in revealed_mysteries(count))
+    if not secrets:
+        secrets = (_secret_badge("First Spore", False),)
     return "\n".join(
         (
             '<div class="world-map-panel">',
@@ -216,17 +228,17 @@ def world_map_markdown(collection: CollectionState | None) -> str:
             '    <h2>Forest Atlas</h2>',
             f'    <p>{count} discoveries logged. Unlock new areas by expanding the MycoDex.</p>',
             '  </div>',
-            f'  <div class="achievement-row">{"".join(achievements)}</div>',
+            f'  <div class="achievement-row">{"".join(secrets)}</div>',
             f'  <div class="map-grid">{"".join(cards)}</div>',
             '</div>',
         )
     )
 
 
-def _achievement_badge(label: str, unlocked: bool) -> str:
-    """Render a compact achievement badge."""
+def _secret_badge(label: str, unlocked: bool) -> str:
+    """Render a compact forest-secret badge."""
     state = "earned" if unlocked else "pending"
-    icon = "🏅" if unlocked else "◇"
+    icon = "🔎" if unlocked else "◇"
     return f'<span class="achievement {state}">{icon} {escape(label)}</span>'
 
 
@@ -239,7 +251,8 @@ def dex_markdown(collection: CollectionState | None) -> str:
     rows = ["### 📖 MycoDex", ""]
     for entry in current_collection:
         rows.append(
-            f"* 🍄 **{entry['name']}** — {entry['rarity']} — found near {entry['habitat']}"
+            f"* 🍄 **{entry['name']}** — {entry['rarity']} — found near {entry['habitat']} "
+            f"— clue: {entry.get('clue', 'not studied yet')}"
         )
     return "\n".join(rows)
 
@@ -263,10 +276,25 @@ def progress_markdown(collection: CollectionState | None) -> str:
         f"**Unlocked:** {unlocked_names}",
     ]
 
+    upcoming_mystery = next_mystery(count)
     if upcoming_area:
         remaining = upcoming_area.required_discoveries - count
-        rows.append(f"**Next goal:** {remaining} more discoveries to unlock **{upcoming_area.name}**.")
+        rows.append(f"**Next area:** {remaining} more discoveries to unlock **{upcoming_area.name}**.")
+    else:
+        rows.append(f"**All areas visible:** You have reached **{AREA_UNLOCKS[-1].name}**.")
+
+    if upcoming_mystery:
+        remaining = upcoming_mystery.required_discoveries - count
+        rows.append(f"**Next secret:** {remaining} more discoveries to reveal **{upcoming_mystery.name}**.")
     else:
-        rows.append(f"**All goals visible:** You have reached **{AREA_UNLOCKS[-1].name}**.")
+        rows.append("**All current secrets found:** Myco thinks the Elder is watching kindly.")
 
     return "\n\n".join(rows)
+
+
+def _mystery_goal_line(active_mystery, count: int) -> str:
+    """Render the next story goal without using a generic XP label."""
+    if active_mystery is None:
+        return "**Mystery:** Every known clue is awake. Keep exploring for rare surprises."
+    remaining = active_mystery.required_discoveries - count
+    return f"**Mystery:** {remaining} clue discoveries until **{active_mystery.name}** — {active_mystery.clue}"