Upload 9 files

src/services/classroom.js

@@ -175,13 +175,14 @@ export async function startChallenge(userId, roomCode, challengeId) {
         // Let's update timestamp to reflect "last worked on"
         await updateDoc(snapshot.docs[0].ref, {
             status: 'started',
+            roomCode: String(roomCode), // Ensure roomCode is updated
             timestamp: serverTimestamp()
         });
     } else {
         // Create new progress entry with 'started' status
         await addDoc(progressRef, {
             userId,
-            roomCode,
+            roomCode: String(roomCode),
             challengeId,
             status: 'started',
             startedAt: serverTimestamp(), // Keep original start time if we want to track duration
@@ -488,28 +489,6 @@ export async function getUser(userId) {
     return snap.exists() ? snap.data() : null;
 }
 
-/**
- * Subscribes to a single user's progress for real-time updates
- * @param {string} userId 
- * @param {Function} callback (progressMap) => void
- * @returns {Function} unsubscribe
- */
-export function subscribeToUserProgress(userId, callback) {
-    const q = query(
-        collection(db, PROGRESS_COLLECTION),
-        where("userId", "==", userId)
-    );
-
-    return onSnapshot(q, (snapshot) => {
-        const progressMap = {};
-        snapshot.forEach(doc => {
-            const data = doc.data();
-            progressMap[data.challengeId] = data;
-        });
-        callback(progressMap);
-    });
-}
-
 /**
  * Removes a user from the classroom (Kick)
  * @param {string} userId 

src/utils/monsterUtils.js

@@ -441,18 +441,48 @@ export function getNextMonster(currentStage, likes, classSize, currentMonsterId
     // Filter potential monsters for this Stage
     let candidates = MONSTER_DEFS.filter(m => m.stage === currentStage);
 
-    // Enforce Lineage (Family)
-    if (currentFam && currentFam !== 'Origin') {
-        // Filter candidates that belong to this Family tree
-        // We need to know which families map to which.
-        // Stage 1 -> Stage 2 Mapping:
-        // Dust -> Dust (Trash/Slime/Tech)
-        // Beast -> Beast (Wolf/Cat/Mech)
-        // Spirit -> Spirit (Fire/Angel/Dragon)
-
-        // In MONSTER_DEFS, 'fam' for Stage 2 is 'Dust', 'Beast', 'Spirit'.
-        // So we just match strict equality.
-        candidates = candidates.filter(m => m.fam === currentFam || m.fam.includes(currentFam));
+    // 1. Strict Lineage by ID Pattern (L{stage}_{path})
+    // e.g. L1_A -> L2_A... / L2_AB -> L3_AB...
+    // This allows exact branching control as per design doc.
+    const isStandardId = currentMonsterId?.match(/^L\d+_[ABC]+$/);
+
+    if (isStandardId) {
+        // Extract path suffix (e.g. "A" from "L1_A", "AB" from "L2_AB")
+        const currentPath = currentMonsterId.split('_')[1];
+        // Filter candidates: Must start with L{nextStage}_{currentPath}
+        const strictMatches = candidates.filter(m => m.id.startsWith(`L${currentStage + 1}_${currentPath}`));
+
+        if (strictMatches.length > 0) {
+            candidates = strictMatches;
+        }
+    }
+    // 2. Fallback: Family Tree Logic (for custom IDs or Egg)
+    else if (currentFam && currentFam !== 'Origin') {
+        // Define Family Tree Mapping
+        const FAMILY_TREE = {
+            // Stage 1 Root: Low Tier (Red Path)
+            'Dust': ['Dust', 'Glitch', 'Trash', 'Slime', 'Tech', 'Hacker', 'Virus'],
+            // Stage 1 Root: Mid Tier (Yellow Path)
+            'Beast': ['Beast', 'Wolf', 'Cat', 'Mech', 'Mech Lion', 'Animal', 'Grunge', 'Royal', 'Warrior', 'Undead', 'Elemental'],
+            // Stage 1 Root: High Tier (Blue Path)
+            'Spirit': ['Spirit', 'Ghost', 'Holy', 'Cosmos', 'Angel', 'Divin', 'Void', 'Undead']
+        };
+
+        // Find which root family the current family belongs to
+        let rootFamily = null;
+        for (const [root, children] of Object.entries(FAMILY_TREE)) {
+            if (root === currentFam || children.includes(currentFam) || children.some(c => currentFam.includes(c))) {
+                rootFamily = root;
+                break;
+            }
+        }
+
+        if (rootFamily) {
+            const allowedFamilies = FAMILY_TREE[rootFamily];
+            candidates = candidates.filter(m => {
+                return allowedFamilies.some(fam => m.fam.includes(fam) || fam.includes(m.fam));
+            });
+        }
     }
 
     // Filter by Tier (Suffix A/B/C)

src/views/StudentView.js

@@ -698,10 +698,17 @@ window.triggerEvolution = async (currentStage, nextStage, likes, classSize, curr
         const { getNextMonster, generateMonsterSVG, MONSTER_STAGES } = await import("../utils/monsterUtils.js");
         const { updateUserMonster } = await import("../services/classroom.js");
 
+
         // Calculate Next Monster with Lineage
+        // IMPORTANT: Ensure we pass currentMonsterId to enforce lineage!
         const currentMonster = getNextMonster(currentStage, likes, classSize, currentMonsterId);
+
+        // Next Stage: If evolving, we need to find what this specific monster turns into.
+        // We pass 'currentMonsterId' to the next stage calculation too, so it knows the family 'Origin'.
         const nextMonster = getNextMonster(nextStage, likes, classSize, currentMonsterId);
 
+        console.log("Evolving from:", currentMonster.name, "to:", nextMonster.name);
+
         const container = document.querySelector('#monster-container-fixed .pixel-monster');
         const containerWrapper = document.querySelector('#monster-container-fixed .pixel-art-container');
 
@@ -739,6 +746,7 @@ window.triggerEvolution = async (currentStage, nextStage, likes, classSize, curr
                         containerWrapper.style.transition = 'filter 0.8s ease-out';
                         containerWrapper.style.filter = 'drop-shadow(0 0 30px #ffffff) brightness(1.5)';
 
+                        // Force SVG update to next monster for final state
                         setFrame(svgNext, false);
 
                         setTimeout(async () => {