@quake2ts/server 0.0.1

package/tests/protocol/player.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { BinaryWriter } from '@quake2ts/shared';
+import { writePlayerState, ProtocolPlayerState } from '../../src/protocol/player.js';
+import { parseProtocolPlayerState } from '@quake2ts/test-utils';
+
+describe('writePlayerState', () => {
+    it('should write an empty state as just flags (plus statbits)', () => {
+        const writer = new BinaryWriter();
+        const emptyState: ProtocolPlayerState = {
+            pm_type: 0, origin: {x:0,y:0,z:0}, velocity: {x:0,y:0,z:0}, pm_time: 0, pm_flags: 0, gravity: 0,
+            delta_angles: {x:0,y:0,z:0}, viewoffset: {x:0,y:0,z:0}, viewangles: {x:0,y:0,z:0}, kick_angles: {x:0,y:0,z:0},
+            gun_index: 0, gun_frame: 0, gun_offset: {x:0,y:0,z:0}, gun_angles: {x:0,y:0,z:0},
+            blend: [0,0,0,0], fov: 0, rdflags: 0, stats: new Array(32).fill(0), watertype: 0
+        };
+
+        writePlayerState(writer, emptyState);
+        const data = writer.getData();
+        const readState = parseProtocolPlayerState(data);
+
+        expect(readState.pm_type).toBe(0);
+        expect(readState.origin.x).toBe(0);
+        expect(readState.stats[0]).toBe(0);
+        expect(readState.watertype).toBe(0);
+    });
+
+    it('should correctly round-trip all fields', () => {
+        const writer = new BinaryWriter();
+        const state: ProtocolPlayerState = {
+            pm_type: 1,
+            origin: { x: 10, y: -20, z: 30 },
+            velocity: { x: 100, y: -50, z: 0 },
+            pm_time: 123,
+            pm_flags: 4,
+            gravity: 800,
+            delta_angles: { x: 10, y: 20, z: 30 },
+            viewoffset: { x: 5, y: -5, z: 10 },
+            viewangles: { x: 45, y: 90, z: 0 },
+            kick_angles: { x: 1, y: 2, z: 3 },
+            gun_index: 5,
+            gun_frame: 12,
+            gun_offset: { x: 1, y: 2, z: 3 },
+            gun_angles: { x: 4, y: 5, z: 6 },
+            blend: [255, 128, 64, 32],
+            fov: 90,
+            rdflags: 7,
+            stats: new Array(32).fill(0),
+            watertype: 128 // Custom flag
+        };
+        state.stats[1] = 100; // Health
+        state.stats[3] = 50;  // Ammo
+
+        writePlayerState(writer, state);
+        const data = writer.getData();
+        const read = parseProtocolPlayerState(data);
+
+        // Verification with tolerances for precision loss (1/8 units, etc)
+        expect(read.pm_type).toBe(state.pm_type);
+        expect(read.origin.x).toBe(state.origin.x);
+        expect(read.velocity.x).toBe(state.velocity.x);
+        expect(read.pm_time).toBe(state.pm_time);
+        expect(read.gravity).toBe(state.gravity);
+        expect(read.viewangles.x).toBeCloseTo(state.viewangles.x, 0.1);
+        expect(read.blend).toEqual(state.blend);
+        expect(read.stats[1]).toBe(100);
+        expect(read.stats[3]).toBe(50);
+        expect(read.gun_index).toBe(5);
+        expect(read.gun_frame).toBe(12);
+        expect(read.watertype).toBe(128);
+    });
+
+    it('should ignore stats > 31', () => {
+        const writer = new BinaryWriter();
+        const state: ProtocolPlayerState = {
+            pm_type: 0, origin: {x:0,y:0,z:0}, velocity: {x:0,y:0,z:0}, pm_time: 0, pm_flags: 0, gravity: 0,
+            delta_angles: {x:0,y:0,z:0}, viewoffset: {x:0,y:0,z:0}, viewangles: {x:0,y:0,z:0}, kick_angles: {x:0,y:0,z:0},
+            gun_index: 0, gun_frame: 0, gun_offset: {x:0,y:0,z:0}, gun_angles: {x:0,y:0,z:0},
+            blend: [0,0,0,0], fov: 0, rdflags: 0, stats: new Array(64).fill(0), watertype: 0
+        };
+        state.stats[31] = 999;
+        state.stats[32] = 123; // Should be ignored
+
+        writePlayerState(writer, state);
+        const read = parseProtocolPlayerState(writer.getData());
+
+        expect(read.stats[31]).toBe(999);
+        expect(read.stats[32]).toBeUndefined(); // Array size is 32 in reader
+    });
+});

package/tests/protocol/write.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { BinaryWriter, ServerCommand, TempEntity, Vec3 } from '@quake2ts/shared';
+import { writeServerCommand } from '../../src/protocol/write.js';
+import { Entity } from '@quake2ts/game';
+
+describe('writeServerCommand', () => {
+    it('writes ServerCommand.print', () => {
+        const writer = new BinaryWriter();
+        writeServerCommand(writer, ServerCommand.print, 1, "Hello World\n");
+        const data = writer.getData();
+
+        // Expect: [cmd (10), level (1), string ("Hello World\n")]
+        expect(data[0]).toBe(ServerCommand.print);
+        expect(data[1]).toBe(1);
+
+        // String check: 'H' is 72 ...
+        expect(String.fromCharCode(data[2])).toBe('H');
+    });
+
+    it('writes ServerCommand.muzzleflash', () => {
+        const writer = new BinaryWriter();
+        writeServerCommand(writer, ServerCommand.muzzleflash, 42, 128);
+        const data = writer.getData();
+
+        // Expect: [cmd (1), ent (42, short), flash (128, byte)]
+        expect(data[0]).toBe(ServerCommand.muzzleflash);
+        // short 42 = 42, 0
+        expect(data[1]).toBe(42);
+        expect(data[2]).toBe(0);
+        expect(data[3]).toBe(128);
+    });
+
+    it('writes TempEntity.ROCKET_EXPLOSION', () => {
+        const writer = new BinaryWriter();
+        const pos: Vec3 = { x: 10, y: 20, z: 30 };
+        writeServerCommand(writer, ServerCommand.temp_entity, TempEntity.ROCKET_EXPLOSION, pos);
+        const data = writer.getData();
+
+        // Expect: [cmd (3), type (7), pos (x, y, z as shorts * 8)]
+        expect(data[0]).toBe(ServerCommand.temp_entity);
+        expect(data[1]).toBe(TempEntity.ROCKET_EXPLOSION);
+
+        // 10 * 8 = 80
+        expect(data[2]).toBe(80);
+        expect(data[3]).toBe(0);
+    });
+
+    it('writes TempEntity.PARASITE_ATTACK', () => {
+        const writer = new BinaryWriter();
+        const ent = { index: 99 } as Entity;
+        const start: Vec3 = { x: 1, y: 1, z: 1 };
+        const end: Vec3 = { x: 2, y: 2, z: 2 };
+
+        writeServerCommand(writer, ServerCommand.temp_entity, TempEntity.PARASITE_ATTACK, ent, start, end);
+        const data = writer.getData();
+
+        // Expect: [cmd, type, short ent, pos start, pos end]
+        expect(data[0]).toBe(ServerCommand.temp_entity);
+        expect(data[1]).toBe(TempEntity.PARASITE_ATTACK);
+
+        // Ent index 99
+        expect(data[2]).toBe(99);
+        expect(data[3]).toBe(0);
+    });
+
+    it('writes ServerCommand.centerprint', () => {
+        const writer = new BinaryWriter();
+        writeServerCommand(writer, ServerCommand.centerprint, "Center Msg");
+        const data = writer.getData();
+
+        expect(data[0]).toBe(ServerCommand.centerprint);
+        // "Center Msg" is 10 chars + null terminator = 11 bytes
+        expect(data.length).toBe(1 + 11);
+        expect(String.fromCharCode(data[1])).toBe('C');
+    });
+
+    it('writes ServerCommand.stufftext', () => {
+        const writer = new BinaryWriter();
+        writeServerCommand(writer, ServerCommand.stufftext, "cmd\n");
+        const data = writer.getData();
+
+        expect(data[0]).toBe(ServerCommand.stufftext);
+        expect(data.length).toBe(1 + 5);
+        expect(String.fromCharCode(data[1])).toBe('c');
+    });
+
+    it('writes ServerCommand.sound', () => {
+        const writer = new BinaryWriter();
+        const flags = 1 | 8; // SND_VOLUME | SND_ENT
+        const soundNum = 5;
+        const volume = 255;
+        const ent = 10;
+
+        // args: flags, soundNum, volume, attenuation, offset, ent, pos
+        writeServerCommand(writer, ServerCommand.sound, flags, soundNum, volume, undefined, undefined, ent, undefined);
+        const data = writer.getData();
+
+        // Format: [cmd, flags, soundNum, volume (if flag), ent (short, if flag)]
+        let idx = 0;
+        expect(data[idx++]).toBe(ServerCommand.sound);
+        expect(data[idx++]).toBe(flags);
+        expect(data[idx++]).toBe(soundNum);
+        expect(data[idx++]).toBe(volume);
+        expect(data[idx++]).toBe(10); // ent low byte
+        expect(data[idx++]).toBe(0); // ent high byte
+    });
+});

package/tests/protocol.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ClientMessageParser, ClientMessageHandler } from '../src/protocol.js';
+import { BinaryWriter, BinaryStream, ClientCommand } from '@quake2ts/shared';
+
+describe('ClientMessageParser', () => {
+  it('should parse NOP command', () => {
+    const writer = new BinaryWriter();
+    writer.writeByte(ClientCommand.nop);
+
+    const stream = new BinaryStream(writer.getData().buffer);
+    const handler = {
+        onMove: vi.fn(),
+        onUserInfo: vi.fn(),
+        onStringCmd: vi.fn(),
+        onNop: vi.fn(),
+        onBad: vi.fn()
+    };
+
+    const parser = new ClientMessageParser(stream, handler);
+    parser.parseMessage();
+
+    expect(handler.onNop).toHaveBeenCalled();
+  });
+
+  it('should parse StringCmd', () => {
+      const writer = new BinaryWriter();
+      writer.writeByte(ClientCommand.stringcmd);
+      writer.writeString("status");
+
+      const stream = new BinaryStream(writer.getData().buffer);
+      const handler = {
+          onMove: vi.fn(),
+          onUserInfo: vi.fn(),
+          onStringCmd: vi.fn(),
+          onNop: vi.fn(),
+          onBad: vi.fn()
+      };
+
+      const parser = new ClientMessageParser(stream, handler);
+      parser.parseMessage();
+
+      expect(handler.onStringCmd).toHaveBeenCalledWith("status");
+  });
+
+  it('should parse UserInfo', () => {
+      const writer = new BinaryWriter();
+      writer.writeByte(ClientCommand.userinfo);
+      writer.writeString("\\name\\Player\\skin\\male/grunt");
+
+      const stream = new BinaryStream(writer.getData().buffer);
+      const handler = {
+          onMove: vi.fn(),
+          onUserInfo: vi.fn(),
+          onStringCmd: vi.fn(),
+          onNop: vi.fn(),
+          onBad: vi.fn()
+      };
+
+      const parser = new ClientMessageParser(stream, handler);
+      parser.parseMessage();
+
+      expect(handler.onUserInfo).toHaveBeenCalledWith("\\name\\Player\\skin\\male/grunt");
+  });
+
+  it('should parse Move command (UserCmd)', () => {
+    const writer = new BinaryWriter();
+    writer.writeByte(ClientCommand.move);
+    writer.writeByte(123); // Checksum
+    writer.writeLong(100); // LastFrame
+    writer.writeByte(50); // msec
+    writer.writeByte(1); // buttons
+    writer.writeShort(0); // angles x
+    writer.writeShort(0); // angles y
+    writer.writeShort(0); // angles z
+    writer.writeShort(200); // forward
+    writer.writeShort(100); // side
+    writer.writeShort(50); // up
+    writer.writeByte(0); // impulse
+    writer.writeByte(0); // lightlevel
+
+    const stream = new BinaryStream(writer.getData().buffer);
+    const handler = {
+        onMove: vi.fn(),
+        onUserInfo: vi.fn(),
+        onStringCmd: vi.fn(),
+        onNop: vi.fn(),
+        onBad: vi.fn()
+    };
+
+    const parser = new ClientMessageParser(stream, handler);
+    parser.parseMessage();
+
+    expect(handler.onMove).toHaveBeenCalled();
+    const [checksum, lastFrame, cmd] = (handler.onMove as unknown as any).mock.calls[0];
+    expect(checksum).toBe(123);
+    expect(lastFrame).toBe(100);
+    expect(cmd.msec).toBe(50);
+    expect(cmd.forwardmove).toBe(200);
+    expect(cmd.sidemove).toBe(100);
+    expect(cmd.upmove).toBe(50);
+  });
+});

package/tests/server-state.test.ts

@@ -0,0 +1,17 @@
+
+import { describe, it, expect } from 'vitest';
+import { ClientState } from '../src/client.js';
+import { UPDATE_BACKUP } from '@quake2ts/shared';
+import { createMockServerClient } from '@quake2ts/test-utils';
+
+describe('Server State Structures', () => {
+    it('Client initialization should set default values correctly', () => {
+        const client = createMockServerClient(0);
+
+        expect(client.index).toBe(0);
+        expect(client.state).toBe(ClientState.Connected);
+        expect(client.frames.length).toBe(0); // Mock client has empty frames by default in test-utils factory unless overridden
+        expect(client.rate).toBe(0); // Mock client default
+        expect(client.lastCmd.msec).toBe(0);
+    });
+});

package/tests/server.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DedicatedServer, createServer } from '../src/dedicated.js';
+import { createMockTransport, MockTransport } from '@quake2ts/test-utils';
+
+// Mock dependencies
+vi.mock('node:fs/promises', () => ({
+    default: {
+        readFile: vi.fn().mockResolvedValue(Buffer.alloc(100))
+    }
+}));
+
+// Must import makeBspModel inside the mock factory to avoid hoisting issues
+vi.mock('@quake2ts/engine', async (importOriginal) => {
+    // We can't use the top-level import here because of hoisting.
+    // So we need to either inline the object or import dynamically if possible,
+    // but vitest mocks are synchronous usually.
+    // However, since we are mocking a return value, we can just return a plain object that looks like what makeBspModel returns
+    // OR we can rely on `await vi.importActual('@quake2ts/test-utils')` if we were mocking that module, but we are mocking `engine`.
+
+    // The error says "Cannot access '__vi_import_1__' before initialization".
+    // This is because `makeBspModel` is imported at top level but used in hoisted `vi.mock`.
+
+    // Solution: Just return a plain object matching the structure, or move `makeBspModel` call inside the test or `beforeEach` and use `vi.mocked`.
+    // But `parseBsp` is called internally by `DedicatedServer`.
+
+    // Let's just define a minimal object here that satisfies the requirements to avoid complexity.
+    return {
+        parseBsp: vi.fn().mockReturnValue({
+            planes: [],
+            nodes: [],
+            leafs: [],
+            brushes: [],
+            leafBrushes: [],
+            bmodels: [],
+            models: [],
+            texInfo: [],
+            brushSides: [],
+            visibility: { numClusters: 0, clusters: [] }
+        })
+    };
+});
+
+describe('DedicatedServer', () => {
+    let server: DedicatedServer;
+    let transport: MockTransport;
+    let consoleWarnSpy: any;
+    let consoleLogSpy: any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        transport = createMockTransport();
+        server = new DedicatedServer({ port: 27910, transport });
+
+        // Suppress expected console warnings and logs
+        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        consoleWarnSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        if (server) {
+            server.stopServer();
+        }
+    });
+
+    it('should create a server with default options', () => {
+        server = createServer({ transport });
+        expect(server).toBeInstanceOf(DedicatedServer);
+    });
+
+    it('should initialize WebSocketServer on start', async () => {
+        await server.startServer('test_map');
+        expect(transport.listenSpy).toHaveBeenCalledWith(27910);
+    });
+
+    it('should be able to stop', async () => {
+        await server.startServer('test_map');
+        server.stopServer();
+        expect(transport.closeSpy).toHaveBeenCalled();
+    });
+
+    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/tests/unit/dedicated_timeout.test.ts

@@ -0,0 +1,142 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DedicatedServer } from '../../src/dedicated.js';
+import { ClientState } from '../../src/client.js';
+import { createMockTransport, MockTransport, createMockServerClient, createMockNetDriver, createMockGameExports } from '@quake2ts/test-utils';
+import { NetDriver } from '@quake2ts/shared';
+
+// Mock dependencies
+vi.mock('node:fs/promises', async () => {
+    return {
+        default: {
+            readFile: vi.fn().mockResolvedValue(Buffer.from(''))
+        },
+        readFile: vi.fn().mockResolvedValue(Buffer.from(''))
+    };
+});
+
+import { createGame } from '@quake2ts/game';
+
+// Mock game creation
+vi.mock('@quake2ts/game', async () => {
+    const actual = await vi.importActual('@quake2ts/game');
+    return {
+        ...actual,
+        createGame: vi.fn(),
+        createPlayerInventory: vi.fn(),
+        createPlayerWeaponStates: vi.fn()
+    };
+});
+
+// Access private properties for testing
+function getPrivate(obj: any, key: string) {
+    return obj[key];
+}
+
+describe('DedicatedServer Timeout', () => {
+    let server: DedicatedServer;
+    let consoleLogSpy: any;
+    let consoleWarnSpy: any;
+    let transport: MockTransport;
+
+    beforeEach(async () => {
+        vi.useFakeTimers({
+            toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date']
+        });
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+        // Setup mock game return value here, where we can access createMockGameExports
+        (createGame as vi.Mock).mockReturnValue(createMockGameExports({
+            clientBegin: vi.fn().mockReturnValue({ index: 1, origin: {x:0,y:0,z:0} } as any),
+            clientConnect: vi.fn().mockReturnValue(true)
+        }));
+
+        transport = createMockTransport();
+        server = new DedicatedServer({ port: 27910, transport });
+        await server.startServer('maps/test.bsp');
+    });
+
+    afterEach(() => {
+        server.stopServer();
+        vi.clearAllMocks();
+        consoleLogSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        vi.useRealTimers();
+    });
+
+    it('should disconnect a client after timeout', () => {
+        // Access svs.clients to manually inject a client
+        const svs = getPrivate(server, 'svs');
+        const sv = getPrivate(server, 'sv');
+
+        // Mock a connected client
+        const mockDriver = createMockNetDriver();
+
+        const clientIndex = 0;
+        const client = createMockServerClient(clientIndex, {
+            net: mockDriver,
+            lastMessage: sv.frame, // Last message was NOW
+            lastConnect: Date.now(),
+            name: 'TestClient'
+        });
+
+        svs.clients[clientIndex] = client;
+
+        // Set up cleanup spy
+        const dropClientSpy = vi.spyOn(server as any, 'dropClient');
+
+        // Advance 29 seconds (290 frames)
+        for(let i=0; i<290; i++) {
+            vi.runOnlyPendingTimers();
+        }
+
+        // Verify still connected
+        expect(svs.clients[clientIndex]).not.toBeNull();
+        expect(dropClientSpy).not.toHaveBeenCalled();
+        expect(mockDriver.disconnect).not.toHaveBeenCalled();
+
+        // Advance another 20 frames (2 seconds) -> Total 31 seconds
+        for(let i=0; i<20; i++) {
+             vi.runOnlyPendingTimers();
+        }
+
+        // Now diff is 310 > 300. Should disconnect.
+        expect(dropClientSpy).toHaveBeenCalledWith(client);
+        expect(mockDriver.disconnect).toHaveBeenCalled();
+    });
+
+    it('should NOT disconnect a client if they send messages', () => {
+        const svs = getPrivate(server, 'svs');
+        const sv = getPrivate(server, 'sv');
+
+        const mockDriver = createMockNetDriver();
+
+        const clientIndex = 0;
+        const client = createMockServerClient(clientIndex, {
+            net: mockDriver,
+            lastMessage: sv.frame,
+            lastConnect: Date.now(),
+            name: 'TestClient'
+        });
+
+        svs.clients[clientIndex] = client;
+        const dropClientSpy = vi.spyOn(server as any, 'dropClient');
+
+        // Advance 15 seconds
+        for(let i=0; i<150; i++) {
+            vi.runOnlyPendingTimers();
+        }
+
+        // Simulate packet received -> updates lastMessage
+        client.lastMessage = sv.frame;
+
+        // Advance another 16 seconds
+        for(let i=0; i<160; i++) {
+            vi.runOnlyPendingTimers();
+        }
+
+        // Total time 31 seconds, but lastMessage was 16 seconds ago.
+        expect(dropClientSpy).not.toHaveBeenCalled();
+    });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "composite": true,
+    "rootDir": "src"
+  }
+}