Update server.js

server.js

@@ -2,16 +2,30 @@ const express = require('express');
 const http = require('http');
 const { Server } = require('socket.io');
 const path = require('path');
+const zlib = require('zlib');
 
 const app = express();
 const server = http.createServer(app);
+
+// Professional Socket.IO configuration
 const io = new Server(server, {
     cors: {
         origin: "*",
         methods: ["GET", "POST"]
     },
-    pingTimeout: 60000,
-    pingInterval: 25000
+    // Optimized for slow connections
+    pingTimeout: 120000,
+    pingInterval: 10000,
+    upgradeTimeout: 30000,
+    transports: ['websocket', 'polling'],
+    allowUpgrades: true,
+    perMessageDeflate: {
+        threshold: 256,
+        zlibDeflateOptions: { level: 6 },
+        zlibInflateOptions: { chunkSize: 10 * 1024 }
+    },
+    httpCompression: true,
+    maxHttpBufferSize: 1e6
 });
 
 app.use(express.static(path.join(__dirname, 'public')));
@@ -19,17 +33,21 @@ app.use(express.static(path.join(__dirname, 'public')));
 // Game constants
 const TILE_SIZE = 10;
 const GRID_WIDTH = 13;
-const TICK_RATE = 20; // Server updates per second
-const INTERPOLATION_BUFFER = 100; // ms
+const BASE_TICK_RATE = 15; // Lower for bandwidth
+const HOP_DURATION = 120;
 
 // Game state
 const players = new Map();
 const gameState = {
     lanes: new Map(),
-    furthestLaneIndex: 14
+    furthestLaneIndex: 14,
+    version: 0 // State version for delta sync
 };
 
-// Lane types and generation
+// Connection stats
+const connectionStats = new Map();
+
+// ============= LANE GENERATION =============
 function generateLaneData(index, prevLane) {
     let type = 'grass';
     let runLength = 1;
@@ -66,21 +84,23 @@ function generateLaneData(index, prevLane) {
         for (let i = 0; i < treeCount; i++) {
             let gx = Math.floor(Math.random() * GRID_WIDTH) - Math.floor(GRID_WIDTH / 2);
             if (index < 5 && gx === 0) continue;
-            staticObstacles.push(gx);
+            if (!staticObstacles.includes(gx)) {
+                staticObstacles.push(gx);
+            }
         }
     }
 
     const lane = {
-        index,
-        type,
-        runLength,
-        staticObstacles,
-        zPos: index * TILE_SIZE,
-        speed: (Math.random() * 0.04 + 0.02) * TILE_SIZE,
-        direction: Math.random() > 0.5 ? 1 : -1,
-        obstacles: [],
+        i: index, // Short keys for bandwidth
+        t: type.charAt(0), // 'g', 'r', 'w'
+        rl: runLength,
+        so: staticObstacles,
+        sp: Math.round((Math.random() * 0.04 + 0.02) * TILE_SIZE * 100) / 100,
+        d: Math.random() > 0.5 ? 1 : -1,
+        obs: [],
         timer: 0,
-        interval: Math.random() * 100 + 150
+        interval: Math.random() * 100 + 150,
+        obsId: 0
     };
 
     // Pre-populate obstacles
@@ -91,15 +111,14 @@ function generateLaneData(index, prevLane) {
             if (Math.abs(randX) < 15) randX += (randX > 0 ? 20 : -20);
             
             const obsWidth = type === 'water' 
-                ? (Math.random() > 0.5 ? 4 : 6) * TILE_SIZE 
+                ? (Math.random() > 0.5 ? 40 : 60)
                 : 12;
             
-            lane.obstacles.push({
-                id: `${index}-${Date.now()}-${i}`,
-                x: randX,
-                isLog: type === 'water',
-                width: obsWidth,
-                speed: lane.speed * lane.direction
+            lane.obs.push({
+                id: lane.obsId++,
+                x: Math.round(randX * 10) / 10,
+                l: type === 'water' ? 1 : 0, // isLog
+                w: obsWidth
             });
         }
     }
@@ -107,7 +126,6 @@ function generateLaneData(index, prevLane) {
     return lane;
 }
 
-// Initialize lanes
 function initializeLanes() {
     gameState.lanes.clear();
     for (let i = -4; i < 15; i++) {
@@ -119,447 +137,470 @@ function initializeLanes() {
 
 initializeLanes();
 
-// Update obstacles positions
-function updateObstacles() {
-    gameState.lanes.forEach((lane) => {
-        if (lane.type === 'road' || lane.type === 'water') {
-            lane.timer++;
-            
-            if (lane.timer > lane.interval) {
-                const startX = -lane.direction * (GRID_WIDTH * TILE_SIZE / 2 + 60);
-                const obsWidth = lane.type === 'water' 
-                    ? (Math.random() > 0.5 ? 4 : 6) * TILE_SIZE 
-                    : 12;
-                
-                lane.obstacles.push({
-                    id: `${lane.index}-${Date.now()}`,
-                    x: startX,
-                    isLog: lane.type === 'water',
-                    width: obsWidth,
-                    speed: lane.speed * lane.direction
-                });
-                
-                lane.timer = 0;
-                lane.interval = Math.random() * 100 + 200;
-            }
-
-            // Move obstacles
-            for (let i = lane.obstacles.length - 1; i >= 0; i--) {
-                const obs = lane.obstacles[i];
-                obs.x += obs.speed;
-                if (Math.abs(obs.x) > 400) {
-                    lane.obstacles.splice(i, 1);
-                }
-            }
-        }
-    });
-}
-
-// Check collision at position
+// ============= COLLISION DETECTION =============
 function checkCollisionAtPosition(gridX, gridZ, worldX = null) {
     const lane = gameState.lanes.get(gridZ);
-    if (!lane) return { collision: false };
+    if (!lane) return { hit: false };
 
-    const playerX = worldX !== null ? worldX : gridX * TILE_SIZE;
+    const px = worldX !== null ? worldX : gridX * TILE_SIZE;
 
-    // Check bounds
-    if (Math.abs(playerX) > (GRID_WIDTH * TILE_SIZE / 2 + 10)) {
-        return { collision: true, type: 'bounds' };
+    if (Math.abs(px) > (GRID_WIDTH * TILE_SIZE / 2 + 10)) {
+        return { hit: true, type: 'bounds' };
     }
 
-    // Check static obstacles (trees)
-    if (lane.type === 'grass') {
-        if (lane.staticObstacles.includes(gridX)) {
-            return { collision: true, type: 'tree', blocked: true };
+    if (lane.t === 'g') {
+        if (lane.so.includes(gridX)) {
+            return { hit: true, type: 'tree', blocked: true };
         }
-        return { collision: false };
+        return { hit: false };
     }
 
-    // Check road (cars)
-    if (lane.type === 'road') {
-        for (const obs of lane.obstacles) {
-            const obsLeft = obs.x - obs.width / 2;
-            const obsRight = obs.x + obs.width / 2;
-            const playerLeft = playerX - 3;
-            const playerRight = playerX + 3;
-            
-            if (playerRight > obsLeft && playerLeft < obsRight) {
-                return { collision: true, type: 'car' };
+    if (lane.t === 'r') {
+        for (const obs of lane.obs) {
+            const left = obs.x - obs.w / 2;
+            const right = obs.x + obs.w / 2;
+            if (px + 3 > left && px - 3 < right) {
+                return { hit: true, type: 'car' };
             }
         }
-        return { collision: false };
+        return { hit: false };
     }
 
-    // Check water (logs)
-    if (lane.type === 'water') {
-        for (const obs of lane.obstacles) {
-            const distX = Math.abs(playerX - obs.x);
-            const safeDist = (obs.width / 2) + 4;
-            
-            if (distX < safeDist) {
-                return { collision: false, onLog: true, log: obs };
+    if (lane.t === 'w') {
+        for (const obs of lane.obs) {
+            if (Math.abs(px - obs.x) < (obs.w / 2) + 4) {
+                return { hit: false, onLog: true, logId: obs.id };
             }
         }
-        return { collision: true, type: 'water' };
+        return { hit: true, type: 'water' };
     }
 
-    return { collision: false };
+    return { hit: false };
 }
 
-// Validate move
 function validateMove(player, dx, dz) {
-    if (!player.alive) return { valid: false };
-    if (dz < 0) return { valid: false }; // No backward
+    if (!player.alive) return { valid: false, reason: 'dead' };
+    if (dz < 0) return { valid: false, reason: 'backward' };
 
-    const targetX = player.gridX + dx;
-    const targetZ = player.gridZ + dz;
+    const targetX = player.gx + dx;
+    const targetZ = player.gz + dz;
 
     if (Math.abs(targetX) > Math.floor(GRID_WIDTH / 2)) {
-        return { valid: false };
+        return { valid: false, reason: 'bounds' };
     }
 
-    // Check for tree blocking
     const lane = gameState.lanes.get(targetZ);
-    if (lane && lane.type === 'grass') {
-        if (lane.staticObstacles.includes(targetX)) {
-            return { valid: false };
-        }
+    if (lane && lane.t === 'g' && lane.so.includes(targetX)) {
+        return { valid: false, reason: 'tree' };
     }
 
-    return { valid: true, targetX, targetZ };
+    return { valid: true, tx: targetX, tz: targetZ };
 }
 
-// Get leaderboard
+// ============= LEADERBOARD =============
 function getLeaderboard() {
-    const sorted = Array.from(players.values())
+    return Array.from(players.values())
         .filter(p => p.alive || p.score > 0)
         .sort((a, b) => b.score - a.score)
-        .slice(0, 3);
-    
-    return sorted.map((p, i) => ({
-        rank: i + 1,
-        username: p.username,
-        score: p.score
-    }));
+        .slice(0, 3)
+        .map((p, i) => ({
+            r: i + 1,
+            n: p.name,
+            s: p.score
+        }));
 }
 
-// Socket handling
+// Compact player data for network
+function compactPlayer(p) {
+    return {
+        id: p.id,
+        n: p.name,
+        gx: p.gx,
+        gz: p.gz,
+        wx: Math.round(p.wx * 10) / 10,
+        wz: Math.round(p.wz * 10) / 10,
+        r: Math.round(p.rot * 100) / 100,
+        s: p.score,
+        a: p.alive ? 1 : 0,
+        h: p.hopping ? 1 : 0,
+        ht: p.hopTime
+    };
+}
+
+// Compact lane data
+function compactLane(lane) {
+    return {
+        i: lane.i,
+        t: lane.t,
+        rl: lane.rl,
+        so: lane.so,
+        sp: lane.sp,
+        d: lane.d,
+        obs: lane.obs.map(o => ({
+            id: o.id,
+            x: Math.round(o.x * 10) / 10,
+            l: o.l,
+            w: o.w
+        }))
+    };
+}
+
+// ============= SOCKET HANDLING =============
 io.on('connection', (socket) => {
-    console.log('Player connected:', socket.id);
+    console.log(`[${new Date().toISOString()}] Connection: ${socket.id}`);
+    
+    // Initialize connection stats
+    connectionStats.set(socket.id, {
+        connected: Date.now(),
+        lastPing: Date.now(),
+        ping: 0,
+        quality: 'good'
+    });
 
-    socket.on('join', (username) => {
-        const sanitizedName = username.substring(0, 15).replace(/[<>]/g, '');
-        
-        const player = {
-            id: socket.id,
-            username: sanitizedName || 'Anonymous',
-            gridX: 0,
-            gridZ: 0,
-            worldX: 0,
-            worldZ: 0,
-            score: 0,
-            alive: true,
-            isHopping: false,
-            hopStartTime: 0,
-            hopDuration: 120,
-            hopStartPos: { x: 0, z: 0 },
-            hopTargetPos: { x: 0, z: 0 },
-            rotation: 0,
-            attachedLog: null,
-            lastMoveTime: 0
-        };
-        
-        players.set(socket.id, player);
+    // Send immediate acknowledgment
+    socket.emit('ack', { 
+        id: socket.id, 
+        t: Date.now(),
+        v: gameState.version 
+    });
 
-        // Send initial state
-        const lanesData = {};
-        gameState.lanes.forEach((lane, key) => {
-            lanesData[key] = lane;
-        });
+    socket.on('join', (data) => {
+        try {
+            const name = (data.name || 'Anon').substring(0, 12).replace(/[<>\"\'&]/g, '');
+            
+            const player = {
+                id: socket.id,
+                name: name,
+                gx: 0, gz: 0,
+                wx: 0, wz: 0,
+                score: 0,
+                alive: true,
+                hopping: false,
+                hopTime: 0,
+                hopStart: { x: 0, z: 0 },
+                hopTarget: { x: 0, z: 0 },
+                rot: 0,
+                logId: null,
+                lastMove: 0,
+                moveSeq: 0
+            };
+            
+            players.set(socket.id, player);
 
-        socket.emit('init', {
-            playerId: socket.id,
-            player: player,
-            players: Array.from(players.values()).filter(p => p.id !== socket.id),
-            lanes: lanesData,
-            serverTime: Date.now()
-        });
+            // Send minimal initial state
+            const lanesArr = [];
+            gameState.lanes.forEach((lane) => {
+                lanesArr.push(compactLane(lane));
+            });
+
+            const otherPlayers = [];
+            players.forEach((p, id) => {
+                if (id !== socket.id) {
+                    otherPlayers.push(compactPlayer(p));
+                }
+            });
 
-        socket.broadcast.emit('playerJoined', player);
-        io.emit('leaderboard', getLeaderboard());
+            socket.emit('init', {
+                p: compactPlayer(player),
+                ps: otherPlayers,
+                ls: lanesArr,
+                t: Date.now(),
+                lb: getLeaderboard()
+            });
+
+            // Notify others
+            socket.broadcast.emit('pj', compactPlayer(player));
+            
+            console.log(`[${new Date().toISOString()}] Joined: ${name} (${socket.id})`);
+        } catch (err) {
+            console.error('Join error:', err);
+            socket.emit('err', { m: 'Join failed' });
+        }
     });
 
-    socket.on('move', (data) => {
+    socket.on('m', (data) => { // Move
         const player = players.get(socket.id);
         if (!player) return;
 
         const now = Date.now();
         
-        // Rate limiting - minimum 80ms between moves
-        if (now - player.lastMoveTime < 80) {
-            socket.emit('moveRejected', { reason: 'tooFast' });
+        // Rate limit: 70ms minimum
+        if (now - player.lastMove < 70) {
+            socket.emit('mr', { s: data.s, r: 'fast' });
             return;
         }
 
-        // Can't move while hopping (server-side enforcement)
-        if (player.isHopping) {
-            socket.emit('moveRejected', { reason: 'hopping' });
+        if (player.hopping) {
+            socket.emit('mr', { s: data.s, r: 'hop' });
             return;
         }
 
         if (!player.alive) {
-            socket.emit('moveRejected', { reason: 'dead' });
-            return;
-        }
-
-        const { dx, dz, seq } = data;
-        const validation = validateMove(player, dx, dz);
-
-        if (!validation.valid) {
-            socket.emit('moveRejected', { seq, reason: 'invalid' });
+            socket.emit('mr', { s: data.s, r: 'dead' });
             return;
         }
 
-        // Check collision at target
-        const targetWorldX = validation.targetX * TILE_SIZE;
-        const collisionCheck = checkCollisionAtPosition(
-            validation.targetX, 
-            validation.targetZ, 
-            targetWorldX
-        );
+        const { dx, dz, s } = data;
+        const v = validateMove(player, dx, dz);
 
-        if (collisionCheck.blocked) {
-            socket.emit('moveRejected', { seq, reason: 'blocked' });
+        if (!v.valid) {
+            socket.emit('mr', { s, r: v.reason });
             return;
         }
 
-        // Update player state
-        player.lastMoveTime = now;
-        player.isHopping = true;
-        player.hopStartTime = now;
-        player.hopStartPos = { x: player.worldX, z: player.worldZ };
-        player.hopTargetPos = { x: targetWorldX, z: validation.targetZ * TILE_SIZE };
-        player.gridX = validation.targetX;
-        player.gridZ = validation.targetZ;
-        player.worldX = targetWorldX;
-        player.worldZ = validation.targetZ * TILE_SIZE;
-        player.attachedLog = null;
-
-        // Set rotation
-        if (dx === 1) player.rotation = -Math.PI / 2;
-        else if (dx === -1) player.rotation = Math.PI / 2;
-        else if (dz === 1) player.rotation = 0;
-        else if (dz === -1) player.rotation = Math.PI;
-
-        // Update score
-        if (validation.targetZ > player.score) {
-            player.score = validation.targetZ;
-            io.emit('leaderboard', getLeaderboard());
+        // Execute move
+        player.lastMove = now;
+        player.hopping = true;
+        player.hopTime = now;
+        player.hopStart = { x: player.wx, z: player.wz };
+        player.hopTarget = { x: v.tx * TILE_SIZE, z: v.tz * TILE_SIZE };
+        player.gx = v.tx;
+        player.gz = v.tz;
+        player.wx = v.tx * TILE_SIZE;
+        player.wz = v.tz * TILE_SIZE;
+        player.logId = null;
+        player.moveSeq = s;
+
+        // Rotation
+        if (dx === 1) player.rot = -Math.PI / 2;
+        else if (dx === -1) player.rot = Math.PI / 2;
+        else if (dz === 1) player.rot = 0;
+        else if (dz === -1) player.rot = Math.PI;
+
+        // Score
+        if (v.tz > player.score) {
+            player.score = v.tz;
+            io.emit('lb', getLeaderboard());
         }
 
-        // Generate new lanes if needed
+        // Generate new lanes
         const spawnZ = player.score + 12;
         while (spawnZ > gameState.furthestLaneIndex) {
             gameState.furthestLaneIndex++;
             const prevLane = gameState.lanes.get(gameState.furthestLaneIndex - 1);
             const newLane = generateLaneData(gameState.furthestLaneIndex, prevLane);
             gameState.lanes.set(gameState.furthestLaneIndex, newLane);
-            io.emit('newLane', newLane);
+            io.emit('nl', compactLane(newLane));
         }
 
-        // Confirm move
-        socket.emit('moveConfirmed', {
-            seq,
-            gridX: player.gridX,
-            gridZ: player.gridZ,
-            worldX: player.worldX,
-            worldZ: player.worldZ,
-            score: player.score,
-            serverTime: now
+        // Confirm
+        socket.emit('mc', {
+            s,
+            gx: player.gx,
+            gz: player.gz,
+            sc: player.score,
+            t: now
         });
 
-        // Broadcast to others
-        socket.broadcast.emit('playerMoved', {
+        // Broadcast
+        socket.broadcast.emit('pm', {
             id: player.id,
-            gridX: player.gridX,
-            gridZ: player.gridZ,
-            worldX: player.worldX,
-            worldZ: player.worldZ,
-            rotation: player.rotation,
-            hopStartTime: now,
-            score: player.score
+            gx: player.gx,
+            gz: player.gz,
+            wx: player.wx,
+            wz: player.wz,
+            r: player.rot,
+            t: now,
+            hs: player.hopStart,
+            ht: player.hopTarget
         });
     });
 
-    socket.on('ping', (clientTime) => {
-        socket.emit('pong', { clientTime, serverTime: Date.now() });
+    socket.on('p', (ct) => { // Ping
+        const stats = connectionStats.get(socket.id);
+        if (stats) {
+            stats.lastPing = Date.now();
+        }
+        socket.emit('po', { c: ct, s: Date.now() });
     });
 
-    socket.on('respawn', () => {
+    socket.on('rs', () => { // Respawn
         const player = players.get(socket.id);
         if (!player) return;
 
-        player.gridX = 0;
-        player.gridZ = 0;
-        player.worldX = 0;
-        player.worldZ = 0;
+        player.gx = 0;
+        player.gz = 0;
+        player.wx = 0;
+        player.wz = 0;
         player.score = 0;
         player.alive = true;
-        player.isHopping = false;
-        player.attachedLog = null;
-        player.rotation = 0;
+        player.hopping = false;
+        player.logId = null;
+        player.rot = 0;
 
-        socket.emit('respawned', player);
-        socket.broadcast.emit('playerRespawned', { id: player.id, player });
-        io.emit('leaderboard', getLeaderboard());
+        socket.emit('rsd', compactPlayer(player));
+        socket.broadcast.emit('prs', { id: player.id });
+        io.emit('lb', getLeaderboard());
     });
 
-    socket.on('disconnect', () => {
-        console.log('Player disconnected:', socket.id);
+    socket.on('hb', () => { // Heartbeat
+        socket.emit('hba');
+    });
+
+    socket.on('disconnect', (reason) => {
+        console.log(`[${new Date().toISOString()}] Disconnect: ${socket.id} (${reason})`);
         players.delete(socket.id);
-        io.emit('playerLeft', socket.id);
-        io.emit('leaderboard', getLeaderboard());
+        connectionStats.delete(socket.id);
+        io.emit('pl', socket.id);
+        io.emit('lb', getLeaderboard());
+    });
+
+    socket.on('error', (err) => {
+        console.error(`Socket error ${socket.id}:`, err);
     });
 });
 
-// Game loop
-setInterval(() => {
-    updateObstacles();
+// ============= GAME LOOP =============
+let lastTick = Date.now();
 
-    // Update players
+function gameTick() {
     const now = Date.now();
-    players.forEach((player) => {
-        if (!player.alive) return;
+    const dt = now - lastTick;
+    lastTick = now;
 
-        // Complete hop if time elapsed
-        if (player.isHopping) {
-            if (now - player.hopStartTime >= player.hopDuration) {
-                player.isHopping = false;
+    // Update obstacles
+    gameState.lanes.forEach((lane) => {
+        if (lane.t === 'r' || lane.t === 'w') {
+            lane.timer += dt;
+            
+            if (lane.timer > lane.interval) {
+                const startX = -lane.d * (GRID_WIDTH * TILE_SIZE / 2 + 60);
+                const obsWidth = lane.t === 'w' ? (Math.random() > 0.5 ? 40 : 60) : 12;
                 
-                // Check collision at landing
-                const collision = checkCollisionAtPosition(
-                    player.gridX, 
-                    player.gridZ, 
-                    player.worldX
-                );
+                lane.obs.push({
+                    id: lane.obsId++,
+                    x: startX,
+                    l: lane.t === 'w' ? 1 : 0,
+                    w: obsWidth
+                });
                 
-                if (collision.collision) {
-                    player.alive = false;
-                    io.emit('playerDied', { 
-                        id: player.id, 
-                        type: collision.type 
-                    });
-                    io.emit('leaderboard', getLeaderboard());
-                } else if (collision.onLog) {
-                    player.attachedLog = collision.log;
+                lane.timer = 0;
+                lane.interval = Math.random() * 100 + 200;
+            }
+
+            // Move obstacles
+            for (let i = lane.obs.length - 1; i >= 0; i--) {
+                const obs = lane.obs[i];
+                obs.x += lane.sp * lane.d * (dt / 16.67);
+                if (Math.abs(obs.x) > 400) {
+                    lane.obs.splice(i, 1);
                 }
             }
         }
+    });
 
-        // Move with log
-        if (!player.isHopping && player.attachedLog) {
-            const lane = gameState.lanes.get(player.gridZ);
-            if (lane) {
-                const log = lane.obstacles.find(o => o.id === player.attachedLog.id);
-                if (log) {
-                    player.worldX = log.x;
-                    player.gridX = Math.round(player.worldX / TILE_SIZE);
-                    
-                    // Check if pushed off screen
-                    if (Math.abs(player.worldX) > (GRID_WIDTH * TILE_SIZE / 2 + 10)) {
-                        player.alive = false;
-                        io.emit('playerDied', { id: player.id, type: 'bounds' });
-                        io.emit('leaderboard', getLeaderboard());
-                    }
-                } else {
-                    player.attachedLog = null;
-                    // Fell off log
-                    const collision = checkCollisionAtPosition(
-                        player.gridX, 
-                        player.gridZ, 
-                        player.worldX
-                    );
-                    if (collision.collision && collision.type === 'water') {
+    // Update players
+    players.forEach((player) => {
+        if (!player.alive) return;
+
+        // Complete hop
+        if (player.hopping && now - player.hopTime >= HOP_DURATION) {
+            player.hopping = false;
+            
+            const col = checkCollisionAtPosition(player.gx, player.gz, player.wx);
+            
+            if (col.hit) {
+                player.alive = false;
+                io.emit('pd', { id: player.id, type: col.type });
+                io.emit('lb', getLeaderboard());
+            } else if (col.onLog) {
+                player.logId = col.logId;
+            }
+        }
+
+        // Check collision during hop
+        if (player.hopping) {
+            const progress = (now - player.hopTime) / HOP_DURATION;
+            const cx = player.hopStart.x + (player.hopTarget.x - player.hopStart.x) * progress;
+            const cz = player.hopStart.z + (player.hopTarget.z - player.hopStart.z) * progress;
+            const cgz = Math.round(cz / TILE_SIZE);
+            
+            const lane = gameState.lanes.get(cgz);
+            if (lane && lane.t === 'r') {
+                for (const obs of lane.obs) {
+                    if (Math.abs(cx - obs.x) < (obs.w / 2 + 3)) {
                         player.alive = false;
-                        io.emit('playerDied', { id: player.id, type: 'water' });
-                        io.emit('leaderboard', getLeaderboard());
+                        player.hopping = false;
+                        io.emit('pd', { id: player.id, type: 'car' });
+                        io.emit('lb', getLeaderboard());
+                        break;
                     }
                 }
             }
         }
 
-        // Check car collisions during hop
-        if (player.isHopping) {
-            const hopProgress = (now - player.hopStartTime) / player.hopDuration;
-            const currentX = player.hopStartPos.x + (player.hopTargetPos.x - player.hopStartPos.x) * hopProgress;
-            const currentZ = player.hopStartPos.z + (player.hopTargetPos.z - player.hopStartPos.z) * hopProgress;
-            const currentGridZ = Math.round(currentZ / TILE_SIZE);
-            
-            const lane = gameState.lanes.get(currentGridZ);
-            if (lane && lane.type === 'road') {
-                for (const obs of lane.obstacles) {
-                    const obsLeft = obs.x - obs.width / 2 - 2;
-                    const obsRight = obs.x + obs.width / 2 + 2;
+        // Log riding
+        if (!player.hopping && player.logId !== null) {
+            const lane = gameState.lanes.get(player.gz);
+            if (lane) {
+                const log = lane.obs.find(o => o.id === player.logId);
+                if (log) {
+                    player.wx = log.x;
+                    player.gx = Math.round(player.wx / TILE_SIZE);
                     
-                    if (currentX > obsLeft && currentX < obsRight) {
+                    if (Math.abs(player.wx) > (GRID_WIDTH * TILE_SIZE / 2 + 10)) {
                         player.alive = false;
-                        player.isHopping = false;
-                        io.emit('playerDied', { id: player.id, type: 'car' });
-                        io.emit('leaderboard', getLeaderboard());
-                        break;
+                        io.emit('pd', { id: player.id, type: 'bounds' });
+                        io.emit('lb', getLeaderboard());
+                    }
+                } else {
+                    player.logId = null;
+                    if (lane.t === 'w') {
+                        player.alive = false;
+                        io.emit('pd', { id: player.id, type: 'water' });
+                        io.emit('lb', getLeaderboard());
                     }
                 }
             }
         }
     });
 
-    // Broadcast game state
-    const playersData = Array.from(players.values()).map(p => ({
-        id: p.id,
-        username: p.username,
-        gridX: p.gridX,
-        gridZ: p.gridZ,
-        worldX: p.worldX,
-        worldZ: p.worldZ,
-        rotation: p.rotation,
-        score: p.score,
-        alive: p.alive,
-        isHopping: p.isHopping,
-        hopStartTime: p.hopStartTime,
-        hopStartPos: p.hopStartPos,
-        hopTargetPos: p.hopTargetPos
-    }));
-
-    const obstaclesData = {};
+    // Broadcast state (minimal)
+    const playersData = [];
+    players.forEach(p => playersData.push(compactPlayer(p)));
+
+    const obsData = {};
     gameState.lanes.forEach((lane, key) => {
-        if (lane.type === 'road' || lane.type === 'water') {
-            obstaclesData[key] = lane.obstacles;
+        if (lane.t !== 'g' && lane.obs.length > 0) {
+            obsData[key] = lane.obs.map(o => ({
+                id: o.id,
+                x: Math.round(o.x * 10) / 10
+            }));
         }
     });
 
-    io.emit('gameState', {
-        players: playersData,
-        obstacles: obstaclesData,
-        serverTime: Date.now()
+    io.emit('gs', {
+        ps: playersData,
+        obs: obsData,
+        t: now
     });
+}
 
-}, 1000 / TICK_RATE);
+setInterval(gameTick, 1000 / BASE_TICK_RATE);
 
-// Cleanup old lanes periodically
+// Cleanup old lanes
 setInterval(() => {
     let minZ = Infinity;
     players.forEach(p => {
-        if (p.gridZ < minZ) minZ = p.gridZ;
+        if (p.gz < minZ) minZ = p.gz;
     });
-
     if (minZ === Infinity) minZ = 0;
 
     gameState.lanes.forEach((lane, key) => {
-        if (key < minZ - 10) {
+        if (key < minZ - 15) {
             gameState.lanes.delete(key);
         }
     });
-}, 5000);
+}, 10000);
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+    res.json({ 
+        status: 'ok', 
+        players: players.size,
+        uptime: process.uptime()
+    });
+});
 
 const PORT = process.env.PORT || 7860;
 server.listen(PORT, '0.0.0.0', () => {