Upload 10 files

src/services/classroom.js

@@ -446,6 +446,11 @@ export async function markNotificationRead(notificationId) {
     });
 }
 
+/**
+ * Gets the number of users in a room
+ * @param {string} roomCode 
+ * @returns {Promise<number>}
+ */
 /**
  * Gets the number of users in a room
  * @param {string} roomCode 
@@ -460,6 +465,23 @@ export async function getClassSize(roomCode) {
     return snapshot.data().count;
 }
 
+/**
+ * Gets the number of students who have reached a higher or equal stage
+ * Used for determining percentile ranking
+ * @param {string} roomCode
+ * @param {number} targetStage
+ * @returns {Promise<number>}
+ */
+export async function getHigherStageCount(roomCode, targetStage) {
+    const q = query(
+        collection(db, USERS_COLLECTION),
+        where("current_room", "==", roomCode),
+        where("monster_stage", ">=", targetStage)
+    );
+    const snapshot = await getCountFromServer(q);
+    return snapshot.data().count;
+}
+
 /**
  * Updates a student's monster stage and specific form
  * @param {string} userId

src/utils/monsterUtils.js

@@ -404,7 +404,16 @@ export function generateMonsterSVG(monster) {
  * @param {string} [currentMonsterId] - ID of the current monster to determine lineage
  * @returns {Object} Selected Monster Definition
  */
-export function getNextMonster(currentStage, likes, classSize, currentMonsterId = null) {
+/**
+ * Determines the next monster form based on parameters and lineage
+ * @param {number} currentStage - Current evolutionary stage (0-3)
+ * @param {number} stageLikes - Likes earned IN THIS STAGE
+ * @param {number} classSize - Active class size
+ * @param {string} [currentMonsterId] - ID of the current monster to determine lineage
+ * @param {number} [percentile] - Speed ranking percentile (0.0 - 1.0, lower is faster). Default 1.0
+ * @returns {Object} Selected Monster Definition
+ */
+export function getNextMonster(currentStage, stageLikes, classSize, currentMonsterId = null, percentile = 1.0) {
     if (currentStage === 0) return MONSTER_DEFS.find(m => m.id === 'Egg');
 
     // Find current monster family if we have an ID
@@ -415,28 +424,50 @@ export function getNextMonster(currentStage, likes, classSize, currentMonsterId
     }
 
     // Stage 1: Basic Families (Origin -> Family)
-    // If coming from Egg (Stage 0), we pick a base family.
+    // If coming from Egg (Stage 0), we pick a base family based on performance.
     if (currentStage === 1) {
-        // Simple distribution:
-        if (likes >= 5) return MONSTER_DEFS.find(m => m.id === 'L1_A'); // Spirit (Blue)
-        if (likes >= 2) return MONSTER_DEFS.find(m => m.id === 'L1_B'); // Beast (Yellow)
-        return MONSTER_DEFS.find(m => m.id === 'L1_C'); // Dust (Red)
+        // Simple distribution for Stage 1 (Egg -> Base)
+        // We can use the same Score Logic or keep simple likes.
+        // Let's use the Score Logic to be consistent with design.
+
+        let score = 0;
+        // Speed Score
+        if (percentile <= 0.3) score += 5;      // Top 30%
+        else if (percentile <= 0.6) score += 3; // Top 60%
+        else score += 1;                        // Rest
+
+        // Like Score
+        if (stageLikes >= 2) score += 2;
+        else if (stageLikes > 0) score += 1;
+
+        if (score >= 5) return MONSTER_DEFS.find(m => m.id === 'L1_A'); // High (Spirit)
+        if (score >= 3) return MONSTER_DEFS.find(m => m.id === 'L1_B'); // Mid (Beast)
+        return MONSTER_DEFS.find(m => m.id === 'L1_C'); // Low (Dust)
     }
 
     // Branching Logic for Stage 2 & 3
-    // A: High Likes ( > classSize / 2 )
-    // B: Normal Likes ( > 1 )
-    // C: Low Likes ( <= 1 )
+    // Score Calculation
+    let score = 0;
 
-    const ratio = classSize > 0 ? likes / classSize : 0;
+    // 1. Speed Score
+    if (percentile <= 0.3) score += 5;      // Top 30%
+    else if (percentile <= 0.6) score += 3; // Top 60%
+    else score += 1;                        // Rest
+
+    // 2. Like Score
+    if (stageLikes >= 2) score += 2;      // High Likes
+    else if (stageLikes > 0) score += 1;  // Any Likes
 
     // Tier Logic
     let tier = 'C';
-    if (likes > classSize / 2) tier = 'A';
-    else if (likes > 1) tier = 'B';
+    if (score >= 5) tier = 'A';      // High Tier
+    else if (score >= 3) tier = 'B'; // Mid Tier
 
-    // Safety check for small classes
-    if (classSize <= 2 && likes >= 1) tier = 'A'; // Boost for testing pairs
+    // Safety check for small classes (Boost if alone)
+    if (classSize <= 2) {
+        if (stageLikes >= 1) tier = 'A';
+        else tier = 'B';
+    }
 
     // Filter potential monsters for this Stage
     let candidates = MONSTER_DEFS.filter(m => m.stage === currentStage);
@@ -449,8 +480,8 @@ export function getNextMonster(currentStage, likes, classSize, currentMonsterId
     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}
-        // FIXED: currentStage IS the target stage (e.g. 3), so we look for L3_...
+        // Filter candidates: Must start with L{targetStage}_{currentPath}
+        // currentStage IS the target stage (e.g. 3), so we look for L3_...
         const strictMatches = candidates.filter(m => m.id.startsWith(`L${currentStage}_${currentPath}`));
 
         if (strictMatches.length > 0) {

src/views/StudentView.js

@@ -696,18 +696,67 @@ window.triggerEvolution = async (currentStage, nextStage, likes, classSize, curr
 
     try {
         const { getNextMonster, generateMonsterSVG, MONSTER_STAGES } = await import("../utils/monsterUtils.js");
-        const { updateUserMonster } = await import("../services/classroom.js");
+        const { updateUserMonster, getHigherStageCount } = await import("../services/classroom.js");
 
+        // Calculate Ranking Percentile
+        const roomCode = localStorage.getItem('vibecoding_room_code');
+        let percentile = 1.0;
 
-        // Calculate Next Monster with Lineage
-        // IMPORTANT: Ensure we pass currentMonsterId to enforce lineage!
-        const currentMonster = getNextMonster(currentStage, likes, classSize, currentMonsterId);
+        // Query how many already at next stage (or same level but evolved)
+        // Actually, we want to know how many have *completed* this stage essentially.
+        // Since we trigger evolution AFTER completion, anyone AT or ABOVE nextStage has completed it.
+        // So we count how many are >= nextStage.
+        // Wait, if I am the first to evolve to stage 1, count >= 1 is 0.
+        // So rank is (0 + 1) / classSize.
+
+        try {
+            const higherCount = await getHigherStageCount(roomCode, nextStage);
+            percentile = (higherCount + 1) / classSize;
+            console.log(`Evolution Rank: ${higherCount + 1}/${classSize} (${percentile})`);
+        } catch (e) {
+            console.error("Rank calc failed", e);
+        }
 
-        // 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);
+        // Calculate Stage-Specific Likes
+        // We need to fetch challenges to filter by level...
+        // cachedChallenges is available in module scope
+        // We need user progress... 
+        // We can't easily get it here without re-fetching or passing it in.
+        // But we have 'likes' passed in, which is TOTAL likes.
+        // Re-fetching progress is safer.
+        const userId = localStorage.getItem('vibecoding_user_id');
+        const { getUserProgress } = await import("../services/classroom.js");
+        const progress = await getUserProgress(userId);
+
+        let stageLikes = 0;
+        // Map stage to challenge level
+        // Stage 0 -> 1 requires Beginner (Level 1) likes
+        // Stage 1 -> 2 requires Intermediate (Level 2) likes
+        // Stage 2 -> 3 requires Advanced (Level 3) likes
+
+        // Note: nextStage parameter is the TARGET stage.
+        // If nextStage is 1 (Egg->Baby), we count Beginner likes.
+
+        const targetLevelMap = {
+            1: 'beginner',
+            2: 'intermediate',
+            3: 'advanced'
+        };
+        const targetLevel = targetLevelMap[nextStage];
+
+        if (targetLevel) {
+            stageLikes = cachedChallenges
+                .filter(c => c.level === targetLevel)
+                .reduce((acc, c) => acc + (progress[c.id]?.likes || 0), 0);
+        }
+        console.log(`Stage ${nextStage} Likes: ${stageLikes} (Total: ${likes})`);
+
+        // Calculate Next Monster with Lineage & Ranking
+        // IMPORTANT: Ensure we pass currentMonsterId to enforce lineage!
+        // We pass 'stageLikes' instead of total 'likes' now
+        const nextMonster = getNextMonster(currentStage, stageLikes, classSize, currentMonsterId, percentile);
 
-        console.log("Evolving from:", currentMonster.name, "to:", nextMonster.name);
+        console.log("Evolving from:", currentMonsterId, "to:", nextMonster.name);
 
         const container = document.querySelector('#monster-container-fixed .pixel-monster');
         const containerWrapper = document.querySelector('#monster-container-fixed .pixel-art-container');
@@ -720,7 +769,7 @@ window.triggerEvolution = async (currentStage, nextStage, likes, classSize, curr
         const maxFlickers = 12; // Increased duration
         let speed = 300;
 
-        const svgCurrent = generateMonsterSVG(currentMonster);
+        const currentMonster = MONSTER_DEFS.find(m => m.id === currentMonsterId) || getNextMonster(currentStage, 0, 0, currentMonsterId);
         const svgNext = generateMonsterSVG(nextMonster);
 
         const setFrame = (svg, isSilhouette) => {

test_evolution.js

@@ -0,0 +1,29 @@
+import { getNextMonster, MONSTER_DEFS } from './src/utils/monsterUtils.js';
+
+const mockMonster = { id: 'L2_CA', name: '駭客蟲', stage: 2 };
+const classSizes = [10, 30];
+const likeCounts = [0, 5, 20]; // Test Low, Mid, High tiers
+
+console.log(`Testing Evolution for: ${mockMonster.name} (${mockMonster.id})`);
+
+classSizes.forEach(size => {
+    likeCounts.forEach(likes => {
+        // We want to see what it evolves INTO, so we ask for Stage 3
+        const next = getNextMonster(3, likes, size, mockMonster.id);
+        console.log(`Class: ${size}, Likes: ${likes} -> Next: ${next.name} (${next.id})`);
+    });
+});
+
+console.log('\n--- Checking Evolution for Trash Mob (L2_CC) ---');
+// Verify if L2_CC evolves to Virus King (L3_CCA) or others
+const trashMob = { id: 'L2_CC', name: '垃圾怪', stage: 2 };
+const nextTrash = getNextMonster(3, 5, 10, trashMob.id);
+console.log(`Trash Mob (L2_CC) w/ High Likes -> ${nextTrash.name} (${nextTrash.id})`);
+
+console.log('\n--- Debugging candidates for L2_CA ---');
+// Manually replicate the util logic step
+const candidates = MONSTER_DEFS.filter(m => m.stage === 3);
+const currentPath = 'CA';
+const rigidMatches = candidates.filter(m => m.id.startsWith(`L3_${currentPath}`));
+console.log('Strict Matches for L3_CA*:');
+rigidMatches.forEach(m => console.log(m.id, m.name));