quake2ts 0.0.557 → 0.0.562

package/packages/server/dist/client.d.ts

@@ -0,0 +1,51 @@
+import { NetDriver, UserCommand, PlayerState, EntityState, NetChan } from '@quake2ts/shared';
+import { Entity } from '@quake2ts/game';
+export declare enum ClientState {
+    Free = 0,
+    Zombie = 1,// client has been disconnected, but don't reuse connection for a couple seconds
+    Connected = 2,// has been assigned to a client_t, but not in game yet
+    Spawned = 3,// client is fully in game
+    Active = 4
+}
+export interface ClientFrame {
+    areaBytes: number;
+    areaBits: Uint8Array;
+    playerState: PlayerState;
+    numEntities: number;
+    firstEntity: number;
+    sentTime: number;
+    entities: EntityState[];
+    packetCRC: number;
+}
+export interface Client {
+    index: number;
+    state: ClientState;
+    net: NetDriver;
+    netchan: NetChan;
+    userInfo: string;
+    lastFrame: number;
+    lastCmd: UserCommand;
+    commandMsec: number;
+    frameLatency: number[];
+    ping: number;
+    messageSize: number[];
+    rate: number;
+    suppressCount: number;
+    edict: Entity | null;
+    name: string;
+    messageLevel: number;
+    datagram: Uint8Array;
+    frames: ClientFrame[];
+    download?: Uint8Array;
+    downloadSize: number;
+    downloadCount: number;
+    lastMessage: number;
+    lastConnect: number;
+    challenge: number;
+    messageQueue: Uint8Array[];
+    lastPacketEntities: number[];
+    commandQueue: UserCommand[];
+    lastCommandTime: number;
+    commandCount: number;
+}
+export declare function createClient(index: number, net: NetDriver): Client;

package/packages/server/dist/client.js

@@ -0,0 +1,100 @@
+import { UPDATE_BACKUP, NetChan } from '@quake2ts/shared';
+export var ClientState;
+(function (ClientState) {
+    ClientState[ClientState["Free"] = 0] = "Free";
+    ClientState[ClientState["Zombie"] = 1] = "Zombie";
+    ClientState[ClientState["Connected"] = 2] = "Connected";
+    ClientState[ClientState["Spawned"] = 3] = "Spawned";
+    ClientState[ClientState["Active"] = 4] = "Active"; // In game (added to match existing code usage)
+})(ClientState || (ClientState = {}));
+export function createClient(index, net) {
+    // Initialize frames array
+    const frames = [];
+    for (let i = 0; i < UPDATE_BACKUP; i++) {
+        frames.push({
+            areaBytes: 0,
+            areaBits: new Uint8Array(0), // Size depends on map areas
+            playerState: createEmptyPlayerState(),
+            numEntities: 0,
+            firstEntity: 0,
+            sentTime: 0,
+            entities: [],
+            packetCRC: 0
+        });
+    }
+    const netchan = new NetChan();
+    // Initialize qport - normally we would get this from userinfo or handshake
+    netchan.setup(Math.floor(Math.random() * 65536));
+    return {
+        index,
+        state: ClientState.Connected,
+        net,
+        netchan,
+        userInfo: '',
+        lastFrame: 0,
+        lastCmd: createEmptyUserCommand(),
+        commandMsec: 0,
+        frameLatency: [],
+        ping: 0,
+        messageSize: [],
+        rate: 25000, // Default rate
+        suppressCount: 0,
+        edict: null,
+        name: `Player ${index}`,
+        messageLevel: 0,
+        datagram: new Uint8Array(0),
+        frames,
+        downloadSize: 0,
+        downloadCount: 0,
+        lastMessage: 0,
+        lastConnect: Date.now(),
+        challenge: 0,
+        messageQueue: [],
+        lastPacketEntities: [],
+        commandQueue: [],
+        lastCommandTime: 0,
+        commandCount: 0
+    };
+}
+function createEmptyUserCommand() {
+    return {
+        msec: 0,
+        buttons: 0,
+        angles: { x: 0, y: 0, z: 0 },
+        forwardmove: 0,
+        sidemove: 0,
+        upmove: 0,
+        sequence: 0,
+        lightlevel: 0,
+        impulse: 0
+    };
+}
+function createEmptyPlayerState() {
+    return {
+        origin: { x: 0, y: 0, z: 0 },
+        velocity: { x: 0, y: 0, z: 0 },
+        viewAngles: { x: 0, y: 0, z: 0 },
+        onGround: false,
+        waterLevel: 0,
+        watertype: 0,
+        mins: { x: -16, y: -16, z: -24 },
+        maxs: { x: 16, y: 16, z: 32 },
+        damageAlpha: 0,
+        damageIndicators: [],
+        blend: [0, 0, 0, 0],
+        // Stubs for new fields
+        stats: [],
+        kick_angles: { x: 0, y: 0, z: 0 },
+        kick_origin: { x: 0, y: 0, z: 0 },
+        gunoffset: { x: 0, y: 0, z: 0 },
+        gunangles: { x: 0, y: 0, z: 0 },
+        gunindex: 0,
+        pm_type: 0,
+        pm_time: 0,
+        pm_flags: 0,
+        gun_frame: 0,
+        rdflags: 0,
+        fov: 90,
+        renderfx: 0
+    };
+}

package/packages/server/dist/dedicated.d.ts

@@ -0,0 +1,69 @@
+import { GameEngine, Entity, MulticastType } from '@quake2ts/game';
+import { ServerCommand } from '@quake2ts/shared';
+import { NetworkTransport } from './transport.js';
+export interface ClientInfo {
+    id: number;
+    name: string;
+    ping: number;
+    address: string;
+}
+export interface ServerOptions {
+    mapName?: string;
+    maxPlayers?: number;
+    deathmatch?: boolean;
+    port?: number;
+    transport?: NetworkTransport;
+}
+export declare class DedicatedServer implements GameEngine {
+    private transport;
+    private svs;
+    private sv;
+    private game;
+    private frameTimeout;
+    private entityIndex;
+    private history;
+    private backup;
+    onClientConnected?: (clientId: number, name: string) => void;
+    onClientDisconnected?: (clientId: number) => void;
+    onServerError?: (error: Error) => void;
+    private options;
+    constructor(optionsOrPort?: ServerOptions | number);
+    setTransport(transport: NetworkTransport): void;
+    startServer(mapName?: string): Promise<void>;
+    stopServer(): void;
+    kickPlayer(clientId: number): void;
+    changeMap(mapName: string): Promise<void>;
+    getConnectedClients(): ClientInfo[];
+    private start;
+    private loadMap;
+    private initGame;
+    private populateBaselines;
+    private entityToState;
+    stop(): void;
+    private handleConnection;
+    private onClientMessage;
+    private onClientDisconnect;
+    private dropClient;
+    private handleMove;
+    private handleUserInfo;
+    private handleStringCmd;
+    private handleStatus;
+    private handleGetChallenge;
+    private handleConnect;
+    private handleBegin;
+    private spawnClient;
+    private sendServerData;
+    private SV_SetConfigString;
+    private SV_WriteConfigString;
+    private SV_ReadPackets;
+    private runFrame;
+    private SV_SendClientMessages;
+    private SV_SendClientFrame;
+    trace(start: any, end: any): any;
+    multicast(origin: any, type: MulticastType, event: ServerCommand, ...args: any[]): void;
+    unicast(ent: Entity, reliable: boolean, event: ServerCommand, ...args: any[]): void;
+    configstring(index: number, value: string): void;
+    private recordHistory;
+    setLagCompensation(active: boolean, client?: Entity, lagMs?: number): void;
+}
+export declare function createServer(options?: ServerOptions): DedicatedServer;