csterm-server 1.0.0

package/dist/test/HeadlessClient.js

@@ -0,0 +1,196 @@
+// Headless WebSocket client for testing multiplayer server
+// Can simulate multiple clients connecting, joining rooms, and performing actions
+import WebSocket from 'ws';
+export class HeadlessClient {
+    socket = null;
+    callbacks = {};
+    playerId = null;
+    playerName;
+    roomId = null;
+    team = null;
+    messageLog = [];
+    constructor(playerName = 'TestPlayer') {
+        this.playerName = playerName;
+    }
+    async connect(serverUrl = 'ws://localhost:8080') {
+        return new Promise((resolve, reject) => {
+            this.socket = new WebSocket(serverUrl);
+            this.socket.onopen = () => {
+                console.log(`[${this.playerName}] Connected to server`);
+                this.callbacks.onConnect?.();
+                resolve();
+            };
+            this.socket.onclose = (event) => {
+                const reason = event.reason || 'Connection closed';
+                console.log(`[${this.playerName}] Disconnected: ${reason}`);
+                this.callbacks.onDisconnect?.(reason);
+            };
+            this.socket.onerror = (error) => {
+                console.error(`[${this.playerName}] WebSocket error`);
+                reject(new Error('WebSocket error'));
+            };
+            this.socket.onmessage = (event) => {
+                this.handleMessage(event.data.toString());
+            };
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    // Lobby operations
+    listRooms() {
+        this.send({ type: 'list_rooms' });
+    }
+    createRoom(config) {
+        const fullConfig = {
+            name: config.name || `${this.playerName}'s Room`,
+            map: config.map || 'dm_arena',
+            mode: config.mode || 'deathmatch',
+            maxPlayers: config.maxPlayers || 10,
+            botCount: config.botCount || 0,
+            botDifficulty: config.botDifficulty || 'medium',
+            isPrivate: config.isPrivate || false,
+            password: config.password,
+        };
+        this.send({ type: 'create_room', config: fullConfig });
+    }
+    joinRoom(roomId, password) {
+        this.send({
+            type: 'join_room',
+            roomId,
+            playerName: this.playerName,
+            password,
+        });
+    }
+    leaveRoom() {
+        this.send({ type: 'leave_room' });
+        this.roomId = null;
+    }
+    setReady() {
+        this.send({ type: 'ready' });
+    }
+    startGame() {
+        this.send({ type: 'start_game' });
+    }
+    changeTeam(team) {
+        this.send({ type: 'change_team', team });
+    }
+    // Game operations
+    sendInput(forward, strafe, yaw, pitch, jump = false) {
+        this.send({
+            type: 'input',
+            input: { forward, strafe, yaw, pitch, jump, crouch: false },
+            sequence: Date.now(),
+        });
+    }
+    sendFire() {
+        this.send({ type: 'fire' });
+    }
+    // Getters
+    getPlayerId() {
+        return this.playerId;
+    }
+    getRoomId() {
+        return this.roomId;
+    }
+    getTeam() {
+        return this.team;
+    }
+    getMessageLog() {
+        return this.messageLog;
+    }
+    clearMessageLog() {
+        this.messageLog = [];
+    }
+    // Wait for a specific message type
+    async waitForMessage(type, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            const checkInterval = setInterval(() => {
+                const message = this.messageLog.find(m => m.type === type);
+                if (message) {
+                    clearInterval(checkInterval);
+                    resolve(message);
+                }
+                else if (Date.now() - startTime > timeout) {
+                    clearInterval(checkInterval);
+                    reject(new Error(`Timeout waiting for message type: ${type}`));
+                }
+            }, 50);
+        });
+    }
+    send(message) {
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(JSON.stringify(message));
+        }
+    }
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            this.messageLog.push(message);
+            this.callbacks.onMessage?.(message);
+            this.dispatchMessage(message);
+        }
+        catch (error) {
+            console.error(`[${this.playerName}] Failed to parse message:`, error);
+        }
+    }
+    dispatchMessage(message) {
+        switch (message.type) {
+            case 'room_list':
+                console.log(`[${this.playerName}] Room list: ${message.rooms.length} rooms`);
+                this.callbacks.onRoomList?.(message.rooms);
+                break;
+            case 'room_joined':
+                this.playerId = message.playerId;
+                this.roomId = message.roomId;
+                console.log(`[${this.playerName}] Joined room ${message.roomId} as ${message.playerId}`);
+                this.callbacks.onRoomJoined?.(message.roomId, message.playerId, message.room);
+                break;
+            case 'room_error':
+                console.error(`[${this.playerName}] Room error: ${message.error}`);
+                break;
+            case 'player_joined':
+                console.log(`[${this.playerName}] Player joined: ${message.playerName} (${message.playerId})`);
+                this.callbacks.onPlayerJoined?.(message.playerId, message.playerName);
+                break;
+            case 'player_team_changed':
+                console.log(`[${this.playerName}] Player ${message.playerId} changed to team ${message.team}`);
+                this.callbacks.onPlayerTeamChanged?.(message.playerId, message.team);
+                break;
+            case 'assigned_team':
+                this.team = message.team;
+                console.log(`[${this.playerName}] Assigned to team: ${message.team}`);
+                break;
+            case 'player_ready':
+                console.log(`[${this.playerName}] Player ${message.playerId} ready: ${message.ready}`);
+                break;
+            case 'game_starting':
+                console.log(`[${this.playerName}] Game starting in ${message.countdown}...`);
+                break;
+            case 'phase_change':
+                console.log(`[${this.playerName}] Phase: ${message.phase}, Round ${message.roundNumber}`);
+                this.callbacks.onPhaseChange?.(message.phase, message.roundNumber, message.tScore, message.ctScore);
+                break;
+            case 'game_state':
+                // Frequent message, don't log
+                break;
+            case 'kill_event':
+                console.log(`[${this.playerName}] Kill: ${message.event.killerName} killed ${message.event.victimName}`);
+                break;
+            default:
+                // Ignore other messages
+                break;
+        }
+    }
+}
+// Helper function to run tests
+export async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/test/testTeamSync.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env npx ts-node
+export {};

package/dist/test/testTeamSync.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env npx ts-node
+// Test script to verify team synchronization between players
+// Run with: npx ts-node server/src/test/testTeamSync.ts
+import { HeadlessClient, delay } from './HeadlessClient.js';
+async function testTeamSync() {
+    console.log('=== Team Sync Test ===\n');
+    // Create two clients
+    const host = new HeadlessClient('Host');
+    const joiner = new HeadlessClient('Joiner');
+    try {
+        // Connect host
+        console.log('1. Connecting host...');
+        await host.connect();
+        await delay(100);
+        // Host creates room
+        console.log('2. Host creating room...');
+        host.createRoom({ name: 'Test Room', botCount: 0 });
+        await delay(500);
+        // Get room ID
+        const roomId = host.getRoomId();
+        if (!roomId) {
+            throw new Error('Host failed to create room');
+        }
+        console.log(`   Room created: ${roomId}`);
+        console.log(`   Host team: ${host.getTeam()}`);
+        // Host changes team to T
+        console.log('3. Host changing team to T...');
+        host.changeTeam('T');
+        await delay(200);
+        console.log(`   Host team after change: ${host.getTeam()}`);
+        // Connect joiner
+        console.log('4. Connecting joiner...');
+        await joiner.connect();
+        await delay(100);
+        // Track team changes received by joiner
+        let receivedTeamChanges = [];
+        joiner.setCallbacks({
+            onPlayerTeamChanged: (playerId, team) => {
+                receivedTeamChanges.push({ playerId, team });
+            },
+        });
+        // Joiner joins the room
+        console.log('5. Joiner joining room...');
+        joiner.joinRoom(roomId);
+        await delay(500);
+        // Check what joiner received
+        console.log('\n=== Results ===');
+        console.log(`Joiner received ${receivedTeamChanges.length} team change messages:`);
+        for (const change of receivedTeamChanges) {
+            console.log(`  - Player ${change.playerId} -> ${change.team}`);
+        }
+        // Check if host's team was received
+        const hostId = host.getPlayerId();
+        const hostTeamReceived = receivedTeamChanges.find(c => c.playerId === hostId);
+        if (hostTeamReceived) {
+            console.log(`\n✓ SUCCESS: Joiner received host's team (${hostTeamReceived.team})`);
+        }
+        else {
+            console.log(`\n✗ FAILURE: Joiner did NOT receive host's team`);
+            console.log(`  Host ID: ${hostId}`);
+            console.log(`  Messages in joiner log: ${joiner.getMessageLog().map(m => m.type).join(', ')}`);
+        }
+        // Print full message log for debugging
+        console.log('\n=== Joiner Message Log ===');
+        for (const msg of joiner.getMessageLog()) {
+            if (msg.type !== 'game_state') {
+                console.log(`  ${msg.type}: ${JSON.stringify(msg).substring(0, 100)}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+    }
+    finally {
+        // Cleanup
+        host.disconnect();
+        joiner.disconnect();
+        console.log('\n=== Test Complete ===');
+    }
+}
+// Run the test
+testTeamSync().catch(console.error);

package/dist/types.d.ts

@@ -0,0 +1,164 @@
+import { WebSocket } from 'ws';
+import { RoomConfig, TeamId, Vec3, PlayerInput, GamePhase, WeaponType, BotDifficulty } from './protocol.js';
+export interface ServerConfig {
+    port: number;
+    tickRate: number;
+    broadcastRate: number;
+    maxRooms: number;
+    maxPlayersPerRoom: number;
+    roomIdleTimeout: number;
+}
+export declare const DEFAULT_SERVER_CONFIG: ServerConfig;
+export interface ConnectedClient {
+    id: string;
+    socket: WebSocket;
+    name: string | null;
+    roomId: string | null;
+    isReady: boolean;
+    lastActivity: number;
+    pendingInputs: Array<{
+        sequence: number;
+        input: PlayerInput;
+    }>;
+}
+export interface ServerPlayerState {
+    id: string;
+    name: string;
+    team: TeamId;
+    position: Vec3;
+    velocity: Vec3;
+    yaw: number;
+    pitch: number;
+    health: number;
+    armor: number;
+    isAlive: boolean;
+    currentWeapon: WeaponType;
+    weapons: Map<number, ServerWeaponState>;
+    money: number;
+    kills: number;
+    deaths: number;
+    lastInputSequence: number;
+}
+export interface ServerWeaponState {
+    type: WeaponType;
+    currentAmmo: number;
+    reserveAmmo: number;
+    isReloading: boolean;
+    reloadStartTime: number;
+    lastFireTime: number;
+}
+export interface ServerBotState {
+    id: string;
+    name: string;
+    team: TeamId;
+    difficulty: BotDifficulty;
+    position: Vec3;
+    velocity: Vec3;
+    yaw: number;
+    pitch: number;
+    health: number;
+    armor: number;
+    isAlive: boolean;
+    currentWeapon: WeaponType;
+    kills: number;
+    deaths: number;
+    targetId: string | null;
+    lastTargetSeen: number;
+    wanderAngle: number;
+    nextFireTime: number;
+}
+export interface ServerDroppedWeapon {
+    id: string;
+    weaponType: WeaponType;
+    position: Vec3;
+    ammo: number;
+    reserveAmmo: number;
+    dropTime: number;
+}
+export interface SpawnPoint {
+    position: Vec3;
+    angle: number;
+    team: TeamId | 'DM';
+}
+export interface MapCollider {
+    min: Vec3;
+    max: Vec3;
+}
+export interface MapData {
+    id: string;
+    name: string;
+    spawnPoints: SpawnPoint[];
+    colliders: MapCollider[];
+    bounds: {
+        min: Vec3;
+        max: Vec3;
+    };
+}
+export interface ServerGameState {
+    phase: GamePhase;
+    phaseStartTime: number;
+    roundNumber: number;
+    tScore: number;
+    ctScore: number;
+    roundWinner: TeamId | null;
+    players: Map<string, ServerPlayerState>;
+    bots: Map<string, ServerBotState>;
+    droppedWeapons: Map<string, ServerDroppedWeapon>;
+    tick: number;
+    lastBroadcastTick: number;
+}
+export interface RoomState {
+    id: string;
+    config: RoomConfig;
+    hostId: string;
+    createdAt: number;
+    lastActivity: number;
+    clients: Map<string, ConnectedClient>;
+    gameState: ServerGameState | null;
+    gameLoopInterval: ReturnType<typeof setInterval> | null;
+    broadcastInterval: ReturnType<typeof setInterval> | null;
+    mapData: MapData;
+}
+export interface RaycastHit {
+    entityId: string;
+    entityType: 'player' | 'bot';
+    distance: number;
+    hitPoint: Vec3;
+    isHeadshot: boolean;
+}
+export interface ServerEconomyConfig {
+    startMoney: number;
+    maxMoney: number;
+    roundWinBonus: number;
+    roundLoseBonus: number;
+    roundLoseStreakBonus: number;
+    maxLoseStreak: number;
+    killReward: Record<WeaponType, number>;
+}
+export declare const DEFAULT_ECONOMY_CONFIG: ServerEconomyConfig;
+export interface ServerWeaponDef {
+    type: WeaponType;
+    name: string;
+    slot: number;
+    damage: number;
+    fireRate: number;
+    reloadTime: number;
+    magazineSize: number;
+    reserveAmmo: number;
+    spread: number;
+    range: number;
+    moveSpeed: number;
+    pellets: number;
+    isAutomatic: boolean;
+    headshotMultiplier: number;
+    cost: number;
+}
+export declare const WEAPON_DEFS: Record<WeaponType, ServerWeaponDef>;
+export declare function createVec3(x?: number, y?: number, z?: number): Vec3;
+export declare function vec3Add(a: Vec3, b: Vec3): Vec3;
+export declare function vec3Sub(a: Vec3, b: Vec3): Vec3;
+export declare function vec3Scale(v: Vec3, s: number): Vec3;
+export declare function vec3Length(v: Vec3): number;
+export declare function vec3Normalize(v: Vec3): Vec3;
+export declare function vec3Distance(a: Vec3, b: Vec3): number;
+export declare function vec3Dot(a: Vec3, b: Vec3): number;

package/dist/types.js

@@ -0,0 +1,139 @@
+// Server-specific type definitions for CS-CLI multiplayer
+export const DEFAULT_SERVER_CONFIG = {
+    port: 8080,
+    tickRate: 60,
+    broadcastRate: 20,
+    maxRooms: 100,
+    maxPlayersPerRoom: 10,
+    roomIdleTimeout: 300000, // 5 minutes
+};
+export const DEFAULT_ECONOMY_CONFIG = {
+    startMoney: 800,
+    maxMoney: 16000,
+    roundWinBonus: 3250,
+    roundLoseBonus: 1400,
+    roundLoseStreakBonus: 500,
+    maxLoseStreak: 4,
+    killReward: {
+        knife: 1500,
+        pistol: 300,
+        rifle: 300,
+        shotgun: 900,
+        sniper: 100,
+    },
+};
+export const WEAPON_DEFS = {
+    knife: {
+        type: 'knife',
+        name: 'Knife',
+        slot: 3,
+        damage: 40,
+        fireRate: 60,
+        reloadTime: 0,
+        magazineSize: Infinity,
+        reserveAmmo: Infinity,
+        spread: 0,
+        range: 2,
+        moveSpeed: 1.0,
+        pellets: 1,
+        isAutomatic: false,
+        headshotMultiplier: 1.0,
+        cost: 0,
+    },
+    pistol: {
+        type: 'pistol',
+        name: 'Pistol',
+        slot: 2,
+        damage: 25,
+        fireRate: 400,
+        reloadTime: 2.2,
+        magazineSize: 12,
+        reserveAmmo: 36,
+        spread: 2,
+        range: 50,
+        moveSpeed: 1.0,
+        pellets: 1,
+        isAutomatic: false,
+        headshotMultiplier: 2.0,
+        cost: 200,
+    },
+    rifle: {
+        type: 'rifle',
+        name: 'Rifle',
+        slot: 1,
+        damage: 30,
+        fireRate: 600,
+        reloadTime: 2.5,
+        magazineSize: 30,
+        reserveAmmo: 90,
+        spread: 3,
+        range: 80,
+        moveSpeed: 0.9,
+        pellets: 1,
+        isAutomatic: true,
+        headshotMultiplier: 2.5,
+        cost: 2700,
+    },
+    shotgun: {
+        type: 'shotgun',
+        name: 'Shotgun',
+        slot: 1,
+        damage: 20,
+        fireRate: 70,
+        reloadTime: 0.5,
+        magazineSize: 8,
+        reserveAmmo: 32,
+        spread: 8,
+        range: 20,
+        moveSpeed: 0.9,
+        pellets: 8,
+        isAutomatic: false,
+        headshotMultiplier: 1.5,
+        cost: 1200,
+    },
+    sniper: {
+        type: 'sniper',
+        name: 'Sniper',
+        slot: 1,
+        damage: 100,
+        fireRate: 40,
+        reloadTime: 3.5,
+        magazineSize: 5,
+        reserveAmmo: 20,
+        spread: 0.5,
+        range: 150,
+        moveSpeed: 0.8,
+        pellets: 1,
+        isAutomatic: false,
+        headshotMultiplier: 4.0,
+        cost: 4750,
+    },
+};
+// ============ Utility Functions ============
+export function createVec3(x = 0, y = 0, z = 0) {
+    return { x, y, z };
+}
+export function vec3Add(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+export function vec3Sub(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+export function vec3Scale(v, s) {
+    return { x: v.x * s, y: v.y * s, z: v.z * s };
+}
+export function vec3Length(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+export function vec3Normalize(v) {
+    const len = vec3Length(v);
+    if (len === 0)
+        return { x: 0, y: 0, z: 0 };
+    return { x: v.x / len, y: v.y / len, z: v.z / len };
+}
+export function vec3Distance(a, b) {
+    return vec3Length(vec3Sub(a, b));
+}
+export function vec3Dot(a, b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "csterm-server",
+  "version": "1.0.0",
+  "description": "Multiplayer game server for CSterm - Counter-Strike in your terminal",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "csterm-server": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "start:hub": "node dist/index.js --hub-only",
+    "start:pool": "node dist/index.js --pool",
+    "dev": "tsc --watch & node --watch dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "game",
+    "server",
+    "multiplayer",
+    "websocket",
+    "fps",
+    "counter-strike",
+    "terminal",
+    "csterm"
+  ],
+  "author": "idanbeck",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.14.2",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/ws": "^8.5.10",
+    "@types/uuid": "^9.0.7",
+    "typescript": "^5.3.2"
+  }
+}