Update server.js

server.js

@@ -1,202 +1,578 @@
 const express = require('express');
 const http = require('http');
 const { Server } = require('socket.io');
+const path = require('path');
 
 const app = express();
 const server = http.createServer(app);
 const io = new Server(server, {
     cors: { origin: "*" },
-    pingTimeout: 60000,
+    pingInterval: 1000,
+    pingTimeout: 5000,
+    transports: ['websocket', 'polling']
 });
 
-app.use(express.static('public'));
-
-// --- 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("-----------------------------------------------------------");
+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
+};
+
+// 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' }
+};
+
+// Powerup Types
+const POWERUP_TYPES = ['speed', 'damage', 'health', 'shield', 'size', 'magnet', 'ghost', 'rapid'];
+
+// Initialize game objects
+function initializeGame() {
+    gameState.orbs = [];
+    gameState.powerups = [];
+    gameState.obstacles = [];
+    
+    // Spawn orbs
+    for (let i = 0; i < ORB_COUNT; i++) {
+        spawnOrb();
+    }
+    
+    // Spawn powerups
+    for (let i = 0; i < POWERUP_COUNT; i++) {
+        spawnPowerup();
+    }
+    
+    // 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'
+        });
     }
 }
-loadCodes();
 
-// --- GAME STATE ---
-let platforms = [];
-let players = {}; 
+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
+    });
+}
+
+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
+    });
+}
 
-function generatePlatform(prevX, prevW) {
-    const gap = 80 + Math.random() * 120;
-    const width = 40 + Math.random() * 60;
+function createPlayer(id, username, playerClass) {
+    const classData = CLASSES[playerClass] || CLASSES.WARRIOR;
     return {
-        x: prevX + prevW + gap,
-        w: width,
-        id: Math.random().toString(36).substr(2, 9)
+        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: []
     };
 }
 
-// Init World
-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));
+// Physics and collision
+function distance(a, b) {
+    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
 }
 
-io.on('connection', (socket) => {
-    let isAuthenticated = false;
+function circleCollision(a, b, radiusA, radiusB) {
+    return distance(a, b) < radiusA + radiusB;
+}
 
-    // 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;
-        }
+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 };
+}
 
-        isAuthenticated = true;
-        const cleanName = (name || "Guest").substring(0, 12);
+// 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;
+    }
+    
+    // Use ability
+    if (useAbility) {
+        usePlayerAbility(player);
+    }
+    
+    player.inputSequence = sequence;
+}
 
-        // 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
-        });
+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;
+    }
+}
 
-        // Broadcast to others
-        socket.broadcast.emit('player_join', players[socket.id]);
-    });
+function dealDamage(target, amount, attacker) {
+    if (target.invincible || !target.isAlive) return;
+    
+    target.health -= amount;
+    
+    if (target.health <= 0) {
+        killPlayer(target, attacker);
+    }
+}
 
-    // 2. Start Growing (Timestamp Authoritative)
-    socket.on('start_grow', () => {
-        if (!isAuthenticated || !players[socket.id]) return;
-        const p = players[socket.id];
+function killPlayer(victim, killer) {
+    victim.isAlive = false;
+    victim.deaths++;
+    victim.killStreak = 0;
+    victim.respawnTime = Date.now() + 3000;
+    
+    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;
         
-        p.isGrowing = true;
-        p.growStartTime = Date.now();
+        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);
         
-        // Relay to others for visual interpolation
-        socket.broadcast.emit('player_action', { id: socket.id, type: 'grow_start' });
-    });
-
-    // 3. Stop Growing (The Physics Check)
-    socket.on('stop_grow', () => {
-        if (!isAuthenticated || !players[socket.id]) return;
-        const p = players[socket.id];
-        if (!p.isGrowing) return;
-
-        const duration = Date.now() - p.growStartTime;
-        p.isGrowing = false;
-
-        // 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 });
+        // Kill feed
+        gameState.killFeed.unshift({
+            killer: killer.username,
+            victim: victim.username,
+            time: Date.now()
+        });
+        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
+        });
+    }
+}
 
-        // --- SERVER PHYSICS CHECK ---
-        const currentPlat = platforms[p.currentPlatIndex];
-        const nextPlat = platforms[p.currentPlatIndex + 1];
+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);
+}
 
-        // Generate map if running out
-        if (!nextPlat) {
-             const last = platforms[platforms.length - 1];
-             const newPlat = generatePlatform(last.x, last.w);
-             platforms.push(newPlat);
-             io.emit('new_platform', newPlat);
+function updatePlayer(player, deltaTime) {
+    if (!player.isAlive) {
+        if (Date.now() >= player.respawnTime) {
+            respawnPlayer(player);
         }
-        
-        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;
+        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);
         }
-
-        // Wait for animation duration (simulated) then update state
-        setTimeout(() => {
-            if (success) {
-                p.score += perfect ? 2 : 1;
-                p.currentPlatIndex++;
-                p.x = nextPlat.x + nextPlat.w - PLAYER_SIZE - 5; // Target X
-                
-                // 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);
-                }
+    }
+    
+    // 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 {
-                p.score = 0;
-                p.currentPlatIndex = 0;
-                p.x = platforms[0].x + platforms[0].w - PLAYER_SIZE - 5; // Reset X
+                player.x += Math.cos(angle) * overlap;
+                player.y += Math.sin(angle) * overlap;
+            }
+        }
+    });
+    
+    // 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);
+        }
+    }
+    
+    // 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;
+        }
+        
+        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;
+        }
+        return true;
+    });
+    
+    // Collect powerups
+    gameState.powerups = gameState.powerups.filter(pow => {
+        if (circleCollision(player, pow, player.size, pow.radius)) {
+            applyPowerup(player, pow.type);
+            return false;
+        }
+        return true;
+    });
+    
+    // Update effects
+    Object.keys(player.effects).forEach(effect => {
+        if (now - player.effects[effect].startTime > player.effects[effect].duration) {
+            delete player.effects[effect];
+        }
+    });
+}
 
-            // 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 
-            });
+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;
+    }
+}
 
-        }, 1000); // 1s represents the fall/walk animation time
+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);
     });
+    
+    // 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 => ({
+        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),
+        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
+    }));
+    
+    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 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);
+        }
+    });
+    
+    socket.on('ping', (startTime) => {
+        socket.emit('pong', startTime);
+    });
+    
     socket.on('disconnect', () => {
-        if (players[socket.id]) {
-            delete players[socket.id];
-            io.emit('player_leave', socket.id);
+        const player = gameState.players.get(socket.id);
+        if (player) {
+            console.log(`${player.username} disconnected`);
         }
+        gameState.players.delete(socket.id);
     });
 });
 
-const PORT = process.env.PORT || 3000;
-server.listen(PORT, () => console.log(`Server running on port ${PORT}`));
+// Initialize and start
+initializeGame();
+setInterval(updateGame, 1000 / TICK_RATE);
+
+const PORT = process.env.PORT || 7860;
+server.listen(PORT, '0.0.0.0', () => {
+    console.log(`Server running on port ${PORT}`);
+});