Create server.js

server.js

@@ -0,0 +1,434 @@
+const express = require('express');
+const http = require('http');
+const { Server } = require('socket.io');
+const fs = require('fs');
+const path = require('path');
+
+const app = express();
+const server = http.createServer(app);
+const io = new Server(server, {
+    cors: { origin: "*" },
+    pingInterval: 2000,
+    pingTimeout: 5000
+});
+
+app.use(express.static('public'));
+
+// Game constants
+const TICK_RATE = 60;
+const TICK_INTERVAL = 1000 / TICK_RATE;
+const GAME_WIDTH = 540;
+const GAME_HEIGHT = 960;
+const GRAVITY = 0.6;
+const JUMP_FORCE = -17;
+const SPRING_FORCE = -26;
+const PLAYER_WIDTH = 40;
+const PLAYER_HEIGHT = 50;
+const PLATFORM_WIDTH = 70;
+const PLATFORM_HEIGHT = 15;
+const MOVE_SPEED = 8;
+const MAX_FALL_SPEED = 20;
+
+// Leaderboard file path
+const LEADERBOARD_PATH = process.env.NODE_ENV === 'production' 
+    ? '/app/data/leaderboard.json' 
+    : './leaderboard.json';
+
+// Seeded random number generator for deterministic platform generation
+class SeededRandom {
+    constructor(seed) {
+        this.seed = seed % 2147483647;
+        if (this.seed <= 0) this.seed += 2147483646;
+    }
+    
+    next() {
+        this.seed = (this.seed * 16807) % 2147483647;
+        return (this.seed - 1) / 2147483646;
+    }
+    
+    nextRange(min, max) {
+        return min + this.next() * (max - min);
+    }
+    
+    nextInt(min, max) {
+        return Math.floor(this.nextRange(min, max));
+    }
+}
+
+// Global game seed
+const WORLD_SEED = 12345;
+const CHUNK_SIZE = 500;
+
+// Platform types
+const PLATFORM_NORMAL = 0;
+const PLATFORM_MOVING = 1;
+const PLATFORM_BREAKABLE = 2;
+const PLATFORM_SPRING = 3;
+
+// Generate platforms for a chunk
+function generateChunk(chunkIndex) {
+    const rng = new SeededRandom(WORLD_SEED + chunkIndex * 7919);
+    const platforms = [];
+    const chunkTop = -chunkIndex * CHUNK_SIZE;
+    const chunkBottom = chunkTop + CHUNK_SIZE;
+    
+    // Difficulty scaling
+    const difficulty = Math.min(chunkIndex / 20, 1);
+    const platformCount = Math.max(4, Math.floor(8 - difficulty * 3));
+    const verticalSpacing = CHUNK_SIZE / platformCount;
+    
+    for (let i = 0; i < platformCount; i++) {
+        const y = chunkTop + i * verticalSpacing + rng.nextRange(10, verticalSpacing - 30);
+        const x = rng.nextRange(20, GAME_WIDTH - PLATFORM_WIDTH - 20);
+        
+        // Determine platform type
+        let type = PLATFORM_NORMAL;
+        const typeRoll = rng.next();
+        
+        if (chunkIndex > 2) {
+            if (typeRoll < 0.15 * difficulty) {
+                type = PLATFORM_BREAKABLE;
+            } else if (typeRoll < 0.3 * difficulty) {
+                type = PLATFORM_MOVING;
+            } else if (typeRoll < 0.1 + 0.1 * difficulty) {
+                type = PLATFORM_SPRING;
+            }
+        }
+        
+        platforms.push({
+            id: `${chunkIndex}_${i}`,
+            x: x,
+            y: y,
+            width: PLATFORM_WIDTH,
+            height: PLATFORM_HEIGHT,
+            type: type,
+            broken: false,
+            moveDir: type === PLATFORM_MOVING ? (rng.next() > 0.5 ? 1 : -1) : 0,
+            moveSpeed: type === PLATFORM_MOVING ? rng.nextRange(1.5, 3) : 0,
+            originalX: x
+        });
+    }
+    
+    return platforms;
+}
+
+// Game state
+const players = new Map();
+const platformCache = new Map();
+const brokenPlatforms = new Set();
+
+// Get platforms for a range
+function getPlatformsInRange(minY, maxY) {
+    const minChunk = Math.floor(-maxY / CHUNK_SIZE);
+    const maxChunk = Math.floor(-minY / CHUNK_SIZE) + 1;
+    const platforms = [];
+    
+    for (let i = Math.max(0, minChunk); i <= maxChunk; i++) {
+        if (!platformCache.has(i)) {
+            platformCache.set(i, generateChunk(i));
+        }
+        platforms.push(...platformCache.get(i));
+    }
+    
+    return platforms.filter(p => !brokenPlatforms.has(p.id));
+}
+
+// Load leaderboard
+function loadLeaderboard() {
+    try {
+        if (fs.existsSync(LEADERBOARD_PATH)) {
+            const data = fs.readFileSync(LEADERBOARD_PATH, 'utf8');
+            return JSON.parse(data);
+        }
+    } catch (e) {
+        console.log('Creating new leaderboard');
+    }
+    return [];
+}
+
+// Save leaderboard
+function saveLeaderboard(leaderboard) {
+    try {
+        const dir = path.dirname(LEADERBOARD_PATH);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(LEADERBOARD_PATH, JSON.stringify(leaderboard, null, 2));
+    } catch (e) {
+        console.error('Failed to save leaderboard:', e);
+    }
+}
+
+let leaderboard = loadLeaderboard();
+
+// Player class
+class Player {
+    constructor(id, username) {
+        this.id = id;
+        this.username = username;
+        this.x = GAME_WIDTH / 2 - PLAYER_WIDTH / 2;
+        this.y = 0;
+        this.vx = 0;
+        this.vy = 0;
+        this.score = 0;
+        this.highestY = 0;
+        this.input = { left: false, right: false };
+        this.lastProcessedInput = 0;
+        this.alive = true;
+        this.color = this.generateColor();
+        this.facingRight = true;
+    }
+    
+    generateColor() {
+        const hue = Math.random() * 360;
+        return `hsl(${hue}, 70%, 60%)`;
+    }
+    
+    update(platforms) {
+        if (!this.alive) return;
+        
+        // Apply input
+        if (this.input.left) {
+            this.vx = -MOVE_SPEED;
+            this.facingRight = false;
+        } else if (this.input.right) {
+            this.vx = MOVE_SPEED;
+            this.facingRight = true;
+        } else {
+            this.vx *= 0.85;
+        }
+        
+        // Apply gravity
+        this.vy += GRAVITY;
+        this.vy = Math.min(this.vy, MAX_FALL_SPEED);
+        
+        // Update position
+        this.x += this.vx;
+        this.y += this.vy;
+        
+        // Screen wrap
+        if (this.x < -PLAYER_WIDTH) {
+            this.x = GAME_WIDTH;
+        } else if (this.x > GAME_WIDTH) {
+            this.x = -PLAYER_WIDTH;
+        }
+        
+        // Platform collision (only when falling)
+        if (this.vy > 0) {
+            for (const platform of platforms) {
+                if (platform.broken) continue;
+                
+                if (this.checkPlatformCollision(platform)) {
+                    if (platform.type === PLATFORM_BREAKABLE) {
+                        platform.broken = true;
+                        brokenPlatforms.add(platform.id);
+                    }
+                    
+                    this.y = platform.y - PLAYER_HEIGHT;
+                    this.vy = platform.type === PLATFORM_SPRING ? SPRING_FORCE : JUMP_FORCE;
+                    break;
+                }
+            }
+        }
+        
+        // Update score
+        const newScore = Math.floor(-this.y / 10);
+        if (newScore > this.score) {
+            this.score = newScore;
+            if (this.y < this.highestY) {
+                this.highestY = this.y;
+            }
+        }
+        
+        // Check death (fell below screen)
+        const cameraY = this.highestY - GAME_HEIGHT * 0.4;
+        if (this.y > cameraY + GAME_HEIGHT + 100) {
+            this.alive = false;
+        }
+    }
+    
+    checkPlatformCollision(platform) {
+        const playerBottom = this.y + PLAYER_HEIGHT;
+        const playerPrevBottom = playerBottom - this.vy;
+        
+        return this.x + PLAYER_WIDTH > platform.x &&
+               this.x < platform.x + platform.width &&
+               playerPrevBottom <= platform.y &&
+               playerBottom >= platform.y &&
+               playerBottom <= platform.y + platform.height + 10;
+    }
+    
+    reset() {
+        this.x = GAME_WIDTH / 2 - PLAYER_WIDTH / 2;
+        this.y = 0;
+        this.vx = 0;
+        this.vy = 0;
+        this.score = 0;
+        this.highestY = 0;
+        this.alive = true;
+    }
+    
+    getState() {
+        return {
+            id: this.id,
+            username: this.username,
+            x: this.x,
+            y: this.y,
+            vx: this.vx,
+            vy: this.vy,
+            score: this.score,
+            alive: this.alive,
+            color: this.color,
+            facingRight: this.facingRight,
+            lastProcessedInput: this.lastProcessedInput
+        };
+    }
+}
+
+// Socket.io connection handling
+io.on('connection', (socket) => {
+    console.log(`Player connected: ${socket.id}`);
+    
+    socket.on('join', (data) => {
+        const username = (data.username || 'Player').substring(0, 16);
+        const player = new Player(socket.id, username);
+        players.set(socket.id, player);
+        
+        // Send initial state
+        socket.emit('init', {
+            playerId: socket.id,
+            worldSeed: WORLD_SEED,
+            chunkSize: CHUNK_SIZE,
+            leaderboard: leaderboard.slice(0, 10)
+        });
+        
+        console.log(`${username} joined the game`);
+    });
+    
+    socket.on('input', (data) => {
+        const player = players.get(socket.id);
+        if (player && player.alive) {
+            player.input = {
+                left: data.left || false,
+                right: data.right || false
+            };
+            player.lastProcessedInput = data.seq || 0;
+        }
+    });
+    
+    socket.on('restart', () => {
+        const player = players.get(socket.id);
+        if (player) {
+            // Save score to leaderboard
+            if (player.score > 0) {
+                const entry = {
+                    username: player.username,
+                    score: player.score,
+                    date: Date.now()
+                };
+                
+                leaderboard.push(entry);
+                leaderboard.sort((a, b) => b.score - a.score);
+                leaderboard = leaderboard.slice(0, 100);
+                saveLeaderboard(leaderboard);
+                
+                io.emit('leaderboard', leaderboard.slice(0, 10));
+            }
+            
+            player.reset();
+        }
+    });
+    
+    socket.on('disconnect', () => {
+        const player = players.get(socket.id);
+        if (player) {
+            // Save score
+            if (player.score > 0) {
+                const entry = {
+                    username: player.username,
+                    score: player.score,
+                    date: Date.now()
+                };
+                
+                leaderboard.push(entry);
+                leaderboard.sort((a, b) => b.score - a.score);
+                leaderboard = leaderboard.slice(0, 100);
+                saveLeaderboard(leaderboard);
+            }
+        }
+        players.delete(socket.id);
+        console.log(`Player disconnected: ${socket.id}`);
+    });
+});
+
+// Update moving platforms
+function updatePlatforms() {
+    for (const [, platforms] of platformCache) {
+        for (const platform of platforms) {
+            if (platform.type === PLATFORM_MOVING && !platform.broken) {
+                platform.x += platform.moveSpeed * platform.moveDir;
+                
+                if (platform.x <= 20 || platform.x >= GAME_WIDTH - PLATFORM_WIDTH - 20) {
+                    platform.moveDir *= -1;
+                }
+            }
+        }
+    }
+}
+
+// Game loop
+let lastTick = Date.now();
+
+function gameLoop() {
+    const now = Date.now();
+    const delta = now - lastTick;
+    
+    if (delta >= TICK_INTERVAL) {
+        lastTick = now - (delta % TICK_INTERVAL);
+        
+        // Update platforms
+        updatePlatforms();
+        
+        // Update all players
+        for (const [, player] of players) {
+            if (player.alive) {
+                const platforms = getPlatformsInRange(
+                    player.y - GAME_HEIGHT,
+                    player.y + GAME_HEIGHT
+                );
+                player.update(platforms);
+            }
+        }
+        
+        // Broadcast game state
+        const gameState = {
+            timestamp: now,
+            players: Array.from(players.values()).map(p => p.getState()),
+            brokenPlatforms: Array.from(brokenPlatforms)
+        };
+        
+        io.emit('state', gameState);
+    }
+    
+    setImmediate(gameLoop);
+}
+
+// Cleanup old platform cache periodically
+setInterval(() => {
+    const activeMinChunk = Math.min(...Array.from(players.values()).map(p => 
+        Math.floor(-p.y / CHUNK_SIZE) - 2
+    ));
+    
+    for (const [chunk] of platformCache) {
+        if (chunk < activeMinChunk - 5) {
+            platformCache.delete(chunk);
+        }
+    }
+}, 10000);
+
+// Start server
+const PORT = process.env.PORT || 7860;
+server.listen(PORT, '0.0.0.0', () => {
+    console.log(`Server running on port ${PORT}`);
+    gameLoop();
+});