Update server.js

server.js

@@ -6,571 +6,560 @@ const path = require('path');
 const app = express();
 const server = http.createServer(app);
 const io = new Server(server, {
-    cors: { origin: "*" },
-    pingInterval: 1000,
-    pingTimeout: 5000,
-    transports: ['websocket', 'polling']
+    cors: {
+        origin: "*",
+        methods: ["GET", "POST"]
+    },
+    pingTimeout: 60000,
+    pingInterval: 25000
 });
 
 app.use(express.static(path.join(__dirname, 'public')));
 
-// Game Constants
-const TICK_RATE = 20;
-const MAP_SIZE = 3000;
-const MAX_PLAYERS = 50;
-const ORB_COUNT = 200;
-const POWERUP_COUNT = 30;
-const OBSTACLE_COUNT = 50;
-const DANGER_ZONE_SHRINK_RATE = 0.5;
-const SAFE_ZONE_MIN = 500;
-
-// Game State
-const gameState = {
-    players: new Map(),
-    orbs: [],
-    powerups: [],
-    obstacles: [],
-    projectiles: [],
-    killFeed: [],
-    safeZoneRadius: MAP_SIZE / 2,
-    safeZoneCenter: { x: MAP_SIZE / 2, y: MAP_SIZE / 2 },
-    gameTime: 0,
-    roundActive: true
-};
+// Game constants
+const TILE_SIZE = 10;
+const GRID_WIDTH = 13;
+const TICK_RATE = 20; // Server updates per second
+const INTERPOLATION_BUFFER = 100; // ms
 
-// Player Classes
-const CLASSES = {
-    TANK: { health: 150, speed: 0.85, size: 35, damage: 8, ability: 'shield', color: '#4CAF50' },
-    ASSASSIN: { health: 80, speed: 1.3, size: 25, damage: 15, ability: 'dash', color: '#9C27B0' },
-    WARRIOR: { health: 100, speed: 1.0, size: 30, damage: 12, ability: 'charge', color: '#F44336' },
-    MAGE: { health: 70, speed: 1.1, size: 28, damage: 20, ability: 'blast', color: '#2196F3' },
-    BERSERKER: { health: 120, speed: 0.95, size: 32, damage: 10, ability: 'rage', color: '#FF9800' }
+// Game state
+const players = new Map();
+const gameState = {
+    lanes: new Map(),
+    furthestLaneIndex: 14
 };
 
-// Powerup Types
-const POWERUP_TYPES = ['speed', 'damage', 'health', 'shield', 'size', 'magnet', 'ghost', 'rapid'];
+// Lane types and generation
+function generateLaneData(index, prevLane) {
+    let type = 'grass';
+    let runLength = 1;
 
-// Initialize game objects
-function initializeGame() {
-    gameState.orbs = [];
-    gameState.powerups = [];
-    gameState.obstacles = [];
-    
-    // Spawn orbs
-    for (let i = 0; i < ORB_COUNT; i++) {
-        spawnOrb();
+    if (index <= 4) {
+        type = 'grass';
+    } else if (prevLane) {
+        const r = Math.random();
+        
+        if (prevLane.type === 'grass') {
+            if (r < 0.6) type = 'road';
+            else if (r < 0.9) type = 'water';
+            else type = 'grass';
+        } else if (prevLane.type === 'road') {
+            if (prevLane.runLength < 4 && r < 0.7) {
+                type = 'road';
+                runLength = prevLane.runLength + 1;
+            } else {
+                type = 'grass';
+            }
+        } else if (prevLane.type === 'water') {
+            if (prevLane.runLength < 2 && r < 0.6) {
+                type = 'water';
+                runLength = prevLane.runLength + 1;
+            } else {
+                type = 'grass';
+            }
+        }
     }
-    
-    // Spawn powerups
-    for (let i = 0; i < POWERUP_COUNT; i++) {
-        spawnPowerup();
+
+    const staticObstacles = [];
+    if (type === 'grass') {
+        const treeCount = Math.floor(Math.random() * 3);
+        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);
+        }
     }
-    
-    // Spawn obstacles
-    for (let i = 0; i < OBSTACLE_COUNT; i++) {
-        gameState.obstacles.push({
-            id: `obs_${i}`,
-            x: Math.random() * MAP_SIZE,
-            y: Math.random() * MAP_SIZE,
-            radius: 30 + Math.random() * 50,
-            type: Math.random() > 0.7 ? 'bounce' : 'solid'
-        });
+
+    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: [],
+        timer: 0,
+        interval: Math.random() * 100 + 150
+    };
+
+    // Pre-populate obstacles
+    if (type === 'road' || type === 'water') {
+        const count = Math.ceil(Math.random() * 2);
+        for (let i = 0; i < count; i++) {
+            let randX = (Math.random() * 120) - 60;
+            if (Math.abs(randX) < 15) randX += (randX > 0 ? 20 : -20);
+            
+            const obsWidth = type === 'water' 
+                ? (Math.random() > 0.5 ? 4 : 6) * TILE_SIZE 
+                : 12;
+            
+            lane.obstacles.push({
+                id: `${index}-${Date.now()}-${i}`,
+                x: randX,
+                isLog: type === 'water',
+                width: obsWidth,
+                speed: lane.speed * lane.direction
+            });
+        }
     }
+
+    return lane;
 }
 
-function spawnOrb() {
-    const value = Math.random() > 0.9 ? 3 : (Math.random() > 0.7 ? 2 : 1);
-    gameState.orbs.push({
-        id: `orb_${Date.now()}_${Math.random()}`,
-        x: Math.random() * MAP_SIZE,
-        y: Math.random() * MAP_SIZE,
-        value: value,
-        radius: 5 + value * 3
-    });
+// Initialize lanes
+function initializeLanes() {
+    gameState.lanes.clear();
+    for (let i = -4; i < 15; i++) {
+        const prevLane = gameState.lanes.get(i - 1);
+        gameState.lanes.set(i, generateLaneData(i, prevLane));
+    }
+    gameState.furthestLaneIndex = 14;
 }
 
-function spawnPowerup() {
-    gameState.powerups.push({
-        id: `pow_${Date.now()}_${Math.random()}`,
-        x: Math.random() * MAP_SIZE,
-        y: Math.random() * MAP_SIZE,
-        type: POWERUP_TYPES[Math.floor(Math.random() * POWERUP_TYPES.length)],
-        radius: 15
+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);
+                }
+            }
+        }
     });
 }
 
-function createPlayer(id, username, playerClass) {
-    const classData = CLASSES[playerClass] || CLASSES.WARRIOR;
-    return {
-        id,
-        username: username.substring(0, 15),
-        class: playerClass,
-        x: MAP_SIZE / 2 + (Math.random() - 0.5) * 500,
-        y: MAP_SIZE / 2 + (Math.random() - 0.5) * 500,
-        vx: 0,
-        vy: 0,
-        angle: 0,
-        health: classData.health,
-        maxHealth: classData.health,
-        energy: 100,
-        maxEnergy: 100,
-        size: classData.size,
-        baseSize: classData.size,
-        speed: classData.speed,
-        baseSpeed: classData.speed,
-        damage: classData.damage,
-        baseDamage: classData.damage,
-        color: classData.color,
-        score: 0,
-        kills: 0,
-        deaths: 0,
-        killStreak: 0,
-        maxKillStreak: 0,
-        orbsCollected: 0,
-        lastAttack: 0,
-        lastAbility: 0,
-        attackCooldown: 500,
-        abilityCooldown: 5000,
-        ability: classData.ability,
-        effects: {},
-        isAlive: true,
-        respawnTime: 0,
-        invincible: false,
-        lastUpdate: Date.now(),
-        inputSequence: 0,
-        pendingInputs: []
-    };
-}
+// Check collision at position
+function checkCollisionAtPosition(gridX, gridZ, worldX = null) {
+    const lane = gameState.lanes.get(gridZ);
+    if (!lane) return { collision: false };
 
-// Physics and collision
-function distance(a, b) {
-    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
-}
+    const playerX = worldX !== null ? worldX : gridX * TILE_SIZE;
 
-function circleCollision(a, b, radiusA, radiusB) {
-    return distance(a, b) < radiusA + radiusB;
-}
+    // Check bounds
+    if (Math.abs(playerX) > (GRID_WIDTH * TILE_SIZE / 2 + 10)) {
+        return { collision: true, type: 'bounds' };
+    }
 
-function normalizeVector(vx, vy) {
-    const mag = Math.sqrt(vx * vx + vy * vy);
-    if (mag === 0) return { x: 0, y: 0 };
-    return { x: vx / mag, y: vy / mag };
-}
+    // Check static obstacles (trees)
+    if (lane.type === 'grass') {
+        if (lane.staticObstacles.includes(gridX)) {
+            return { collision: true, type: 'tree', blocked: true };
+        }
+        return { collision: false };
+    }
 
-// Game logic
-function processPlayerInput(player, input) {
-    if (!player.isAlive) return;
-    
-    const speed = 8 * player.speed;
-    const { joystickX, joystickY, useAbility, sequence } = input;
-    
-    // Apply movement with dead zone
-    if (Math.abs(joystickX) > 0.1 || Math.abs(joystickY) > 0.1) {
-        const normalized = normalizeVector(joystickX, joystickY);
-        player.vx = normalized.x * speed * Math.min(1, Math.sqrt(joystickX ** 2 + joystickY ** 2));
-        player.vy = normalized.y * speed * Math.min(1, Math.sqrt(joystickX ** 2 + joystickY ** 2));
-        player.angle = Math.atan2(joystickY, joystickX);
-    } else {
-        player.vx *= 0.9;
-        player.vy *= 0.9;
+    // 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' };
+            }
+        }
+        return { collision: false };
     }
-    
-    // Use ability
-    if (useAbility) {
-        usePlayerAbility(player);
+
+    // 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 };
+            }
+        }
+        return { collision: true, type: 'water' };
     }
-    
-    player.inputSequence = sequence;
+
+    return { collision: false };
 }
 
-function usePlayerAbility(player) {
-    const now = Date.now();
-    if (now - player.lastAbility < player.abilityCooldown) return;
-    if (player.energy < 30) return;
-    
-    player.lastAbility = now;
-    player.energy -= 30;
-    
-    switch (player.ability) {
-        case 'dash':
-            player.vx *= 4;
-            player.vy *= 4;
-            player.invincible = true;
-            setTimeout(() => { player.invincible = false; }, 300);
-            break;
-        case 'shield':
-            player.effects.shield = { duration: 3000, startTime: now };
-            player.invincible = true;
-            setTimeout(() => { player.invincible = false; }, 3000);
-            break;
-        case 'charge':
-            const chargeSpeed = 15;
-            player.vx = Math.cos(player.angle) * chargeSpeed;
-            player.vy = Math.sin(player.angle) * chargeSpeed;
-            player.effects.charging = { duration: 500, startTime: now, damage: player.damage * 2 };
-            break;
-        case 'blast':
-            // Area damage
-            gameState.players.forEach((target) => {
-                if (target.id !== player.id && target.isAlive) {
-                    const dist = distance(player, target);
-                    if (dist < 150) {
-                        const damage = player.damage * 2 * (1 - dist / 150);
-                        dealDamage(target, damage, player);
-                    }
-                }
-            });
-            break;
-        case 'rage':
-            player.effects.rage = { duration: 5000, startTime: now };
-            player.damage = player.baseDamage * 1.5;
-            player.speed = player.baseSpeed * 1.3;
-            setTimeout(() => {
-                player.damage = player.baseDamage;
-                player.speed = player.baseSpeed;
-            }, 5000);
-            break;
+// Validate move
+function validateMove(player, dx, dz) {
+    if (!player.alive) return { valid: false };
+    if (dz < 0) return { valid: false }; // No backward
+
+    const targetX = player.gridX + dx;
+    const targetZ = player.gridZ + dz;
+
+    if (Math.abs(targetX) > Math.floor(GRID_WIDTH / 2)) {
+        return { valid: false };
     }
-}
 
-function dealDamage(target, amount, attacker) {
-    if (target.invincible || !target.isAlive) return;
-    
-    target.health -= amount;
-    
-    if (target.health <= 0) {
-        killPlayer(target, attacker);
+    // Check for tree blocking
+    const lane = gameState.lanes.get(targetZ);
+    if (lane && lane.type === 'grass') {
+        if (lane.staticObstacles.includes(targetX)) {
+            return { valid: false };
+        }
     }
+
+    return { valid: true, targetX, targetZ };
 }
 
-function killPlayer(victim, killer) {
-    victim.isAlive = false;
-    victim.deaths++;
-    victim.killStreak = 0;
-    victim.respawnTime = Date.now() + 3000;
+// Get leaderboard
+function getLeaderboard() {
+    const sorted = Array.from(players.values())
+        .filter(p => p.alive || p.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 3);
     
-    if (killer && killer.id !== victim.id) {
-        const streakBonus = Math.min(killer.killStreak, 10) * 10;
-        const sizeBonus = Math.floor(victim.size - victim.baseSize);
-        const killScore = 100 + streakBonus + sizeBonus;
+    return sorted.map((p, i) => ({
+        rank: i + 1,
+        username: p.username,
+        score: p.score
+    }));
+}
+
+// Socket handling
+io.on('connection', (socket) => {
+    console.log('Player connected:', socket.id);
+
+    socket.on('join', (username) => {
+        const sanitizedName = username.substring(0, 15).replace(/[<>]/g, '');
         
-        killer.kills++;
-        killer.killStreak++;
-        killer.maxKillStreak = Math.max(killer.maxKillStreak, killer.killStreak);
-        killer.score += killScore;
-        killer.size = Math.min(killer.size + 2, killer.baseSize * 2);
-        killer.health = Math.min(killer.health + 20, killer.maxHealth);
+        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
+        };
         
-        // Kill feed
-        gameState.killFeed.unshift({
-            killer: killer.username,
-            victim: victim.username,
-            time: Date.now()
+        players.set(socket.id, player);
+
+        // Send initial state
+        const lanesData = {};
+        gameState.lanes.forEach((lane, key) => {
+            lanesData[key] = lane;
         });
-        if (gameState.killFeed.length > 5) gameState.killFeed.pop();
-    }
-    
-    // Drop orbs
-    const orbsToDrop = Math.min(Math.floor(victim.score / 50), 10);
-    for (let i = 0; i < orbsToDrop; i++) {
-        gameState.orbs.push({
-            id: `orb_${Date.now()}_${i}`,
-            x: victim.x + (Math.random() - 0.5) * 50,
-            y: victim.y + (Math.random() - 0.5) * 50,
-            value: 2,
-            radius: 8
+
+        socket.emit('init', {
+            playerId: socket.id,
+            player: player,
+            players: Array.from(players.values()).filter(p => p.id !== socket.id),
+            lanes: lanesData,
+            serverTime: Date.now()
         });
-    }
-}
 
-function respawnPlayer(player) {
-    const classData = CLASSES[player.class];
-    player.isAlive = true;
-    player.health = classData.health;
-    player.energy = 100;
-    player.size = classData.size;
-    player.x = gameState.safeZoneCenter.x + (Math.random() - 0.5) * gameState.safeZoneRadius;
-    player.y = gameState.safeZoneCenter.y + (Math.random() - 0.5) * gameState.safeZoneRadius;
-    player.vx = 0;
-    player.vy = 0;
-    player.invincible = true;
-    player.effects = {};
-    setTimeout(() => { player.invincible = false; }, 2000);
-}
+        socket.broadcast.emit('playerJoined', player);
+        io.emit('leaderboard', getLeaderboard());
+    });
+
+    socket.on('move', (data) => {
+        const player = players.get(socket.id);
+        if (!player) return;
 
-function updatePlayer(player, deltaTime) {
-    if (!player.isAlive) {
-        if (Date.now() >= player.respawnTime) {
-            respawnPlayer(player);
+        const now = Date.now();
+        
+        // Rate limiting - minimum 80ms between moves
+        if (now - player.lastMoveTime < 80) {
+            socket.emit('moveRejected', { reason: 'tooFast' });
+            return;
         }
-        return;
-    }
-    
-    // Apply velocity
-    player.x += player.vx;
-    player.y += player.vy;
-    
-    // Friction
-    player.vx *= 0.95;
-    player.vy *= 0.95;
-    
-    // Boundary check
-    player.x = Math.max(player.size, Math.min(MAP_SIZE - player.size, player.x));
-    player.y = Math.max(player.size, Math.min(MAP_SIZE - player.size, player.y));
-    
-    // Energy regeneration
-    player.energy = Math.min(player.energy + 0.2, player.maxEnergy);
-    
-    // Safe zone damage
-    const distFromCenter = distance(player, gameState.safeZoneCenter);
-    if (distFromCenter > gameState.safeZoneRadius) {
-        const overDistance = distFromCenter - gameState.safeZoneRadius;
-        player.health -= Math.min(overDistance * 0.01, 2);
-        if (player.health <= 0) {
-            killPlayer(player, null);
+
+        // Can't move while hopping (server-side enforcement)
+        if (player.isHopping) {
+            socket.emit('moveRejected', { reason: 'hopping' });
+            return;
         }
-    }
-    
-    // Collision with obstacles
-    gameState.obstacles.forEach(obs => {
-        if (circleCollision(player, obs, player.size, obs.radius)) {
-            const angle = Math.atan2(player.y - obs.y, player.x - obs.x);
-            const overlap = player.size + obs.radius - distance(player, obs);
-            
-            if (obs.type === 'bounce') {
-                player.vx = Math.cos(angle) * 10;
-                player.vy = Math.sin(angle) * 10;
-            } else {
-                player.x += Math.cos(angle) * overlap;
-                player.y += Math.sin(angle) * overlap;
-            }
+
+        if (!player.alive) {
+            socket.emit('moveRejected', { reason: 'dead' });
+            return;
         }
-    });
-    
-    // Auto-attack nearby enemies
-    const now = Date.now();
-    if (now - player.lastAttack > player.attackCooldown) {
-        let closestEnemy = null;
-        let closestDist = player.size + 50;
-        
-        gameState.players.forEach((target) => {
-            if (target.id !== player.id && target.isAlive) {
-                const dist = distance(player, target);
-                if (dist < closestDist) {
-                    closestDist = dist;
-                    closestEnemy = target;
-                }
-            }
-        });
-        
-        if (closestEnemy) {
-            player.lastAttack = now;
-            dealDamage(closestEnemy, player.damage, player);
+
+        const { dx, dz, seq } = data;
+        const validation = validateMove(player, dx, dz);
+
+        if (!validation.valid) {
+            socket.emit('moveRejected', { seq, reason: 'invalid' });
+            return;
         }
-    }
-    
-    // Collect orbs
-    const magnetRange = player.effects.magnet ? 150 : 0;
-    gameState.orbs = gameState.orbs.filter(orb => {
-        const dist = distance(player, orb);
-        
-        // Magnet effect
-        if (magnetRange > 0 && dist < magnetRange) {
-            const angle = Math.atan2(player.y - orb.y, player.x - orb.x);
-            orb.x += Math.cos(angle) * 5;
-            orb.y += Math.sin(angle) * 5;
+
+        // Check collision at target
+        const targetWorldX = validation.targetX * TILE_SIZE;
+        const collisionCheck = checkCollisionAtPosition(
+            validation.targetX, 
+            validation.targetZ, 
+            targetWorldX
+        );
+
+        if (collisionCheck.blocked) {
+            socket.emit('moveRejected', { seq, reason: 'blocked' });
+            return;
         }
-        
-        if (circleCollision(player, orb, player.size, orb.radius)) {
-            player.score += orb.value * 10;
-            player.orbsCollected++;
-            player.size = Math.min(player.size + orb.value * 0.5, player.baseSize * 2);
-            return false;
+
+        // 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());
         }
-        return true;
-    });
-    
-    // Collect powerups
-    gameState.powerups = gameState.powerups.filter(pow => {
-        if (circleCollision(player, pow, player.size, pow.radius)) {
-            applyPowerup(player, pow.type);
-            return false;
+
+        // Generate new lanes if needed
+        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);
         }
-        return true;
+
+        // Confirm move
+        socket.emit('moveConfirmed', {
+            seq,
+            gridX: player.gridX,
+            gridZ: player.gridZ,
+            worldX: player.worldX,
+            worldZ: player.worldZ,
+            score: player.score,
+            serverTime: now
+        });
+
+        // Broadcast to others
+        socket.broadcast.emit('playerMoved', {
+            id: player.id,
+            gridX: player.gridX,
+            gridZ: player.gridZ,
+            worldX: player.worldX,
+            worldZ: player.worldZ,
+            rotation: player.rotation,
+            hopStartTime: now,
+            score: player.score
+        });
     });
-    
-    // Update effects
-    Object.keys(player.effects).forEach(effect => {
-        if (now - player.effects[effect].startTime > player.effects[effect].duration) {
-            delete player.effects[effect];
-        }
+
+    socket.on('ping', (clientTime) => {
+        socket.emit('pong', { clientTime, serverTime: Date.now() });
     });
-}
 
-function applyPowerup(player, type) {
-    const now = Date.now();
-    const duration = 10000;
-    
-    switch (type) {
-        case 'speed':
-            player.speed = player.baseSpeed * 1.5;
-            player.effects.speed = { duration, startTime: now };
-            setTimeout(() => { player.speed = player.baseSpeed; }, duration);
-            break;
-        case 'damage':
-            player.damage = player.baseDamage * 1.5;
-            player.effects.damage = { duration, startTime: now };
-            setTimeout(() => { player.damage = player.baseDamage; }, duration);
-            break;
-        case 'health':
-            player.health = Math.min(player.health + 50, player.maxHealth);
-            break;
-        case 'shield':
-            player.effects.shield = { duration: 5000, startTime: now };
-            player.invincible = true;
-            setTimeout(() => { player.invincible = false; }, 5000);
-            break;
-        case 'size':
-            player.size = Math.min(player.size + 10, player.baseSize * 2);
-            break;
-        case 'magnet':
-            player.effects.magnet = { duration, startTime: now };
-            break;
-        case 'ghost':
-            player.effects.ghost = { duration: 5000, startTime: now };
-            break;
-        case 'rapid':
-            player.attackCooldown = 250;
-            player.effects.rapid = { duration, startTime: now };
-            setTimeout(() => { player.attackCooldown = 500; }, duration);
-            break;
-    }
-}
+    socket.on('respawn', () => {
+        const player = players.get(socket.id);
+        if (!player) return;
+
+        player.gridX = 0;
+        player.gridZ = 0;
+        player.worldX = 0;
+        player.worldZ = 0;
+        player.score = 0;
+        player.alive = true;
+        player.isHopping = false;
+        player.attachedLog = null;
+        player.rotation = 0;
+
+        socket.emit('respawned', player);
+        socket.broadcast.emit('playerRespawned', { id: player.id, player });
+        io.emit('leaderboard', getLeaderboard());
+    });
+
+    socket.on('disconnect', () => {
+        console.log('Player disconnected:', socket.id);
+        players.delete(socket.id);
+        io.emit('playerLeft', socket.id);
+        io.emit('leaderboard', getLeaderboard());
+    });
+});
+
+// Game loop
+setInterval(() => {
+    updateObstacles();
 
-function updateGame() {
-    const now = Date.now();
-    gameState.gameTime++;
-    
-    // Shrink safe zone
-    if (gameState.safeZoneRadius > SAFE_ZONE_MIN && gameState.gameTime % 100 === 0) {
-        gameState.safeZoneRadius -= DANGER_ZONE_SHRINK_RATE;
-    }
-    
     // Update players
-    gameState.players.forEach(player => {
-        updatePlayer(player, 1 / TICK_RATE);
+    const now = Date.now();
+    players.forEach((player) => {
+        if (!player.alive) return;
+
+        // Complete hop if time elapsed
+        if (player.isHopping) {
+            if (now - player.hopStartTime >= player.hopDuration) {
+                player.isHopping = false;
+                
+                // Check collision at landing
+                const collision = checkCollisionAtPosition(
+                    player.gridX, 
+                    player.gridZ, 
+                    player.worldX
+                );
+                
+                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;
+                }
+            }
+        }
+
+        // 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') {
+                        player.alive = false;
+                        io.emit('playerDied', { id: player.id, type: 'water' });
+                        io.emit('leaderboard', getLeaderboard());
+                    }
+                }
+            }
+        }
+
+        // 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;
+                    
+                    if (currentX > obsLeft && currentX < obsRight) {
+                        player.alive = false;
+                        player.isHopping = false;
+                        io.emit('playerDied', { id: player.id, type: 'car' });
+                        io.emit('leaderboard', getLeaderboard());
+                        break;
+                    }
+                }
+            }
+        }
     });
-    
-    // Respawn orbs
-    while (gameState.orbs.length < ORB_COUNT) {
-        spawnOrb();
-    }
-    
-    // Respawn powerups
-    while (gameState.powerups.length < POWERUP_COUNT) {
-        spawnPowerup();
-    }
-    
-    // Send game state to all players
-    const playersArray = Array.from(gameState.players.values()).map(p => ({
+
+    // Broadcast game state
+    const playersData = Array.from(players.values()).map(p => ({
         id: p.id,
         username: p.username,
-        class: p.class,
-        x: Math.round(p.x),
-        y: Math.round(p.y),
-        vx: Math.round(p.vx * 100) / 100,
-        vy: Math.round(p.vy * 100) / 100,
-        angle: Math.round(p.angle * 100) / 100,
-        health: Math.round(p.health),
-        maxHealth: p.maxHealth,
-        energy: Math.round(p.energy),
-        size: Math.round(p.size),
+        gridX: p.gridX,
+        gridZ: p.gridZ,
+        worldX: p.worldX,
+        worldZ: p.worldZ,
+        rotation: p.rotation,
         score: p.score,
-        kills: p.kills,
-        killStreak: p.killStreak,
-        color: p.color,
-        isAlive: p.isAlive,
-        invincible: p.invincible,
-        effects: Object.keys(p.effects),
-        seq: p.inputSequence
+        alive: p.alive,
+        isHopping: p.isHopping,
+        hopStartTime: p.hopStartTime,
+        hopStartPos: p.hopStartPos,
+        hopTargetPos: p.hopTargetPos
     }));
-    
-    const leaderboard = playersArray
-        .filter(p => p.isAlive)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, 10)
-        .map((p, i) => ({ rank: i + 1, username: p.username, score: p.score, kills: p.kills }));
-    
-    const gameUpdate = {
-        players: playersArray,
-        orbs: gameState.orbs.map(o => ({ id: o.id, x: Math.round(o.x), y: Math.round(o.y), v: o.value })),
-        powerups: gameState.powerups.map(p => ({ id: p.id, x: Math.round(p.x), y: Math.round(p.y), t: p.type })),
-        obstacles: gameState.obstacles,
-        safeZone: {
-            x: Math.round(gameState.safeZoneCenter.x),
-            y: Math.round(gameState.safeZoneCenter.y),
-            r: Math.round(gameState.safeZoneRadius)
-        },
-        killFeed: gameState.killFeed,
-        leaderboard,
-        time: now,
-        playerCount: gameState.players.size
-    };
-    
-    io.emit('gameState', gameUpdate);
-}
 
-// Socket.io handling
-io.on('connection', (socket) => {
-    console.log(`Player connected: ${socket.id}`);
-    
-    socket.on('join', (data) => {
-        if (gameState.players.size >= MAX_PLAYERS) {
-            socket.emit('error', { message: 'Server full!' });
-            return;
-        }
-        
-        const { username, playerClass } = data;
-        if (!username || username.trim().length < 1) {
-            socket.emit('error', { message: 'Invalid username!' });
-            return;
+    const obstaclesData = {};
+    gameState.lanes.forEach((lane, key) => {
+        if (lane.type === 'road' || lane.type === 'water') {
+            obstaclesData[key] = lane.obstacles;
         }
-        
-        const player = createPlayer(socket.id, username.trim(), playerClass || 'WARRIOR');
-        gameState.players.set(socket.id, player);
-        
-        socket.emit('joined', {
-            id: socket.id,
-            mapSize: MAP_SIZE,
-            classes: CLASSES
-        });
-        
-        console.log(`${username} joined as ${playerClass}`);
     });
-    
-    socket.on('input', (input) => {
-        const player = gameState.players.get(socket.id);
-        if (player) {
-            processPlayerInput(player, input);
-        }
+
+    io.emit('gameState', {
+        players: playersData,
+        obstacles: obstaclesData,
+        serverTime: Date.now()
     });
-    
-    socket.on('ping', (startTime) => {
-        socket.emit('pong', startTime);
+
+}, 1000 / TICK_RATE);
+
+// Cleanup old lanes periodically
+setInterval(() => {
+    let minZ = Infinity;
+    players.forEach(p => {
+        if (p.gridZ < minZ) minZ = p.gridZ;
     });
-    
-    socket.on('disconnect', () => {
-        const player = gameState.players.get(socket.id);
-        if (player) {
-            console.log(`${player.username} disconnected`);
+
+    if (minZ === Infinity) minZ = 0;
+
+    gameState.lanes.forEach((lane, key) => {
+        if (key < minZ - 10) {
+            gameState.lanes.delete(key);
         }
-        gameState.players.delete(socket.id);
     });
-});
-
-// Initialize and start
-initializeGame();
-setInterval(updateGame, 1000 / TICK_RATE);
+}, 5000);
 
 const PORT = process.env.PORT || 7860;
 server.listen(PORT, '0.0.0.0', () => {