quake2ts 0.0.561 → 0.0.563

package/packages/server/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   ClientMessageParser: () => ClientMessageParser,
   ClientState: () => ClientState,
   DedicatedServer: () => DedicatedServer,
+  ServerState: () => ServerState,
   WebSocketNetDriver: () => WebSocketNetDriver,
   createClient: () => createClient,
   createServer: () => createServer
@@ -331,6 +332,19 @@ var import_shared4 = require("@quake2ts/shared");
 var import_engine = require("@quake2ts/engine");
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_game2 = require("@quake2ts/game");
+
+// src/server.ts
+var ServerState = /* @__PURE__ */ ((ServerState2) => {
+  ServerState2[ServerState2["Dead"] = 0] = "Dead";
+  ServerState2[ServerState2["Loading"] = 1] = "Loading";
+  ServerState2[ServerState2["Game"] = 2] = "Game";
+  ServerState2[ServerState2["Cinematic"] = 3] = "Cinematic";
+  ServerState2[ServerState2["Demo"] = 4] = "Demo";
+  ServerState2[ServerState2["Pic"] = 5] = "Pic";
+  return ServerState2;
+})(ServerState || {});
+
+// src/dedicated.ts
 var import_shared5 = require("@quake2ts/shared");
 
 // src/protocol/player.ts
@@ -1003,7 +1017,11 @@ var DedicatedServer = class {
   }
   onClientMessage(client, data) {
     const buffer = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength ? data.buffer : data.slice().buffer;
-    client.messageQueue.push(new Uint8Array(buffer));
+    if (buffer instanceof ArrayBuffer) {
+      client.messageQueue.push(new Uint8Array(buffer));
+    } else {
+      client.messageQueue.push(new Uint8Array(buffer));
+    }
   }
   onClientDisconnect(client) {
     console.log(`Client ${client.index} disconnected`);
@@ -1229,7 +1247,13 @@ var DedicatedServer = class {
         if (data.length === 0) {
           continue;
         }
-        const reader = new import_shared4.BinaryStream(data.buffer);
+        let buffer;
+        if (data.buffer instanceof ArrayBuffer) {
+          buffer = data.buffer;
+        } else {
+          buffer = new Uint8Array(data).buffer;
+        }
+        const reader = new import_shared4.BinaryStream(buffer);
         const parser = new ClientMessageParser(reader, {
           onMove: (checksum, lastFrame, cmd) => this.handleMove(client, cmd, checksum, lastFrame),
           onUserInfo: (info) => this.handleUserInfo(client, info),
@@ -1573,6 +1597,7 @@ function createServer(options = {}) {
   ClientMessageParser,
   ClientState,
   DedicatedServer,
+  ServerState,
   WebSocketNetDriver,
   createClient,
   createServer

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

@@ -1,161 +1,7 @@
-import { NetDriver, ServerCommand, PlayerState, EntityState, NetChan, UserCommand, BinaryStream } from '@quake2ts/shared';
-import WebSocket from 'ws';
-import { GameEngine, MulticastType, Entity } from '@quake2ts/game';
-
-declare class WebSocketNetDriver implements NetDriver {
-    private socket;
-    private messageCallback;
-    private closeCallback;
-    private errorCallback;
-    connect(url: string): Promise<void>;
-    attach(socket: WebSocket): void;
-    disconnect(): void;
-    send(data: Uint8Array): void;
-    onMessage(callback: (data: Uint8Array) => void): void;
-    onClose(callback: () => void): void;
-    onError(callback: (error: Error) => void): void;
-    isConnected(): boolean;
-}
-
-interface NetworkTransport {
-    listen(port: number): Promise<void>;
-    close(): void;
-    onConnection(callback: (driver: NetDriver, info?: any) => void): void;
-    onError(callback: (error: Error) => void): void;
-}
-
-interface ClientInfo {
-    id: number;
-    name: string;
-    ping: number;
-    address: string;
-}
-interface ServerOptions {
-    mapName?: string;
-    maxPlayers?: number;
-    deathmatch?: boolean;
-    port?: number;
-    transport?: NetworkTransport;
-}
-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;
-}
-declare function createServer(options?: ServerOptions): DedicatedServer;
-
-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
-}
-interface ClientFrame {
-    areaBytes: number;
-    areaBits: Uint8Array;
-    playerState: PlayerState;
-    numEntities: number;
-    firstEntity: number;
-    sentTime: number;
-    entities: EntityState[];
-    packetCRC: number;
-}
-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;
-}
-declare function createClient(index: number, net: NetDriver): Client;
-
-interface ClientMessageHandler {
-    onMove(checksum: number, lastFrame: number, userCmd: UserCommand): void;
-    onUserInfo(info: string): void;
-    onStringCmd(cmd: string): void;
-    onNop(): void;
-    onBad(): void;
-}
-declare class ClientMessageParser {
-    private stream;
-    private handler;
-    constructor(stream: BinaryStream, handler: ClientMessageHandler);
-    parseMessage(): void;
-    private parseMove;
-    private parseUserInfo;
-    private parseStringCmd;
-}
-
-export { type Client, type ClientFrame, type ClientInfo, type ClientMessageHandler, ClientMessageParser, ClientState, DedicatedServer, type NetworkTransport, type ServerOptions, WebSocketNetDriver, createClient, createServer };
+export * from './net/nodeWsDriver.js';
+export * from './dedicated.js';
+export * from './client.js';
+export * from './protocol.js';
+export { ServerOptions, createServer } from './dedicated.js';
+export { NetworkTransport } from './transport.js';
+export * from './server.js';

package/packages/server/dist/index.js

@@ -290,6 +290,19 @@ import { BinaryWriter as BinaryWriter2, ServerCommand as ServerCommand2, BinaryS
 import { parseBsp } from "@quake2ts/engine";
 import fs from "fs/promises";
 import { createPlayerInventory, createPlayerWeaponStates } from "@quake2ts/game";
+
+// src/server.ts
+var ServerState = /* @__PURE__ */ ((ServerState2) => {
+  ServerState2[ServerState2["Dead"] = 0] = "Dead";
+  ServerState2[ServerState2["Loading"] = 1] = "Loading";
+  ServerState2[ServerState2["Game"] = 2] = "Game";
+  ServerState2[ServerState2["Cinematic"] = 3] = "Cinematic";
+  ServerState2[ServerState2["Demo"] = 4] = "Demo";
+  ServerState2[ServerState2["Pic"] = 5] = "Pic";
+  return ServerState2;
+})(ServerState || {});
+
+// src/dedicated.ts
 import { writeDeltaEntity, writeRemoveEntity } from "@quake2ts/shared";
 
 // src/protocol/player.ts
@@ -962,7 +975,11 @@ var DedicatedServer = class {
   }
   onClientMessage(client, data) {
     const buffer = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength ? data.buffer : data.slice().buffer;
-    client.messageQueue.push(new Uint8Array(buffer));
+    if (buffer instanceof ArrayBuffer) {
+      client.messageQueue.push(new Uint8Array(buffer));
+    } else {
+      client.messageQueue.push(new Uint8Array(buffer));
+    }
   }
   onClientDisconnect(client) {
     console.log(`Client ${client.index} disconnected`);
@@ -1188,7 +1205,13 @@ var DedicatedServer = class {
         if (data.length === 0) {
           continue;
         }
-        const reader = new BinaryStream2(data.buffer);
+        let buffer;
+        if (data.buffer instanceof ArrayBuffer) {
+          buffer = data.buffer;
+        } else {
+          buffer = new Uint8Array(data).buffer;
+        }
+        const reader = new BinaryStream2(buffer);
         const parser = new ClientMessageParser(reader, {
           onMove: (checksum, lastFrame, cmd) => this.handleMove(client, cmd, checksum, lastFrame),
           onUserInfo: (info) => this.handleUserInfo(client, info),
@@ -1531,6 +1554,7 @@ export {
   ClientMessageParser,
   ClientState,
   DedicatedServer,
+  ServerState,
   WebSocketNetDriver,
   createClient,
   createServer

package/packages/server/dist/net/nodeWsDriver.d.ts

@@ -0,0 +1,16 @@
+import { NetDriver } from '@quake2ts/shared';
+import WebSocket from 'ws';
+export declare class WebSocketNetDriver implements NetDriver {
+    private socket;
+    private messageCallback;
+    private closeCallback;
+    private errorCallback;
+    connect(url: string): Promise<void>;
+    attach(socket: WebSocket): void;
+    disconnect(): void;
+    send(data: Uint8Array): void;
+    onMessage(callback: (data: Uint8Array) => void): void;
+    onClose(callback: () => void): void;
+    onError(callback: (error: Error) => void): void;
+    isConnected(): boolean;
+}

package/packages/server/dist/net/nodeWsDriver.js

@@ -0,0 +1,122 @@
+import WebSocket from 'ws';
+export class WebSocketNetDriver {
+    constructor() {
+        this.socket = null;
+        this.messageCallback = null;
+        this.closeCallback = null;
+        this.errorCallback = null;
+    }
+    async connect(url) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.socket = new WebSocket(url);
+                this.socket.binaryType = 'arraybuffer';
+                this.socket.onopen = () => {
+                    resolve();
+                };
+                this.socket.onerror = (event) => {
+                    const error = new Error('WebSocket connection error ' + event.message);
+                    if (this.errorCallback) {
+                        this.errorCallback(error);
+                    }
+                    reject(error);
+                };
+                this.socket.onclose = () => {
+                    if (this.closeCallback) {
+                        this.closeCallback();
+                    }
+                    this.socket = null;
+                };
+                this.socket.onmessage = (event) => {
+                    if (this.messageCallback) {
+                        if (event.data instanceof ArrayBuffer) {
+                            this.messageCallback(new Uint8Array(event.data));
+                        }
+                        else if (Buffer.isBuffer(event.data)) {
+                            // ws in Node might return Buffer
+                            this.messageCallback(new Uint8Array(event.data));
+                        }
+                        else if (Array.isArray(event.data)) {
+                            // Buffer[]
+                            const totalLength = event.data.reduce((acc, buf) => acc + buf.length, 0);
+                            const result = new Uint8Array(totalLength);
+                            let offset = 0;
+                            for (const buf of event.data) {
+                                result.set(buf, offset);
+                                offset += buf.length;
+                            }
+                            this.messageCallback(result);
+                        }
+                        else {
+                            console.warn('Received non-binary message from server', typeof event.data);
+                        }
+                    }
+                };
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    // Method to attach an existing socket (server-side incoming connection)
+    attach(socket) {
+        this.socket = socket;
+        this.socket.binaryType = 'arraybuffer';
+        this.socket.onclose = () => {
+            if (this.closeCallback)
+                this.closeCallback();
+            this.socket = null;
+        };
+        this.socket.onerror = (event) => {
+            if (this.errorCallback)
+                this.errorCallback(new Error(event.message));
+        };
+        this.socket.onmessage = (event) => {
+            if (this.messageCallback) {
+                if (event.data instanceof ArrayBuffer) {
+                    this.messageCallback(new Uint8Array(event.data));
+                }
+                else if (Buffer.isBuffer(event.data)) {
+                    this.messageCallback(new Uint8Array(event.data));
+                }
+                else if (Array.isArray(event.data)) { // ws specific
+                    // handle fragmentation if necessary, usually it's Buffer[]
+                    const totalLength = event.data.reduce((acc, buf) => acc + buf.length, 0);
+                    const result = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for (const buf of event.data) {
+                        result.set(buf, offset);
+                        offset += buf.length;
+                    }
+                    this.messageCallback(result);
+                }
+            }
+        };
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+    }
+    send(data) {
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(data);
+        }
+        else {
+            console.warn('Attempted to send data on closed or connecting socket');
+        }
+    }
+    onMessage(callback) {
+        this.messageCallback = callback;
+    }
+    onClose(callback) {
+        this.closeCallback = callback;
+    }
+    onError(callback) {
+        this.errorCallback = callback;
+    }
+    isConnected() {
+        return this.socket !== null && this.socket.readyState === WebSocket.OPEN;
+    }
+}

package/packages/server/dist/protocol/player.d.ts

@@ -0,0 +1,23 @@
+import { BinaryWriter, Vec3 } from '@quake2ts/shared';
+export interface ProtocolPlayerState {
+    pm_type: number;
+    origin: Vec3;
+    velocity: Vec3;
+    pm_time: number;
+    pm_flags: number;
+    gravity: number;
+    delta_angles: Vec3;
+    viewoffset: Vec3;
+    viewangles: Vec3;
+    kick_angles: Vec3;
+    gun_index: number;
+    gun_frame: number;
+    gun_offset: Vec3;
+    gun_angles: Vec3;
+    blend: number[];
+    fov: number;
+    rdflags: number;
+    stats: number[];
+    watertype: number;
+}
+export declare function writePlayerState(writer: BinaryWriter, ps: ProtocolPlayerState): void;

package/packages/server/dist/protocol/player.js

@@ -0,0 +1,137 @@
+// Bitflags matching demo/parser.ts
+const PS_M_TYPE = (1 << 0);
+const PS_M_ORIGIN = (1 << 1);
+const PS_M_VELOCITY = (1 << 2);
+const PS_M_TIME = (1 << 3);
+const PS_M_FLAGS = (1 << 4);
+const PS_M_GRAVITY = (1 << 5);
+const PS_M_DELTA_ANGLES = (1 << 6);
+const PS_VIEWOFFSET = (1 << 7);
+const PS_VIEWANGLES = (1 << 8);
+const PS_KICKANGLES = (1 << 9);
+const PS_BLEND = (1 << 10);
+const PS_FOV = (1 << 11);
+const PS_WEAPONINDEX = (1 << 12);
+const PS_WEAPONFRAME = (1 << 13);
+const PS_RDFLAGS = (1 << 14);
+const PS_WATERTYPE = (1 << 15);
+export function writePlayerState(writer, ps) {
+    // Determine mask
+    let mask = 0;
+    if (ps.pm_type !== 0)
+        mask |= PS_M_TYPE;
+    if (ps.origin.x !== 0 || ps.origin.y !== 0 || ps.origin.z !== 0)
+        mask |= PS_M_ORIGIN;
+    if (ps.velocity.x !== 0 || ps.velocity.y !== 0 || ps.velocity.z !== 0)
+        mask |= PS_M_VELOCITY;
+    if (ps.pm_time !== 0)
+        mask |= PS_M_TIME;
+    if (ps.pm_flags !== 0)
+        mask |= PS_M_FLAGS;
+    if (ps.gravity !== 0)
+        mask |= PS_M_GRAVITY;
+    if (ps.delta_angles.x !== 0 || ps.delta_angles.y !== 0 || ps.delta_angles.z !== 0)
+        mask |= PS_M_DELTA_ANGLES;
+    if (ps.viewoffset.x !== 0 || ps.viewoffset.y !== 0 || ps.viewoffset.z !== 0)
+        mask |= PS_VIEWOFFSET;
+    if (ps.viewangles.x !== 0 || ps.viewangles.y !== 0 || ps.viewangles.z !== 0)
+        mask |= PS_VIEWANGLES;
+    if (ps.kick_angles.x !== 0 || ps.kick_angles.y !== 0 || ps.kick_angles.z !== 0)
+        mask |= PS_KICKANGLES;
+    if (ps.gun_index !== 0)
+        mask |= PS_WEAPONINDEX;
+    // Weapon frame includes offset/angles
+    if (ps.gun_frame !== 0 ||
+        ps.gun_offset.x !== 0 || ps.gun_offset.y !== 0 || ps.gun_offset.z !== 0 ||
+        ps.gun_angles.x !== 0 || ps.gun_angles.y !== 0 || ps.gun_angles.z !== 0) {
+        mask |= PS_WEAPONFRAME;
+    }
+    if (ps.blend && (ps.blend[0] !== 0 || ps.blend[1] !== 0 || ps.blend[2] !== 0 || ps.blend[3] !== 0)) {
+        mask |= PS_BLEND;
+    }
+    if (ps.fov !== 0)
+        mask |= PS_FOV;
+    if (ps.rdflags !== 0)
+        mask |= PS_RDFLAGS;
+    if (ps.watertype !== 0)
+        mask |= PS_WATERTYPE;
+    // Stats mask calculation
+    let statsMask = 0;
+    // Only support first 32 stats for now
+    for (let i = 0; i < 32; i++) {
+        if (ps.stats[i] && ps.stats[i] !== 0) {
+            statsMask |= (1 << i);
+        }
+    }
+    // Write header
+    writer.writeShort(mask);
+    // Write fields
+    if (mask & PS_M_TYPE)
+        writer.writeByte(ps.pm_type);
+    if (mask & PS_M_ORIGIN) {
+        writer.writeShort(Math.round(ps.origin.x * 8));
+        writer.writeShort(Math.round(ps.origin.y * 8));
+        writer.writeShort(Math.round(ps.origin.z * 8));
+    }
+    if (mask & PS_M_VELOCITY) {
+        writer.writeShort(Math.round(ps.velocity.x * 8));
+        writer.writeShort(Math.round(ps.velocity.y * 8));
+        writer.writeShort(Math.round(ps.velocity.z * 8));
+    }
+    if (mask & PS_M_TIME)
+        writer.writeByte(ps.pm_time);
+    if (mask & PS_M_FLAGS)
+        writer.writeByte(ps.pm_flags);
+    if (mask & PS_M_GRAVITY)
+        writer.writeShort(ps.gravity);
+    if (mask & PS_M_DELTA_ANGLES) {
+        writer.writeShort(Math.round(ps.delta_angles.x * (32768 / 180)));
+        writer.writeShort(Math.round(ps.delta_angles.y * (32768 / 180)));
+        writer.writeShort(Math.round(ps.delta_angles.z * (32768 / 180)));
+    }
+    if (mask & PS_VIEWOFFSET) {
+        writer.writeChar(Math.round(ps.viewoffset.x * 4));
+        writer.writeChar(Math.round(ps.viewoffset.y * 4));
+        writer.writeChar(Math.round(ps.viewoffset.z * 4));
+    }
+    if (mask & PS_VIEWANGLES) {
+        writer.writeAngle16(ps.viewangles.x);
+        writer.writeAngle16(ps.viewangles.y);
+        writer.writeAngle16(ps.viewangles.z);
+    }
+    if (mask & PS_KICKANGLES) {
+        writer.writeChar(Math.round(ps.kick_angles.x * 4));
+        writer.writeChar(Math.round(ps.kick_angles.y * 4));
+        writer.writeChar(Math.round(ps.kick_angles.z * 4));
+    }
+    if (mask & PS_WEAPONINDEX)
+        writer.writeByte(ps.gun_index);
+    if (mask & PS_WEAPONFRAME) {
+        writer.writeByte(ps.gun_frame);
+        writer.writeChar(Math.round(ps.gun_offset.x * 4));
+        writer.writeChar(Math.round(ps.gun_offset.y * 4));
+        writer.writeChar(Math.round(ps.gun_offset.z * 4));
+        writer.writeChar(Math.round(ps.gun_angles.x * 4));
+        writer.writeChar(Math.round(ps.gun_angles.y * 4));
+        writer.writeChar(Math.round(ps.gun_angles.z * 4));
+    }
+    if (mask & PS_BLEND) {
+        writer.writeByte(Math.round(ps.blend[0]));
+        writer.writeByte(Math.round(ps.blend[1]));
+        writer.writeByte(Math.round(ps.blend[2]));
+        writer.writeByte(Math.round(ps.blend[3]));
+    }
+    if (mask & PS_FOV)
+        writer.writeByte(ps.fov);
+    if (mask & PS_RDFLAGS)
+        writer.writeByte(ps.rdflags);
+    if (mask & PS_WATERTYPE)
+        writer.writeByte(ps.watertype);
+    // Write Stats
+    writer.writeLong(statsMask);
+    for (let i = 0; i < 32; i++) {
+        if (statsMask & (1 << i)) {
+            writer.writeShort(ps.stats[i]);
+        }
+    }
+}

package/packages/server/dist/protocol/write.d.ts

@@ -0,0 +1,7 @@
+import { BinaryWriter, ServerCommand } from '@quake2ts/shared';
+/**
+ * Writes a server command and its arguments to a BinaryWriter.
+ * This handles the serialization of generic arguments passed to multicast/unicast
+ * into the specific binary format expected by the protocol.
+ */
+export declare function writeServerCommand(writer: BinaryWriter, event: ServerCommand, ...args: any[]): void;