csterm-server 1.0.0

package/dist/protocol.d.ts

@@ -0,0 +1,433 @@
+export type TeamId = 'T' | 'CT' | 'SPECTATOR';
+export type GameModeType = 'deathmatch' | 'competitive';
+export type GamePhase = 'pre_match' | 'warmup' | 'freeze' | 'live' | 'round_end' | 'halftime' | 'match_end';
+export type WeaponType = 'knife' | 'pistol' | 'rifle' | 'shotgun' | 'sniper';
+export type BotDifficulty = 'easy' | 'medium' | 'hard';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface RoomConfig {
+    name: string;
+    map: string;
+    mode: GameModeType;
+    maxPlayers: number;
+    botCount: number;
+    botDifficulty: BotDifficulty;
+    isPrivate: boolean;
+    password?: string;
+}
+export interface RoomInfo {
+    id: string;
+    name: string;
+    map: string;
+    mode: GameModeType;
+    playerCount: number;
+    maxPlayers: number;
+    botCount: number;
+    isPrivate: boolean;
+    phase: GamePhase;
+    hostId: string;
+}
+export interface PlayerInput {
+    forward: number;
+    strafe: number;
+    yaw: number;
+    pitch: number;
+    jump: boolean;
+    crouch: boolean;
+}
+export interface PlayerSnapshot {
+    id: string;
+    name: string;
+    position: Vec3;
+    yaw: number;
+    pitch: number;
+    health: number;
+    armor: number;
+    team: TeamId;
+    isAlive: boolean;
+    currentWeapon: WeaponType;
+    money: number;
+    kills: number;
+    deaths: number;
+}
+export interface BotSnapshot {
+    id: string;
+    name: string;
+    position: Vec3;
+    yaw: number;
+    pitch: number;
+    health: number;
+    armor: number;
+    team: TeamId;
+    isAlive: boolean;
+    currentWeapon: WeaponType;
+    kills: number;
+    deaths: number;
+}
+export interface DroppedWeaponSnapshot {
+    id: string;
+    weaponType: WeaponType;
+    position: Vec3;
+}
+export interface GameStateSnapshot {
+    tick: number;
+    timestamp: number;
+    phase: GamePhase;
+    roundTime: number;
+    freezeTime: number;
+    players: PlayerSnapshot[];
+    bots: BotSnapshot[];
+    droppedWeapons: DroppedWeaponSnapshot[];
+    tScore: number;
+    ctScore: number;
+    roundNumber: number;
+}
+export interface KillEvent {
+    killerId: string;
+    killerName: string;
+    victimId: string;
+    victimName: string;
+    weapon: WeaponType;
+    headshot: boolean;
+}
+export interface HitEvent {
+    attackerId: string;
+    victimId: string;
+    damage: number;
+    headshot: boolean;
+}
+export interface FireEvent {
+    playerId: string;
+    origin: Vec3;
+    direction: Vec3;
+    weapon: WeaponType;
+}
+export interface ListRoomsMessage {
+    type: 'list_rooms';
+}
+export interface CreateRoomMessage {
+    type: 'create_room';
+    config: RoomConfig;
+}
+export interface JoinRoomMessage {
+    type: 'join_room';
+    roomId: string;
+    playerName: string;
+    password?: string;
+}
+export interface LeaveRoomMessage {
+    type: 'leave_room';
+}
+export interface PlayerInputMessage {
+    type: 'input';
+    input: PlayerInput;
+    sequence: number;
+}
+export interface FireMessage {
+    type: 'fire';
+}
+export interface ReloadMessage {
+    type: 'reload';
+}
+export interface BuyWeaponMessage {
+    type: 'buy_weapon';
+    weaponName: string;
+}
+export interface PickupWeaponMessage {
+    type: 'pickup_weapon';
+    weaponId: string;
+}
+export interface DropWeaponMessage {
+    type: 'drop_weapon';
+}
+export interface SelectWeaponMessage {
+    type: 'select_weapon';
+    slot: number;
+}
+export interface ChatMessage {
+    type: 'chat';
+    message: string;
+    teamOnly: boolean;
+}
+export interface ReadyMessage {
+    type: 'ready';
+}
+export interface StartGameMessage {
+    type: 'start_game';
+}
+export interface ChangeTeamMessage {
+    type: 'change_team';
+    team: TeamId;
+}
+export type ClientMessage = ListRoomsMessage | CreateRoomMessage | JoinRoomMessage | LeaveRoomMessage | PlayerInputMessage | FireMessage | ReloadMessage | BuyWeaponMessage | PickupWeaponMessage | DropWeaponMessage | SelectWeaponMessage | ChatMessage | ReadyMessage | StartGameMessage | ChangeTeamMessage | LockstepInputMessage | LockstepSyncMessage;
+export interface RoomListMessage {
+    type: 'room_list';
+    rooms: RoomInfo[];
+}
+export interface RoomJoinedMessage {
+    type: 'room_joined';
+    roomId: string;
+    playerId: string;
+    room: RoomInfo;
+}
+export interface RoomErrorMessage {
+    type: 'room_error';
+    error: string;
+}
+export interface PlayerJoinedMessage {
+    type: 'player_joined';
+    playerId: string;
+    playerName: string;
+}
+export interface PlayerLeftMessage {
+    type: 'player_left';
+    playerId: string;
+    playerName: string;
+}
+export interface GameStateMessage {
+    type: 'game_state';
+    state: GameStateSnapshot;
+}
+export interface PhaseChangeMessage {
+    type: 'phase_change';
+    phase: GamePhase;
+    roundNumber: number;
+    tScore: number;
+    ctScore: number;
+}
+export interface FireEventMessage {
+    type: 'fire_event';
+    event: FireEvent;
+}
+export interface HitEventMessage {
+    type: 'hit_event';
+    event: HitEvent;
+}
+export interface KillEventMessage {
+    type: 'kill_event';
+    event: KillEvent;
+}
+export interface SpawnEventMessage {
+    type: 'spawn_event';
+    entityId: string;
+    entityType: 'player' | 'bot';
+    position: Vec3;
+    team: TeamId;
+}
+export interface WeaponDroppedMessage {
+    type: 'weapon_dropped';
+    weaponId: string;
+    weaponType: WeaponType;
+    position: Vec3;
+}
+export interface WeaponPickedUpMessage {
+    type: 'weapon_picked_up';
+    weaponId: string;
+    playerId: string;
+}
+export interface ChatReceivedMessage {
+    type: 'chat_received';
+    senderId: string;
+    senderName: string;
+    message: string;
+    teamOnly: boolean;
+}
+export interface PlayerReadyMessage {
+    type: 'player_ready';
+    playerId: string;
+    ready: boolean;
+}
+export interface PlayerTeamChangedMessage {
+    type: 'player_team_changed';
+    playerId: string;
+    team: TeamId;
+}
+export interface GameStartingMessage {
+    type: 'game_starting';
+    countdown: number;
+}
+export interface AssignedTeamMessage {
+    type: 'assigned_team';
+    team: TeamId;
+}
+export interface InputAckMessage {
+    type: 'input_ack';
+    sequence: number;
+    position: Vec3;
+}
+export interface LockstepInputMessage {
+    type: 'lockstep_input';
+    tick: number;
+    input: PlayerInput;
+    actions: LockstepAction[];
+    position: Vec3;
+    yaw: number;
+    pitch: number;
+    health: number;
+    isAlive: boolean;
+}
+export interface LockstepAction {
+    type: 'fire' | 'reload' | 'buy' | 'drop' | 'pickup' | 'select_weapon' | 'hit' | 'death';
+    data?: any;
+}
+export interface LockstepTickMessage {
+    type: 'lockstep_tick';
+    tick: number;
+    inputs: Array<{
+        playerId: string;
+        input: PlayerInput;
+        actions: LockstepAction[];
+        position: Vec3;
+        yaw: number;
+        pitch: number;
+        health: number;
+        isAlive: boolean;
+    }>;
+}
+export interface LockstepStartMessage {
+    type: 'lockstep_start';
+    tick: number;
+    players: Array<{
+        id: string;
+        name: string;
+        team: TeamId;
+        spawnPosition: Vec3;
+        spawnYaw: number;
+    }>;
+    mapData: {
+        bounds: {
+            min: Vec3;
+            max: Vec3;
+        };
+        colliders: Array<{
+            min: Vec3;
+            max: Vec3;
+        }>;
+        spawnPoints: Array<{
+            position: Vec3;
+            angle: number;
+            team: string;
+        }>;
+    };
+}
+export interface LockstepSyncMessage {
+    type: 'lockstep_sync';
+    tick: number;
+    hash: string;
+}
+export interface LockstepDesyncMessage {
+    type: 'lockstep_desync';
+    tick: number;
+    expectedHash: string;
+    receivedHash: string;
+    playerId: string;
+}
+export type ServerMessage = RoomListMessage | RoomJoinedMessage | RoomErrorMessage | PlayerJoinedMessage | PlayerLeftMessage | GameStateMessage | PhaseChangeMessage | FireEventMessage | HitEventMessage | KillEventMessage | SpawnEventMessage | WeaponDroppedMessage | WeaponPickedUpMessage | ChatReceivedMessage | PlayerReadyMessage | PlayerTeamChangedMessage | GameStartingMessage | AssignedTeamMessage | InputAckMessage | LockstepTickMessage | LockstepStartMessage | LockstepDesyncMessage;
+export interface PoolServerInfo {
+    id: string;
+    name: string;
+    endpoint: string;
+    maxRooms: number;
+    currentRooms: number;
+    playerCount: number;
+    load: number;
+    lastHeartbeat: number;
+    rooms: RoomInfo[];
+}
+export interface AggregatedRoomInfo extends RoomInfo {
+    poolId: string;
+    poolName: string;
+    poolEndpoint: string;
+}
+export interface PoolRegisterMessage {
+    type: 'pool_register';
+    serverName: string;
+    endpoint: string;
+    maxRooms: number;
+}
+export interface PoolHeartbeatMessage {
+    type: 'pool_heartbeat';
+    rooms: RoomInfo[];
+    playerCount: number;
+    load: number;
+}
+export interface PoolRoomCreatedMessage {
+    type: 'pool_room_created';
+    room: RoomInfo;
+}
+export interface PoolRoomClosedMessage {
+    type: 'pool_room_closed';
+    roomId: string;
+}
+export interface PoolUnregisterMessage {
+    type: 'pool_unregister';
+}
+export type PoolToHubMessage = PoolRegisterMessage | PoolHeartbeatMessage | PoolRoomCreatedMessage | PoolRoomClosedMessage | PoolUnregisterMessage;
+export interface PoolAcceptedMessage {
+    type: 'pool_accepted';
+    poolId: string;
+}
+export interface PoolRejectedMessage {
+    type: 'pool_rejected';
+    reason: string;
+}
+export interface PoolPingMessage {
+    type: 'pool_ping';
+}
+export type HubToPoolMessage = PoolAcceptedMessage | PoolRejectedMessage | PoolPingMessage;
+export interface HubListRoomsMessage {
+    type: 'hub_list_rooms';
+}
+export interface HubGetEndpointMessage {
+    type: 'hub_get_endpoint';
+    roomId: string;
+}
+export interface HubCreateRoomMessage {
+    type: 'hub_create_room';
+    config: RoomConfig;
+    preferredPool?: string;
+}
+export type ClientToHubMessage = HubListRoomsMessage | HubGetEndpointMessage | HubCreateRoomMessage;
+export interface HubRoomListMessage {
+    type: 'hub_room_list';
+    rooms: AggregatedRoomInfo[];
+    pools: {
+        id: string;
+        name: string;
+        playerCount: number;
+    }[];
+}
+export interface HubRoomEndpointMessage {
+    type: 'hub_room_endpoint';
+    roomId: string;
+    endpoint: string;
+    token: string;
+}
+export interface HubRoomNotFoundMessage {
+    type: 'hub_room_not_found';
+    roomId: string;
+}
+export interface HubRoomCreatedMessage {
+    type: 'hub_room_created';
+    roomId: string;
+    endpoint: string;
+    token: string;
+}
+export interface HubErrorMessage {
+    type: 'hub_error';
+    error: string;
+}
+export type HubToClientMessage = HubRoomListMessage | HubRoomEndpointMessage | HubRoomNotFoundMessage | HubRoomCreatedMessage | HubErrorMessage;
+export declare function isClientMessage(msg: unknown): msg is ClientMessage;
+export declare function parseClientMessage(data: string): ClientMessage | null;
+export declare function serializeServerMessage(msg: ServerMessage): string;
+export declare function isPoolToHubMessage(msg: unknown): msg is PoolToHubMessage;
+export declare function parsePoolToHubMessage(data: string): PoolToHubMessage | null;
+export declare function isClientToHubMessage(msg: unknown): msg is ClientToHubMessage;
+export declare function parseClientToHubMessage(data: string): ClientToHubMessage | null;
+export declare function serializeHubToPoolMessage(msg: HubToPoolMessage): string;
+export declare function serializeHubToClientMessage(msg: HubToClientMessage): string;
+export declare function serializePoolToHubMessage(msg: PoolToHubMessage): string;

package/dist/protocol.js

@@ -0,0 +1,59 @@
+// Network protocol message type definitions for CS-CLI multiplayer
+// ============ Helpers ============
+export function isClientMessage(msg) {
+    return typeof msg === 'object' && msg !== null && 'type' in msg;
+}
+export function parseClientMessage(data) {
+    try {
+        const msg = JSON.parse(data);
+        if (isClientMessage(msg)) {
+            return msg;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeServerMessage(msg) {
+    return JSON.stringify(msg);
+}
+export function isPoolToHubMessage(msg) {
+    return typeof msg === 'object' && msg !== null && 'type' in msg;
+}
+export function parsePoolToHubMessage(data) {
+    try {
+        const msg = JSON.parse(data);
+        if (isPoolToHubMessage(msg)) {
+            return msg;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isClientToHubMessage(msg) {
+    return typeof msg === 'object' && msg !== null && 'type' in msg;
+}
+export function parseClientToHubMessage(data) {
+    try {
+        const msg = JSON.parse(data);
+        if (isClientToHubMessage(msg)) {
+            return msg;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeHubToPoolMessage(msg) {
+    return JSON.stringify(msg);
+}
+export function serializeHubToClientMessage(msg) {
+    return JSON.stringify(msg);
+}
+export function serializePoolToHubMessage(msg) {
+    return JSON.stringify(msg);
+}

package/dist/test/HeadlessClient.d.ts

@@ -0,0 +1,44 @@
+import { ServerMessage, RoomConfig, RoomInfo, TeamId, GamePhase } from '../protocol.js';
+interface HeadlessClientCallbacks {
+    onConnect?: () => void;
+    onDisconnect?: (reason: string) => void;
+    onMessage?: (message: ServerMessage) => void;
+    onRoomList?: (rooms: RoomInfo[]) => void;
+    onRoomJoined?: (roomId: string, playerId: string, room: RoomInfo) => void;
+    onPlayerJoined?: (playerId: string, playerName: string) => void;
+    onPlayerTeamChanged?: (playerId: string, team: TeamId) => void;
+    onPhaseChange?: (phase: GamePhase, round: number, tScore: number, ctScore: number) => void;
+}
+export declare class HeadlessClient {
+    private socket;
+    private callbacks;
+    private playerId;
+    private playerName;
+    private roomId;
+    private team;
+    private messageLog;
+    constructor(playerName?: string);
+    connect(serverUrl?: string): Promise<void>;
+    disconnect(): void;
+    setCallbacks(callbacks: HeadlessClientCallbacks): void;
+    listRooms(): void;
+    createRoom(config: Partial<RoomConfig>): void;
+    joinRoom(roomId: string, password?: string): void;
+    leaveRoom(): void;
+    setReady(): void;
+    startGame(): void;
+    changeTeam(team: 'T' | 'CT'): void;
+    sendInput(forward: number, strafe: number, yaw: number, pitch: number, jump?: boolean): void;
+    sendFire(): void;
+    getPlayerId(): string | null;
+    getRoomId(): string | null;
+    getTeam(): TeamId | null;
+    getMessageLog(): ServerMessage[];
+    clearMessageLog(): void;
+    waitForMessage(type: string, timeout?: number): Promise<ServerMessage>;
+    private send;
+    private handleMessage;
+    private dispatchMessage;
+}
+export declare function delay(ms: number): Promise<void>;
+export {};