quake2ts 0.0.557 → 0.0.562

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

@@ -0,0 +1,167 @@
+import { ServerCommand, TempEntity } 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 function writeServerCommand(writer, event, ...args) {
+    writer.writeByte(event);
+    switch (event) {
+        case ServerCommand.print: {
+            // args: [level: number, text: string]
+            const level = args[0];
+            const text = args[1];
+            writer.writeByte(level);
+            writer.writeString(text);
+            break;
+        }
+        case ServerCommand.centerprint: {
+            // args: [text: string]
+            const text = args[0];
+            writer.writeString(text);
+            break;
+        }
+        case ServerCommand.stufftext: {
+            // args: [text: string]
+            const text = args[0];
+            writer.writeString(text);
+            break;
+        }
+        case ServerCommand.sound: {
+            // args: [flags, soundNum, volume?, attenuation?, offset?, ent?, pos?]
+            const flags = args[0];
+            const soundNum = args[1];
+            const volume = args[2];
+            const attenuation = args[3];
+            const offset = args[4];
+            const ent = args[5];
+            const pos = args[6];
+            writer.writeByte(flags);
+            writer.writeByte(soundNum);
+            if (flags & 1) { // SND_VOLUME
+                writer.writeByte(volume || 0);
+            }
+            if (flags & 2) { // SND_ATTENUATION
+                writer.writeByte(attenuation || 0);
+            }
+            if (flags & 16) { // SND_OFFSET
+                writer.writeByte(offset || 0);
+            }
+            if (flags & 8) { // SND_ENT
+                writer.writeShort(ent || 0);
+            }
+            if (flags & 4) { // SND_POS
+                if (pos) {
+                    writer.writePos(pos);
+                }
+                else {
+                    writer.writePos({ x: 0, y: 0, z: 0 });
+                }
+            }
+            break;
+        }
+        case ServerCommand.muzzleflash: {
+            // args: [entityIndex: number, flashType: number]
+            const entIndex = args[0];
+            const flashType = args[1];
+            writer.writeShort(entIndex);
+            writer.writeByte(flashType);
+            break;
+        }
+        case ServerCommand.temp_entity: {
+            // args: [type: TempEntity, ...params]
+            const type = args[0];
+            writer.writeByte(type);
+            writeTempEntity(writer, type, args.slice(1));
+            break;
+        }
+        default:
+            console.warn(`writeServerCommand: Unhandled command ${event}`);
+            break;
+    }
+}
+function writeTempEntity(writer, type, args) {
+    switch (type) {
+        case TempEntity.ROCKET_EXPLOSION:
+        case TempEntity.GRENADE_EXPLOSION:
+        case TempEntity.EXPLOSION1:
+        case TempEntity.EXPLOSION2:
+        case TempEntity.ROCKET_EXPLOSION_WATER:
+        case TempEntity.GRENADE_EXPLOSION_WATER:
+        case TempEntity.BFG_EXPLOSION:
+        case TempEntity.BFG_BIGEXPLOSION:
+        case TempEntity.PLASMA_EXPLOSION:
+        case TempEntity.PLAIN_EXPLOSION:
+        case TempEntity.TRACKER_EXPLOSION:
+        case TempEntity.EXPLOSION1_BIG:
+        case TempEntity.EXPLOSION1_NP:
+        case TempEntity.EXPLOSION1_NL:
+        case TempEntity.EXPLOSION2_NL:
+        case TempEntity.BERSERK_SLAM:
+            // Format: [pos]
+            writer.writePos(args[0]);
+            break;
+        case TempEntity.BLASTER:
+        case TempEntity.FLECHETTE:
+            // Format: [pos, dir]
+            writer.writePos(args[0]);
+            writer.writeDir(args[1]);
+            break;
+        case TempEntity.RAILTRAIL:
+        case TempEntity.DEBUGTRAIL:
+        case TempEntity.BUBBLETRAIL:
+        case TempEntity.BUBBLETRAIL2:
+        case TempEntity.BFG_LASER:
+        case TempEntity.LIGHTNING_BEAM:
+        case TempEntity.LIGHTNING:
+            // Format: [start, end]
+            writer.writePos(args[0]);
+            writer.writePos(args[1]);
+            break;
+        case TempEntity.LASER_SPARKS:
+        case TempEntity.WELDING_SPARKS:
+        case TempEntity.TUNNEL_SPARKS:
+        case TempEntity.ELECTRIC_SPARKS:
+        case TempEntity.HEATBEAM_SPARKS:
+        case TempEntity.HEATBEAM_STEAM:
+        case TempEntity.STEAM:
+            // Format: [count, pos, dir, color?]
+            // Q2: writeByte(count), writePos(start), writeDir(normal), writeByte(skin/color)
+            writer.writeByte(args[0]);
+            writer.writePos(args[1]);
+            writer.writeDir(args[2]);
+            writer.writeByte(args[3] || 0);
+            break;
+        case TempEntity.PARASITE_ATTACK:
+        case TempEntity.MEDIC_CABLE_ATTACK:
+            // Format: [entIndex, start, end]
+            // args[0] is Entity usually
+            const ent = args[0];
+            writer.writeShort(ent ? ent.index : 0);
+            writer.writePos(args[1]);
+            writer.writePos(args[2]);
+            break;
+        case TempEntity.GUNSHOT:
+        case TempEntity.BLOOD:
+        case TempEntity.SPARKS:
+        case TempEntity.BULLET_SPARKS:
+        case TempEntity.SCREEN_SPARKS:
+        case TempEntity.SHIELD_SPARKS:
+            // Format: [pos, dir]
+            writer.writePos(args[0]);
+            writer.writeDir(args[1]);
+            break;
+        case TempEntity.SPLASH:
+        case TempEntity.POWER_SPLASH:
+        case TempEntity.WIDOWSPLASH:
+            // Format: [count, pos, dir, color]
+            writer.writeByte(args[0]);
+            writer.writePos(args[1]);
+            writer.writeDir(args[2]);
+            writer.writeByte(args[3] || 0);
+            break;
+        default:
+            console.warn(`writeTempEntity: Unhandled TempEntity ${type}`);
+            break;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BinaryStream, UserCommand } from '@quake2ts/shared';
+export interface ClientMessageHandler {
+    onMove(checksum: number, lastFrame: number, userCmd: UserCommand): void;
+    onUserInfo(info: string): void;
+    onStringCmd(cmd: string): void;
+    onNop(): void;
+    onBad(): void;
+}
+export declare class ClientMessageParser {
+    private stream;
+    private handler;
+    constructor(stream: BinaryStream, handler: ClientMessageHandler);
+    parseMessage(): void;
+    private parseMove;
+    private parseUserInfo;
+    private parseStringCmd;
+}

package/packages/server/dist/protocol.js

@@ -0,0 +1,71 @@
+import { ClientCommand } from '@quake2ts/shared';
+export class ClientMessageParser {
+    constructor(stream, handler) {
+        this.stream = stream;
+        this.handler = handler;
+    }
+    parseMessage() {
+        while (this.stream.hasMore()) {
+            const cmdId = this.stream.readByte();
+            if (cmdId === -1)
+                break;
+            switch (cmdId) {
+                case ClientCommand.move:
+                    this.parseMove();
+                    break;
+                case ClientCommand.userinfo:
+                    this.parseUserInfo();
+                    break;
+                case ClientCommand.stringcmd:
+                    this.parseStringCmd();
+                    break;
+                case ClientCommand.nop:
+                    this.handler.onNop();
+                    break;
+                default:
+                    console.warn(`Unknown client command: ${cmdId}`);
+                    this.handler.onBad();
+                    return;
+            }
+        }
+    }
+    parseMove() {
+        const checksum = this.stream.readByte();
+        const lastFrame = this.stream.readLong();
+        // Read UserCmd
+        // TODO: support delta compression if needed (Q2 uses delta compression for usercmds)
+        // For now, assume full UserCmd or implement basic read
+        const msec = this.stream.readByte();
+        const buttons = this.stream.readByte();
+        const angles = {
+            x: this.stream.readShort() * (360.0 / 65536.0),
+            y: this.stream.readShort() * (360.0 / 65536.0),
+            z: this.stream.readShort() * (360.0 / 65536.0),
+        };
+        const forwardmove = this.stream.readShort();
+        const sidemove = this.stream.readShort();
+        const upmove = this.stream.readShort();
+        const impulse = this.stream.readByte();
+        const lightlevel = this.stream.readByte(); // Used for light-based stealth, usually ignored by server logic except for stats
+        const userCmd = {
+            msec,
+            buttons,
+            angles,
+            forwardmove,
+            sidemove,
+            upmove,
+            impulse,
+            lightlevel,
+            sequence: 0 // Server doesn't read sequence from packet body in standard protocol, it tracks it
+        };
+        this.handler.onMove(checksum, lastFrame, userCmd);
+    }
+    parseUserInfo() {
+        const info = this.stream.readString();
+        this.handler.onUserInfo(info);
+    }
+    parseStringCmd() {
+        const cmd = this.stream.readString();
+        this.handler.onStringCmd(cmd);
+    }
+}

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

@@ -0,0 +1,50 @@
+import { CollisionModel } from "@quake2ts/shared";
+import { EntityState } from "@quake2ts/shared";
+import { Client } from "./client.js";
+/**
+ * ServerState corresponds to server_state_t in the original source.
+ */
+export declare enum ServerState {
+    Dead = 0,// no map loaded
+    Loading = 1,// spawning level edicts
+    Game = 2,// actively running
+    Cinematic = 3,
+    Demo = 4,
+    Pic = 5
+}
+export interface Challenge {
+    adr: string;
+    challenge: number;
+    time: number;
+}
+/**
+ * ServerStatic holds the state that is constant across server restarts.
+ * Corresponds to server_static_t in the original source.
+ */
+export interface ServerStatic {
+    initialized: boolean;
+    realTime: number;
+    mapCmd: string;
+    spawnCount: number;
+    clients: (Client | null)[];
+    lastHeartbeat: number;
+    challenges: Challenge[];
+    demoFile?: any;
+}
+/**
+ * Server holds the state for the current running server instance.
+ * Corresponds to server_t in the original source.
+ */
+export interface Server {
+    state: ServerState;
+    attractLoop: boolean;
+    loadGame: boolean;
+    startTime: number;
+    time: number;
+    frame: number;
+    name: string;
+    collisionModel: CollisionModel | null;
+    configStrings: string[];
+    baselines: (EntityState | null)[];
+    multicastBuf: Uint8Array;
+}

package/packages/server/dist/server.js

@@ -0,0 +1,12 @@
+/**
+ * ServerState corresponds to server_state_t in the original source.
+ */
+export var ServerState;
+(function (ServerState) {
+    ServerState[ServerState["Dead"] = 0] = "Dead";
+    ServerState[ServerState["Loading"] = 1] = "Loading";
+    ServerState[ServerState["Game"] = 2] = "Game";
+    ServerState[ServerState["Cinematic"] = 3] = "Cinematic";
+    ServerState[ServerState["Demo"] = 4] = "Demo";
+    ServerState[ServerState["Pic"] = 5] = "Pic";
+})(ServerState || (ServerState = {}));

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

@@ -0,0 +1 @@
+export {};

package/packages/server/dist/server.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DedicatedServer, createServer } from './dedicated.js';
+// Mock dependencies
+vi.mock('node:fs/promises', () => ({
+    default: {
+        readFile: vi.fn().mockResolvedValue(Buffer.alloc(100))
+    }
+}));
+vi.mock('@quake2ts/engine', () => ({
+    parseBsp: vi.fn().mockReturnValue({
+        planes: [],
+        nodes: [],
+        leafs: [],
+        brushes: [],
+        models: [],
+        leafLists: { leafBrushes: [] },
+        texInfo: [],
+        brushSides: [],
+        visibility: { numClusters: 0, clusters: [] } // Add visibility to mock
+    })
+}));
+// Mock Transport
+class MockTransport {
+    async listen(port) {
+        return Promise.resolve();
+    }
+    close() { }
+    onConnection(callback) {
+        this.onConnectionCallback = callback;
+    }
+    onError(callback) {
+        this.onErrorCallback = callback;
+    }
+}
+describe('DedicatedServer', () => {
+    let server;
+    let transport;
+    beforeEach(() => {
+        transport = new MockTransport();
+    });
+    afterEach(() => {
+        if (server) {
+            server.stopServer();
+        }
+    });
+    it('should create a server with default options', () => {
+        server = createServer({ transport });
+        expect(server).toBeInstanceOf(DedicatedServer);
+    });
+    it('should start and stop with custom transport', async () => {
+        server = createServer({ transport });
+        await expect(server.startServer('maps/test.bsp')).resolves.not.toThrow();
+        server.stopServer();
+    });
+    it('should fail to start without map', async () => {
+        server = createServer({ transport });
+        await expect(server.startServer()).rejects.toThrow('No map specified');
+    });
+    it('should kick player', () => {
+        server = createServer({ transport });
+        // Just verify method exists and runs safely on empty server
+        expect(() => server.kickPlayer(0)).not.toThrow();
+    });
+    it('should change map', async () => {
+        server = createServer({ transport });
+        await server.startServer('maps/q2dm1.bsp');
+        await expect(server.changeMap('maps/q2dm2.bsp')).resolves.not.toThrow();
+    });
+});

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

@@ -0,0 +1,7 @@
+import { NetDriver } from '@quake2ts/shared';
+export interface NetworkTransport {
+    listen(port: number): Promise<void>;
+    close(): void;
+    onConnection(callback: (driver: NetDriver, info?: any) => void): void;
+    onError(callback: (error: Error) => void): void;
+}

package/packages/server/dist/transport.js

@@ -0,0 +1 @@
+export {};

package/packages/server/dist/transports/websocket.d.ts

@@ -0,0 +1,11 @@
+import { NetworkTransport } from '../transport.js';
+import { NetDriver } from '@quake2ts/shared';
+export declare class WebSocketTransport implements NetworkTransport {
+    private wss;
+    private connectionCallback;
+    private errorCallback;
+    listen(port: number): Promise<void>;
+    close(): void;
+    onConnection(callback: (driver: NetDriver, info?: any) => void): void;
+    onError(callback: (error: Error) => void): void;
+}

package/packages/server/dist/transports/websocket.js

@@ -0,0 +1,38 @@
+import { WebSocketServer } from 'ws';
+import { WebSocketNetDriver } from '../net/nodeWsDriver.js';
+export class WebSocketTransport {
+    constructor() {
+        this.wss = null;
+        this.connectionCallback = null;
+        this.errorCallback = null;
+    }
+    async listen(port) {
+        return new Promise((resolve) => {
+            this.wss = new WebSocketServer({ port });
+            this.wss.on('listening', () => resolve());
+            this.wss.on('connection', (ws, req) => {
+                const driver = new WebSocketNetDriver();
+                driver.attach(ws);
+                if (this.connectionCallback) {
+                    this.connectionCallback(driver, req);
+                }
+            });
+            this.wss.on('error', (err) => {
+                if (this.errorCallback)
+                    this.errorCallback(err);
+            });
+        });
+    }
+    close() {
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+        }
+    }
+    onConnection(callback) {
+        this.connectionCallback = callback;
+    }
+    onError(callback) {
+        this.errorCallback = callback;
+    }
+}