Update server.js

server.js

@@ -6,24 +6,51 @@ const app = express();
 const server = http.createServer(app);
 const io = new Server(server, {
     cors: { origin: "*" },
-    pingTimeout: 60000, // No timeout unless connection lost
+    pingTimeout: 60000,
 });
 
 app.use(express.static('public'));
 
-// CONFIG
-const GROWTH_RATE = 3; // Pixels per tick (must match client)
-const PLATFORM_HEIGHT = 100;
+// --- CONFIGURATION ---
 const PLAYER_SIZE = 20;
+// Growth rate (pixels per ms). 
+// Must match Client exactly for prediction to work.
+// 3px per frame (at 60fps) ~= 0.18px per ms
+const GROWTH_SPEED = 0.18; 
+
+// --- ACCESS CODES ---
+// In HuggingFace, add a secret named 'GAME_CODES'
+// For now, we generate them in memory if not found.
+let VALID_CODES = new Set();
+const FIXED_CODE = "676900";
+
+function loadCodes() {
+    if (process.env.GAME_CODES) {
+        // Expecting comma separated codes
+        const codes = process.env.GAME_CODES.split(',');
+        codes.forEach(c => VALID_CODES.add(c.trim()));
+    } else {
+        // Generate 29 random codes + fixed code
+        console.log("--- GENERATING NEW ACCESS CODES (Save these to Secrets) ---");
+        VALID_CODES.add(FIXED_CODE);
+        console.log(`1. ${FIXED_CODE} (Master)`);
+        for(let i=1; i<30; i++) {
+            const code = Math.floor(100000 + Math.random() * 900000).toString();
+            VALID_CODES.add(code);
+            console.log(`${i+1}. ${code}`);
+        }
+        console.log("-----------------------------------------------------------");
+    }
+}
+loadCodes();
 
-// STATE
-let platforms = []; // Shared world for everyone
-let players = {};   // { socketId: { id, name, score, x, state, ... } }
+// --- GAME STATE ---
+let platforms = [];
+let players = {}; 
 
-// Generate infinite world logic
 function generatePlatform(prevX, prevW) {
-    const gap = 80 + Math.random() * 120; // Random gap
-    const width = 40 + Math.random() * 60; // Random width
+    const gap = 80 + Math.random() * 120;
+    const width = 40 + Math.random() * 60;
     return {
         x: prevX + prevW + gap,
         w: width,
@@ -31,7 +58,7 @@ function generatePlatform(prevX, prevW) {
     };
 }
 
-// Init first few platforms
+// Init World
 platforms.push({ x: 50, w: 100, id: 'start' });
 for (let i = 0; i < 10; i++) {
     const last = platforms[platforms.length - 1];
@@ -39,111 +66,135 @@ for (let i = 0; i < 10; i++) {
 }
 
 io.on('connection', (socket) => {
-    console.log(`Player connected: ${socket.id}`);
-
-    // Init Player State
-    players[socket.id] = {
-        id: socket.id,
-        name: "Guest",
-        score: 0,
-        x: platforms[0].x + platforms[0].w - PLAYER_SIZE - 5,
-        currentPlatIndex: 0,
-        stickHeight: 0,
-        isGrowing: false,
-        growStartTime: 0,
-        state: 'ready' // ready, growing, moving, dead
-    };
+    let isAuthenticated = false;
+
+    // 1. Login with Code
+    socket.on('login', (data) => {
+        const { name, code } = data;
+        
+        if (!VALID_CODES.has(code)) {
+            socket.emit('auth_error', 'Invalid Access Code');
+            return;
+        }
+
+        isAuthenticated = true;
+        const cleanName = (name || "Guest").substring(0, 12);
 
-    // 1. Join Game
-    socket.on('join', (name) => {
-        players[socket.id].name = name.substring(0, 12) || "Guest";
-        // Send initial World State
+        // Init Player
+        players[socket.id] = {
+            id: socket.id,
+            name: cleanName,
+            score: 0,
+            x: platforms[0].x + platforms[0].w - PLAYER_SIZE - 5,
+            currentPlatIndex: 0,
+            growStartTime: 0,
+            isGrowing: false
+        };
+
+        // Send Success & World State
         socket.emit('init', {
             id: socket.id,
             platforms: platforms,
             players: players
         });
-        io.emit('player_update', players[socket.id]); // Tell others
+
+        // Broadcast to others
+        socket.broadcast.emit('player_join', players[socket.id]);
     });
 
-    // 2. Start Growing Stick
+    // 2. Start Growing (Timestamp Authoritative)
     socket.on('start_grow', () => {
+        if (!isAuthenticated || !players[socket.id]) return;
         const p = players[socket.id];
-        if (p.state !== 'ready') return;
         
-        p.state = 'growing';
-        p.growStartTime = Date.now();
         p.isGrowing = true;
+        p.growStartTime = Date.now();
         
-        // Broadcast visual state to others
-        io.emit('player_action', { id: socket.id, type: 'grow_start' });
+        // Relay to others for visual interpolation
+        socket.broadcast.emit('player_action', { id: socket.id, type: 'grow_start' });
     });
 
-    // 3. Stop Growing (The Critical Physics Check)
+    // 3. Stop Growing (The Physics Check)
     socket.on('stop_grow', () => {
+        if (!isAuthenticated || !players[socket.id]) return;
         const p = players[socket.id];
-        if (p.state !== 'growing') return;
+        if (!p.isGrowing) return;
 
         const duration = Date.now() - p.growStartTime;
-        // Server calculates length based on time. Client cannot fake stick length.
-        // We divide by approx frame rate (16ms) to match client visual loop
-        // Or simpler: stick grows based on ms duration directly
-        // Let's align with the client loop logic: roughly 60fps loop adds 3px
-        // 3px per ~16.6ms = ~0.18px per ms
-        p.stickHeight = Math.min((duration / 16.66) * GROWTH_RATE, 2000); 
-
         p.isGrowing = false;
-        p.state = 'moving';
 
-        io.emit('player_action', { id: socket.id, type: 'grow_stop', height: p.stickHeight });
+        // Calculate Authoritative Height
+        // Cap max height to prevent exploit
+        let stickHeight = Math.min(duration * GROWTH_SPEED, 2000);
+
+        // Notify others immediately of the result so they see the animation
+        socket.broadcast.emit('player_action', { id: socket.id, type: 'grow_stop', height: stickHeight });
 
-        // Logic Check
+        // --- SERVER PHYSICS CHECK ---
         const currentPlat = platforms[p.currentPlatIndex];
         const nextPlat = platforms[p.currentPlatIndex + 1];
 
-        // Ensure we have platforms
+        // Generate map if running out
         if (!nextPlat) {
              const last = platforms[platforms.length - 1];
-             platforms.push(generatePlatform(last.x, last.w));
-             io.emit('new_platform', platforms[platforms.length - 1]);
+             const newPlat = generatePlatform(last.x, last.w);
+             platforms.push(newPlat);
+             io.emit('new_platform', newPlat);
         }
         
-        const stickEnd = currentPlat.x + currentPlat.w + p.stickHeight;
-        
+        const stickEnd = currentPlat.x + currentPlat.w + stickHeight;
+        const safeStart = nextPlat.x;
+        const safeEnd = nextPlat.x + nextPlat.w;
+        const perfectCenter = nextPlat.x + (nextPlat.w / 2);
+
+        let success = false;
+        let perfect = false;
+
+        if (stickEnd >= safeStart && stickEnd <= safeEnd) {
+            success = true;
+            // Check for perfect center hit (optional bonus logic)
+            if (Math.abs(stickEnd - perfectCenter) < 5) perfect = true;
+        }
+
+        // Wait for animation duration (simulated) then update state
         setTimeout(() => {
-            // Did they land?
-            if (stickEnd >= nextPlat.x && stickEnd <= nextPlat.x + nextPlat.w) {
-                // SUCCESS
-                p.score++;
+            if (success) {
+                p.score += perfect ? 2 : 1;
                 p.currentPlatIndex++;
-                p.x = nextPlat.x + nextPlat.w - PLAYER_SIZE - 5;
-                p.state = 'ready';
+                p.x = nextPlat.x + nextPlat.w - PLAYER_SIZE - 5; // Target X
                 
-                // Generate more world if needed
+                // Infinite Gen
                 if (platforms.length < p.currentPlatIndex + 5) {
-                    const last = platforms[platforms.length - 1];
-                    const newPlat = generatePlatform(last.x, last.w);
-                    platforms.push(newPlat);
-                    io.emit('new_platform', newPlat);
+                     const last = platforms[platforms.length - 1];
+                     const newPlat = generatePlatform(last.x, last.w);
+                     platforms.push(newPlat);
+                     io.emit('new_platform', newPlat);
                 }
-
-                io.emit('player_result', { id: socket.id, success: true, score: p.score, x: p.x });
             } else {
-                // FAIL
                 p.score = 0;
                 p.currentPlatIndex = 0;
-                p.x = platforms[0].x + platforms[0].w - PLAYER_SIZE - 5;
-                p.state = 'ready';
-                
-                io.emit('player_result', { id: socket.id, success: false, score: 0, x: p.x });
+                p.x = platforms[0].x + platforms[0].w - PLAYER_SIZE - 5; // Reset X
             }
-        }, 1000); // Wait for fall animation roughly
+
+            // RECONCILIATION PACKET
+            // We tell everyone the result.
+            // The local client will compare this. If they predicted correctly, nothing happens visually.
+            // If they cheated, this packet will snap them back to reality.
+            io.emit('player_result', {
+                id: socket.id,
+                success: success,
+                score: p.score,
+                x: p.x 
+            });
+
+        }, 1000); // 1s represents the fall/walk animation time
     });
 
     socket.on('disconnect', () => {
-        console.log(`Player disconnected: ${socket.id}`);
-        delete players[socket.id];
-        io.emit('player_leave', socket.id);
+        if (players[socket.id]) {
+            delete players[socket.id];
+            io.emit('player_leave', socket.id);
+        }
     });
 });