csterm-server 1.0.0

package/dist/Room.js

@@ -0,0 +1,498 @@
+// Single game room for CS-CLI multiplayer server
+import { WebSocket } from 'ws';
+import { serializeServerMessage, } from './protocol.js';
+import { createVec3, } from './types.js';
+import { GameRunner } from './GameRunner.js';
+import { LockstepRunner } from './LockstepRunner.js';
+import { getVoiceRelay, removeVoiceRelay, isVoiceFrame } from './VoiceRelay.js';
+// Enable lockstep mode (set to true to use deterministic lockstep)
+const USE_LOCKSTEP = true;
+// Default map data for dm_arena
+const DEFAULT_MAP = {
+    id: 'dm_arena',
+    name: 'DM Arena',
+    spawnPoints: [
+        // DM spawns
+        { position: createVec3(-48, 0.1, -48), angle: 45 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(48, 0.1, -48), angle: 135 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(-48, 0.1, 48), angle: -45 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(48, 0.1, 48), angle: -135 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(-28, 0.1, -28), angle: 45 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(28, 0.1, -28), angle: 135 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(-28, 0.1, 28), angle: -45 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(28, 0.1, 28), angle: -135 * Math.PI / 180, team: 'DM' },
+        { position: createVec3(0, 0.1, -35), angle: Math.PI, team: 'DM' },
+        { position: createVec3(0, 0.1, 35), angle: 0, team: 'DM' },
+        { position: createVec3(-35, 0.1, 0), angle: Math.PI / 2, team: 'DM' },
+        { position: createVec3(35, 0.1, 0), angle: -Math.PI / 2, team: 'DM' },
+        // T spawns (south)
+        { position: createVec3(-20, 0.1, 48), angle: 0, team: 'T' },
+        { position: createVec3(0, 0.1, 50), angle: 0, team: 'T' },
+        { position: createVec3(20, 0.1, 48), angle: 0, team: 'T' },
+        { position: createVec3(-35, 0.1, 42), angle: 0, team: 'T' },
+        { position: createVec3(35, 0.1, 42), angle: 0, team: 'T' },
+        // CT spawns (north)
+        { position: createVec3(-20, 0.1, -48), angle: Math.PI, team: 'CT' },
+        { position: createVec3(0, 0.1, -50), angle: Math.PI, team: 'CT' },
+        { position: createVec3(20, 0.1, -48), angle: Math.PI, team: 'CT' },
+        { position: createVec3(-35, 0.1, -42), angle: Math.PI, team: 'CT' },
+        { position: createVec3(35, 0.1, -42), angle: Math.PI, team: 'CT' },
+    ],
+    colliders: [
+        // Outer walls
+        { min: createVec3(-60, 0, -59), max: createVec3(60, 12, -57) },
+        { min: createVec3(-60, 0, 57), max: createVec3(60, 12, 59) },
+        { min: createVec3(57, 0, -58), max: createVec3(59, 12, 58) },
+        { min: createVec3(-59, 0, -58), max: createVec3(-57, 12, 58) },
+        // Central pillar
+        { min: createVec3(-2.5, 0, -2.5), max: createVec3(2.5, 8, 2.5) },
+        // Buildings
+        { min: createVec3(-41, 0, -40), max: createVec3(-29, 6, -30) },
+        { min: createVec3(29, 0, -41), max: createVec3(40, 6, -29) },
+        { min: createVec3(-40, 0, 29), max: createVec3(-30, 6, 41) },
+        { min: createVec3(29, 0, 29), max: createVec3(41, 6, 41) },
+    ],
+    bounds: {
+        min: createVec3(-60, 0, -60),
+        max: createVec3(60, 20, 60),
+    },
+};
+// Bot names
+const BOT_NAMES = [
+    'Alpha', 'Bravo', 'Charlie', 'Delta', 'Echo',
+    'Foxtrot', 'Golf', 'Hotel', 'India', 'Juliet',
+];
+export class Room {
+    id;
+    config;
+    hostId;
+    lastActivity;
+    clients = new Map();
+    gameRunner = null;
+    lockstepRunner = null;
+    serverConfig;
+    mapData;
+    // Team assignments
+    teamAssignments = new Map();
+    // Voice relay
+    voiceRelay;
+    constructor(id, config, hostId, serverConfig) {
+        this.id = id;
+        this.config = config;
+        this.hostId = hostId;
+        this.serverConfig = serverConfig;
+        this.lastActivity = Date.now();
+        this.mapData = DEFAULT_MAP;
+        this.voiceRelay = getVoiceRelay(id);
+    }
+    // ============ Player Management ============
+    addPlayer(clientId, client) {
+        console.log(`[Room] Adding player ${clientId} (${client.name}). Existing clients: ${this.clients.size}`);
+        // Helper to send directly to new joiner's socket (since they're not in this.clients yet)
+        const sendToNewJoiner = (message) => {
+            if (client.socket.readyState === WebSocket.OPEN) {
+                try {
+                    client.socket.send(serializeServerMessage(message));
+                }
+                catch (e) {
+                    // Ignore send errors
+                }
+            }
+        };
+        // Send existing players to new joiner BEFORE adding them
+        for (const [existingId, existingClient] of this.clients) {
+            console.log(`[Room] Sending existing player ${existingId} to new joiner ${clientId}`);
+            sendToNewJoiner({
+                type: 'player_joined',
+                playerId: existingId,
+                playerName: existingClient.name || 'Player',
+            });
+            // Send their team assignment
+            const existingTeam = this.teamAssignments.get(existingId);
+            console.log(`[Room] Existing player ${existingId} team: ${existingTeam}`);
+            if (existingTeam) {
+                sendToNewJoiner({
+                    type: 'player_team_changed',
+                    playerId: existingId,
+                    team: existingTeam,
+                });
+            }
+            // Also send their ready state
+            if (existingClient.isReady) {
+                sendToNewJoiner({
+                    type: 'player_ready',
+                    playerId: existingId,
+                    ready: true,
+                });
+            }
+        }
+        this.clients.set(clientId, client);
+        this.lastActivity = Date.now();
+        // Broadcast new player to all OTHER clients
+        this.broadcastExcept(clientId, {
+            type: 'player_joined',
+            playerId: clientId,
+            playerName: client.name || 'Player',
+        });
+        // Assign team
+        const team = this.assignTeam(clientId);
+        this.teamAssignments.set(clientId, team);
+        // Send team assignment
+        this.sendToClient(clientId, {
+            type: 'assigned_team',
+            team,
+        });
+        // If game is running, spawn the player
+        if (USE_LOCKSTEP && this.lockstepRunner) {
+            this.lockstepRunner.addPlayer(clientId, client.name || 'Player', team);
+        }
+        else if (this.gameRunner) {
+            this.gameRunner.addPlayer(clientId, client.name || 'Player', team);
+        }
+    }
+    removePlayer(clientId) {
+        this.clients.delete(clientId);
+        this.teamAssignments.delete(clientId);
+        this.lastActivity = Date.now();
+        if (USE_LOCKSTEP && this.lockstepRunner) {
+            this.lockstepRunner.removePlayer(clientId);
+        }
+        else if (this.gameRunner) {
+            this.gameRunner.removePlayer(clientId);
+        }
+        // Transfer host if needed
+        if (clientId === this.hostId && this.clients.size > 0) {
+            this.hostId = this.clients.keys().next().value;
+            console.log(`Host transferred to ${this.hostId}`);
+        }
+    }
+    getPlayerCount() {
+        return this.clients.size;
+    }
+    // ============ Team Management ============
+    assignTeam(clientId) {
+        // Count current teams
+        let tCount = 0;
+        let ctCount = 0;
+        for (const team of this.teamAssignments.values()) {
+            if (team === 'T')
+                tCount++;
+            else if (team === 'CT')
+                ctCount++;
+        }
+        // Assign to smaller team, or random if equal
+        if (tCount < ctCount)
+            return 'T';
+        if (ctCount < tCount)
+            return 'CT';
+        return Math.random() < 0.5 ? 'T' : 'CT';
+    }
+    // ============ Game Control ============
+    startGame() {
+        if (USE_LOCKSTEP) {
+            this.startLockstepGame();
+        }
+        else {
+            this.startServerAuthoritativeGame();
+        }
+    }
+    startLockstepGame() {
+        if (this.lockstepRunner) {
+            // Already running, don't restart
+            return;
+        }
+        console.log(`[Room] Starting lockstep game in room ${this.id}`);
+        // Notify clients game is starting
+        this.broadcast({
+            type: 'game_starting',
+            countdown: 0,
+        });
+        // Create lockstep runner (no bots in lockstep mode)
+        this.lockstepRunner = new LockstepRunner(this.mapData, this.config, this.serverConfig, (msg) => this.broadcast(msg), (clientId, msg) => this.sendToClient(clientId, msg));
+        // Add all connected players
+        for (const [clientId, client] of this.clients) {
+            const team = this.teamAssignments.get(clientId) || 'T';
+            this.lockstepRunner.addPlayer(clientId, client.name || 'Player', team);
+        }
+        // Start the lockstep runner
+        this.lockstepRunner.start();
+        console.log(`Lockstep game started in room ${this.id}`);
+    }
+    startServerAuthoritativeGame() {
+        if (this.gameRunner) {
+            // Already running, don't restart
+            return;
+        }
+        // Notify clients game is starting
+        this.broadcast({
+            type: 'game_starting',
+            countdown: 0, // Start immediately
+        });
+        // Create game state
+        const gameState = this.createInitialGameState();
+        // Create game runner
+        this.gameRunner = new GameRunner(gameState, this.mapData, this.config, this.serverConfig, (msg) => this.broadcast(msg), (clientId, msg) => this.sendToClient(clientId, msg));
+        // Add all connected players
+        for (const [clientId, client] of this.clients) {
+            const team = this.teamAssignments.get(clientId) || 'T';
+            this.gameRunner.addPlayer(clientId, client.name || 'Player', team);
+        }
+        // Add bots - balance teams based on current player assignments
+        let tCount = 0;
+        let ctCount = 0;
+        for (const team of this.teamAssignments.values()) {
+            if (team === 'T')
+                tCount++;
+            else if (team === 'CT')
+                ctCount++;
+        }
+        for (let i = 0; i < this.config.botCount; i++) {
+            const botName = BOT_NAMES[i % BOT_NAMES.length];
+            // Assign bot to smaller team
+            let team;
+            if (tCount < ctCount) {
+                team = 'T';
+                tCount++;
+            }
+            else if (ctCount < tCount) {
+                team = 'CT';
+                ctCount++;
+            }
+            else {
+                // Equal - alternate
+                team = i % 2 === 0 ? 'T' : 'CT';
+                if (team === 'T')
+                    tCount++;
+                else
+                    ctCount++;
+            }
+            this.gameRunner.addBot(botName, team, this.config.botDifficulty);
+        }
+        // Start the game
+        this.gameRunner.start();
+        // Notify players
+        this.broadcast({
+            type: 'phase_change',
+            phase: 'warmup',
+            roundNumber: 0,
+            tScore: 0,
+            ctScore: 0,
+        });
+        console.log(`Server-authoritative game started in room ${this.id}`);
+    }
+    createInitialGameState() {
+        return {
+            phase: 'pre_match',
+            phaseStartTime: Date.now(),
+            roundNumber: 0,
+            tScore: 0,
+            ctScore: 0,
+            roundWinner: null,
+            players: new Map(),
+            bots: new Map(),
+            droppedWeapons: new Map(),
+            tick: 0,
+            lastBroadcastTick: 0,
+        };
+    }
+    stop() {
+        if (this.lockstepRunner) {
+            this.lockstepRunner.stop();
+            this.lockstepRunner = null;
+        }
+        if (this.gameRunner) {
+            this.gameRunner.stop();
+            this.gameRunner = null;
+        }
+        // Clear voice relay
+        this.voiceRelay.clear();
+    }
+    /**
+     * Full cleanup when room is destroyed
+     */
+    destroy() {
+        this.stop();
+        removeVoiceRelay(this.id);
+    }
+    // ============ Message Handling ============
+    handleMessage(clientId, message) {
+        this.lastActivity = Date.now();
+        switch (message.type) {
+            case 'ready':
+                this.handleReady(clientId);
+                break;
+            case 'start_game':
+                this.handleStartGame(clientId);
+                break;
+            case 'change_team':
+                if ('team' in message) {
+                    this.handleChangeTeam(clientId, message.team);
+                }
+                break;
+            case 'lockstep_input':
+                // Handle lockstep input
+                if (USE_LOCKSTEP && this.lockstepRunner && 'tick' in message && 'input' in message) {
+                    this.lockstepRunner.handleLockstepInput(clientId, message.tick, message.input, message.actions || [], message.position || { x: 0, y: 0, z: 0 }, message.yaw || 0, message.pitch || 0, message.health ?? 100, message.isAlive ?? true);
+                }
+                break;
+            case 'lockstep_sync':
+                // Handle lockstep sync check
+                if (USE_LOCKSTEP && this.lockstepRunner && 'tick' in message && 'hash' in message) {
+                    this.lockstepRunner.handleSyncCheck(clientId, message.tick, message.hash);
+                }
+                break;
+            case 'input':
+            case 'fire':
+            case 'reload':
+            case 'buy_weapon':
+            case 'pickup_weapon':
+            case 'drop_weapon':
+            case 'select_weapon':
+                // Forward to game runner (server-authoritative mode only)
+                if (!USE_LOCKSTEP && this.gameRunner) {
+                    this.gameRunner.handleInput(clientId, message);
+                }
+                break;
+            case 'chat':
+                this.handleChat(clientId, message.message, message.teamOnly);
+                break;
+            default:
+                break;
+        }
+    }
+    handleReady(clientId) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        client.isReady = !client.isReady;
+        this.broadcast({
+            type: 'player_ready',
+            playerId: clientId,
+            ready: client.isReady,
+        });
+    }
+    handleStartGame(clientId) {
+        // Only host can start
+        if (clientId !== this.hostId)
+            return;
+        // Check if all players are ready (or just the host for now)
+        this.startGame();
+    }
+    handleChangeTeam(clientId, team) {
+        if (team !== 'T' && team !== 'CT')
+            return;
+        this.teamAssignments.set(clientId, team);
+        // Send team assignment back to player
+        this.sendToClient(clientId, {
+            type: 'assigned_team',
+            team,
+        });
+        // Broadcast team change to all players
+        this.broadcast({
+            type: 'player_team_changed',
+            playerId: clientId,
+            team,
+        });
+        console.log(`Player ${clientId} changed to team ${team}`);
+    }
+    handleChat(clientId, message, teamOnly) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return;
+        const chatMessage = {
+            type: 'chat_received',
+            senderId: clientId,
+            senderName: client.name || 'Unknown',
+            message,
+            teamOnly,
+        };
+        if (teamOnly) {
+            // Only send to same team
+            const senderTeam = this.teamAssignments.get(clientId);
+            for (const [id, _] of this.clients) {
+                if (this.teamAssignments.get(id) === senderTeam) {
+                    this.sendToClient(id, chatMessage);
+                }
+            }
+        }
+        else {
+            this.broadcast(chatMessage);
+        }
+    }
+    // ============ Voice Relay ============
+    /**
+     * Handle binary data (voice frames)
+     * Returns true if it was a voice frame
+     */
+    handleBinaryData(clientId, data) {
+        let uint8Data;
+        if (data instanceof ArrayBuffer) {
+            uint8Data = new Uint8Array(data);
+        }
+        else if (Buffer.isBuffer(data)) {
+            uint8Data = new Uint8Array(data.buffer, data.byteOffset, data.length);
+        }
+        else {
+            uint8Data = data;
+        }
+        if (!isVoiceFrame(uint8Data)) {
+            return false;
+        }
+        this.lastActivity = Date.now();
+        this.voiceRelay.relayVoiceFrame(uint8Data, clientId, this.clients, this.teamAssignments);
+        return true;
+    }
+    // ============ Communication ============
+    broadcast(message) {
+        const data = serializeServerMessage(message);
+        for (const client of this.clients.values()) {
+            if (client.socket.readyState === WebSocket.OPEN) {
+                try {
+                    client.socket.send(data);
+                }
+                catch (e) {
+                    // Ignore send errors
+                }
+            }
+        }
+    }
+    broadcastExcept(excludeId, message) {
+        const data = serializeServerMessage(message);
+        for (const [id, client] of this.clients) {
+            if (id !== excludeId && client.socket.readyState === WebSocket.OPEN) {
+                try {
+                    client.socket.send(data);
+                }
+                catch (e) {
+                    // Ignore send errors
+                }
+            }
+        }
+    }
+    sendToClient(clientId, message) {
+        const client = this.clients.get(clientId);
+        if (!client || client.socket.readyState !== WebSocket.OPEN)
+            return;
+        try {
+            client.socket.send(serializeServerMessage(message));
+        }
+        catch (e) {
+            // Ignore send errors
+        }
+    }
+    // ============ Info ============
+    getInfo() {
+        return {
+            id: this.id,
+            name: this.config.name,
+            map: this.config.map,
+            mode: this.config.mode,
+            playerCount: this.clients.size,
+            maxPlayers: this.config.maxPlayers,
+            botCount: this.config.botCount,
+            isPrivate: this.config.isPrivate,
+            phase: this.lockstepRunner?.getPhase() || this.gameRunner?.getPhase() || 'pre_match',
+            hostId: this.hostId,
+        };
+    }
+}

package/dist/RoomManager.d.ts

@@ -0,0 +1,29 @@
+import { WebSocket } from 'ws';
+import { RoomConfig, RoomInfo, ClientMessage, ServerMessage } from './protocol.js';
+import { ConnectedClient, ServerConfig } from './types.js';
+export declare class RoomManager {
+    private rooms;
+    private clients;
+    private config;
+    private cleanupInterval;
+    onRoomCreated?: (room: RoomInfo) => void;
+    onRoomClosed?: (roomId: string) => void;
+    constructor(config?: Partial<ServerConfig>);
+    addClient(socket: WebSocket): string;
+    removeClient(clientId: string): void;
+    getClient(clientId: string): ConnectedClient | undefined;
+    createRoom(clientId: string, config: RoomConfig): string | null;
+    joinRoom(clientId: string, roomId: string, playerName: string, password?: string): boolean;
+    leaveRoom(clientId: string): void;
+    removeRoom(roomId: string): void;
+    listRooms(): RoomInfo[];
+    handleMessage(clientId: string, message: ClientMessage): void;
+    handleBinaryData(clientId: string, data: Buffer): void;
+    sendToClient(clientId: string, message: ServerMessage): void;
+    cleanup(): void;
+    shutdown(): void;
+    getStats(): {
+        rooms: number;
+        clients: number;
+    };
+}