Update server.js

server.js

@@ -4,100 +4,148 @@ const { Server } = require('socket.io');
 
 const app = express();
 const server = http.createServer(app);
-const io = new Server(server, { 
+const io = new Server(server, {
     cors: { origin: "*" },
-    pingInterval: 1000, 
-    pingTimeout: 5000 
+    pingTimeout: 60000, // No timeout unless connection lost
 });
 
 app.use(express.static('public'));
 
-// GLOBAL STATE
-const players = {};
-// A static seed ensuring everyone gets the exact same map logic
-const GLOBAL_SEED = Math.floor(Math.random() * 1000000); 
+// CONFIG
+const GROWTH_RATE = 3; // Pixels per tick (must match client)
+const PLATFORM_HEIGHT = 100;
+const PLAYER_SIZE = 20;
+
+// STATE
+let platforms = []; // Shared world for everyone
+let players = {};   // { socketId: { id, name, score, x, state, ... } }
+
+// Generate infinite world logic
+function generatePlatform(prevX, prevW) {
+    const gap = 80 + Math.random() * 120; // Random gap
+    const width = 40 + Math.random() * 60; // Random width
+    return {
+        x: prevX + prevW + gap,
+        w: width,
+        id: Math.random().toString(36).substr(2, 9)
+    };
+}
+
+// Init first few platforms
+platforms.push({ x: 50, w: 100, id: 'start' });
+for (let i = 0; i < 10; i++) {
+    const last = platforms[platforms.length - 1];
+    platforms.push(generatePlatform(last.x, last.w));
+}
 
 io.on('connection', (socket) => {
-    // 1. Send configuration immediately
-    socket.emit('config', { seed: GLOBAL_SEED });
+    console.log(`Player connected: ${socket.id}`);
 
-    // 2. Player joins
-    socket.on('join', (data) => {
-        players[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
+    };
+
+    // 1. Join Game
+    socket.on('join', (name) => {
+        players[socket.id].name = name.substring(0, 12) || "Guest";
+        // Send initial World State
+        socket.emit('init', {
             id: socket.id,
-            name: (data.name || "Guest").substring(0, 12),
-            skin: data.skin || "square",
-            x: 0,
-            y: 0,
-            score: 0,
-            isDead: false,
-            lastSeen: Date.now()
-        };
+            platforms: platforms,
+            players: players
+        });
+        io.emit('player_update', players[socket.id]); // Tell others
     });
 
-    // 3. Receive player updates
-    socket.on('update', (data) => {
+    // 2. Start Growing Stick
+    socket.on('start_grow', () => {
         const p = players[socket.id];
-        if (p) {
-            // Data comes in array: [x, y, vx, vy, score, isDead]
-            p.x = data[0];
-            p.y = data[1];
-            p.vx = data[2];
-            p.vy = data[3];
-            p.score = data[4];
-            p.isDead = data[5];
-            p.lastSeen = Date.now();
-        }
+        if (p.state !== 'ready') return;
+        
+        p.state = 'growing';
+        p.growStartTime = Date.now();
+        p.isGrowing = true;
+        
+        // Broadcast visual state to others
+        io.emit('player_action', { id: socket.id, type: 'grow_start' });
     });
 
-    socket.on('disconnect', () => {
-        delete players[socket.id];
-    });
-});
+    // 3. Stop Growing (The Critical Physics Check)
+    socket.on('stop_grow', () => {
+        const p = players[socket.id];
+        if (p.state !== 'growing') return;
 
-// BROADCAST LOOP (30 TPS)
-// 30 times a second is the sweet spot for browser games. 
-// 60 TPS over internet often causes packet choking (the 0.1fps issue).
-setInterval(() => {
-    const pack = [];
-    const leaderboard = [];
-    const now = Date.now();
+        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); 
 
-    for (const id in players) {
-        const p = players[id];
-        
-        // Timeout check (remove stale players)
-        if (now - p.lastSeen > 10000000000) {
-            delete players[id];
-            continue;
-        }
+        p.isGrowing = false;
+        p.state = 'moving';
 
-        // COMPRESSION: Send Array instead of Object
-        // [id, x, y, skin, isDead, name]
-        pack.push([
-            p.id,
-            Math.round(p.x),
-            Math.round(p.y),
-            p.skin,
-            p.isDead ? 1 : 0,
-            p.name
-        ]);
-
-        if (!p.isDead) {
-            leaderboard.push({ name: p.name, score: p.score });
-        }
-    }
+        io.emit('player_action', { id: socket.id, type: 'grow_stop', height: p.stickHeight });
 
-    // Top 3 Leaderboard
-    leaderboard.sort((a, b) => b.score - a.score);
-    const top3 = leaderboard.slice(0, 3);
+        // Logic Check
+        const currentPlat = platforms[p.currentPlatIndex];
+        const nextPlat = platforms[p.currentPlatIndex + 1];
+
+        // Ensure we have platforms
+        if (!nextPlat) {
+             const last = platforms[platforms.length - 1];
+             platforms.push(generatePlatform(last.x, last.w));
+             io.emit('new_platform', platforms[platforms.length - 1]);
+        }
+        
+        const stickEnd = currentPlat.x + currentPlat.w + p.stickHeight;
+        
+        setTimeout(() => {
+            // Did they land?
+            if (stickEnd >= nextPlat.x && stickEnd <= nextPlat.x + nextPlat.w) {
+                // SUCCESS
+                p.score++;
+                p.currentPlatIndex++;
+                p.x = nextPlat.x + nextPlat.w - PLAYER_SIZE - 5;
+                p.state = 'ready';
+                
+                // Generate more world if needed
+                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);
+                }
 
-    // Send world state
-    io.emit('w', { p: pack, l: top3 });
+                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 });
+            }
+        }, 1000); // Wait for fall animation roughly
+    });
 
-}, 33); 
+    socket.on('disconnect', () => {
+        console.log(`Player disconnected: ${socket.id}`);
+        delete players[socket.id];
+        io.emit('player_leave', socket.id);
+    });
+});
 
 const PORT = process.env.PORT || 3000;
-server.listen(PORT, () => {
-    console.log(`Server running on port ${PORT} | Seed: ${GLOBAL_SEED}`);
-});
+server.listen(PORT, () => console.log(`Server running on port ${PORT}`));