@quake2ts/server 0.0.739 → 0.0.741

package/dist/dedicated.js

@@ -1,1104 +0,0 @@
-import { createGame, MulticastType, Solid } from '@quake2ts/game';
-import { createClient, ClientState } from './client.js';
-import { ClientMessageParser } from './protocol.js';
-import { BinaryWriter, ServerCommand, BinaryStream, traceBox, UPDATE_BACKUP, MAX_CONFIGSTRINGS, MAX_EDICTS, CollisionEntityIndex, inPVS, inPHS, crc8, ConfigStringIndex } from '@quake2ts/shared';
-import { parseBsp, PakArchive } from '@quake2ts/engine';
-import fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { createPlayerInventory, createPlayerWeaponStates } from '@quake2ts/game';
-import { ServerState } from './server.js';
-import { writeDeltaEntity, writeRemoveEntity } from '@quake2ts/shared';
-import { writePlayerState } from './protocol/player.js';
-import { writeServerCommand } from './protocol/write.js';
-import { lerpAngle } from '@quake2ts/shared';
-import { WebSocketTransport } from './transports/websocket.js';
-function lerp(a, b, t) {
-    return a + (b - a) * t;
-}
-const DEFAULT_MAX_CLIENTS = 16;
-const FRAME_RATE = 10; // 10Hz dedicated server loop (Q2 standard)
-const FRAME_TIME_MS = 1000 / FRAME_RATE;
-export class DedicatedServer {
-    constructor(optionsOrPort = {}) {
-        this.game = null;
-        this.frameTimeout = null;
-        this.entityIndex = null;
-        // History buffer: Map<EntityIndex, HistoryArray>
-        this.history = new Map();
-        this.backup = new Map();
-        const options = typeof optionsOrPort === 'number' ? { port: optionsOrPort } : optionsOrPort;
-        this.options = {
-            port: 27910,
-            maxPlayers: DEFAULT_MAX_CLIENTS,
-            deathmatch: true,
-            ...options
-        };
-        this.transport = this.options.transport || new WebSocketTransport();
-        this.svs = {
-            initialized: false,
-            realTime: 0,
-            mapCmd: '',
-            spawnCount: 0,
-            clients: new Array(this.options.maxPlayers).fill(null),
-            lastHeartbeat: 0,
-            challenges: []
-        };
-        this.sv = {
-            state: ServerState.Dead,
-            attractLoop: false,
-            loadGame: false,
-            startTime: 0, // Initialize startTime
-            time: 0,
-            frame: 0,
-            name: '',
-            collisionModel: null,
-            configStrings: new Array(MAX_CONFIGSTRINGS).fill(''),
-            baselines: new Array(MAX_EDICTS).fill(null),
-            multicastBuf: new Uint8Array(0)
-        };
-        this.entityIndex = new CollisionEntityIndex();
-    }
-    setTransport(transport) {
-        if (this.svs.initialized) {
-            throw new Error('Cannot set transport after server started');
-        }
-        this.transport = transport;
-    }
-    async startServer(mapName) {
-        const map = mapName || this.options.mapName;
-        if (!map) {
-            throw new Error('No map specified');
-        }
-        await this.start(map);
-    }
-    stopServer() {
-        this.stop();
-    }
-    kickPlayer(clientId) {
-        if (clientId < 0 || clientId >= this.svs.clients.length)
-            return;
-        const client = this.svs.clients[clientId];
-        if (client && client.state >= ClientState.Connected) {
-            console.log(`Kicking client ${clientId}`);
-            // Send disconnect message if possible
-            if (client.netchan) {
-                const writer = new BinaryWriter();
-                writer.writeByte(ServerCommand.print);
-                writer.writeByte(2);
-                writer.writeString('Kicked by server.\n');
-                try {
-                    const packet = client.netchan.transmit(writer.getData());
-                    client.net.send(packet);
-                }
-                catch (e) { }
-            }
-            this.dropClient(client);
-        }
-    }
-    async changeMap(mapName) {
-        console.log(`Changing map to ${mapName}`);
-        // Notify clients?
-        this.multicast({ x: 0, y: 0, z: 0 }, MulticastType.All, ServerCommand.print, 2, `Changing map to ${mapName}...\n`);
-        // Stop current game loop
-        if (this.frameTimeout)
-            clearTimeout(this.frameTimeout);
-        // Reset Server State
-        this.sv.state = ServerState.Loading;
-        this.sv.collisionModel = null;
-        this.sv.time = 0;
-        this.sv.frame = 0;
-        this.sv.configStrings.fill('');
-        this.sv.baselines.fill(null);
-        this.history.clear();
-        this.entityIndex = new CollisionEntityIndex();
-        // Load new Map
-        await this.loadMap(mapName);
-        // Re-init game
-        this.initGame();
-        // Send new serverdata to all connected clients and respawn them
-        for (const client of this.svs.clients) {
-            if (client && client.state >= ClientState.Connected) {
-                // Reset client game state
-                client.edict = null; // Will be respawned
-                client.state = ClientState.Connected; // Move back to connected state to trigger spawn
-                // Send new serverdata
-                this.sendServerData(client);
-                // Force them to reload/precache
-                client.netchan.writeReliableByte(ServerCommand.stufftext);
-                client.netchan.writeReliableString(`map ${mapName}\n`);
-                // Trigger spawn
-                this.handleBegin(client);
-            }
-        }
-        // Resume loop
-        this.runFrame();
-    }
-    getConnectedClients() {
-        const list = [];
-        for (const client of this.svs.clients) {
-            if (client && client.state >= ClientState.Connected) {
-                list.push({
-                    id: client.index,
-                    name: 'Player', // TODO: Parse userinfo for name
-                    ping: client.ping,
-                    address: 'unknown'
-                });
-            }
-        }
-        return list;
-    }
-    async start(mapName) {
-        console.log(`Starting Dedicated Server on port ${this.options.port}...`);
-        this.sv.name = mapName;
-        this.svs.initialized = true;
-        this.svs.spawnCount++;
-        // 1. Initialize Network
-        this.transport.onConnection((driver, info) => {
-            console.log('New connection', info ? `from ${info.socket?.remoteAddress}` : '');
-            this.handleConnection(driver, info);
-        });
-        this.transport.onError((err) => {
-            if (this.onServerError)
-                this.onServerError(err);
-        });
-        await this.transport.listen(this.options.port);
-        // 2. Load Map
-        await this.loadMap(mapName);
-        // 3. Initialize Game
-        this.initGame();
-        // 4. Start Loop
-        this.runFrame();
-        console.log('Server started.');
-    }
-    async loadMap(mapName) {
-        try {
-            console.log(`Loading map ${mapName}...`);
-            this.sv.state = ServerState.Loading;
-            this.sv.name = mapName;
-            let arrayBuffer;
-            // Check if map exists on disk
-            try {
-                await fs.access(mapName);
-                const mapData = await fs.readFile(mapName);
-                arrayBuffer = mapData.buffer.slice(mapData.byteOffset, mapData.byteOffset + mapData.byteLength);
-            }
-            catch (e) {
-                console.log(`Map file ${mapName} not found on disk, checking pak.pak...`);
-                // Check pak.pak
-                const possiblePakPaths = [
-                    path.resolve(process.cwd(), 'pak.pak'),
-                    path.resolve(process.cwd(), '../pak.pak'),
-                    path.resolve(process.cwd(), '../../pak.pak'),
-                    path.resolve('baseq2/pak.pak')
-                ];
-                let pakPath = null;
-                for (const p of possiblePakPaths) {
-                    try {
-                        await fs.access(p);
-                        pakPath = p;
-                        break;
-                    }
-                    catch { }
-                }
-                if (!pakPath) {
-                    throw new Error(`Map ${mapName} not found and pak.pak not found.`);
-                }
-                const pakBuffer = await fs.readFile(pakPath);
-                const pakArrayBuffer = pakBuffer.buffer.slice(pakBuffer.byteOffset, pakBuffer.byteOffset + pakBuffer.byteLength);
-                const pak = PakArchive.fromArrayBuffer('pak.pak', pakArrayBuffer);
-                const entry = pak.getEntry(mapName);
-                if (!entry) {
-                    throw new Error(`Map ${mapName} not found in pak.pak`);
-                }
-                const data = pak.readFile(mapName);
-                arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-            }
-            const bspMap = parseBsp(arrayBuffer);
-            // Convert BspMap to CollisionModel manually
-            const planes = bspMap.planes.map(p => {
-                const normal = { x: p.normal[0], y: p.normal[1], z: p.normal[2] };
-                let signbits = 0;
-                if (normal.x < 0)
-                    signbits |= 1;
-                if (normal.y < 0)
-                    signbits |= 2;
-                if (normal.z < 0)
-                    signbits |= 4;
-                return {
-                    normal,
-                    dist: p.dist,
-                    type: p.type,
-                    signbits
-                };
-            });
-            const nodes = bspMap.nodes.map(n => ({
-                plane: planes[n.planeIndex],
-                children: n.children
-            }));
-            const leafBrushes = [];
-            const leaves = bspMap.leafs.map((l, i) => {
-                const brushes = bspMap.leafLists.leafBrushes[i];
-                const firstLeafBrush = leafBrushes.length;
-                leafBrushes.push(...brushes);
-                return {
-                    contents: l.contents,
-                    cluster: l.cluster,
-                    area: l.area,
-                    firstLeafBrush,
-                    numLeafBrushes: brushes.length
-                };
-            });
-            const brushes = bspMap.brushes.map(b => {
-                const sides = [];
-                for (let i = 0; i < b.numSides; i++) {
-                    const sideIndex = b.firstSide + i;
-                    const bspSide = bspMap.brushSides[sideIndex];
-                    const plane = planes[bspSide.planeIndex];
-                    const texInfo = bspMap.texInfo[bspSide.texInfo];
-                    const surfaceFlags = texInfo ? texInfo.flags : 0;
-                    sides.push({
-                        plane,
-                        surfaceFlags
-                    });
-                }
-                return {
-                    contents: b.contents,
-                    sides,
-                    checkcount: 0
-                };
-            });
-            const bmodels = bspMap.models.map(m => ({
-                mins: { x: m.mins[0], y: m.mins[1], z: m.mins[2] },
-                maxs: { x: m.maxs[0], y: m.maxs[1], z: m.maxs[2] },
-                origin: { x: m.origin[0], y: m.origin[1], z: m.origin[2] },
-                headnode: m.headNode
-            }));
-            let visibility;
-            if (bspMap.visibility) {
-                visibility = {
-                    numClusters: bspMap.visibility.numClusters,
-                    clusters: bspMap.visibility.clusters
-                };
-            }
-            this.sv.collisionModel = {
-                planes,
-                nodes,
-                leaves,
-                brushes,
-                leafBrushes,
-                bmodels,
-                visibility
-            };
-            console.log(`Map loaded successfully.`);
-        }
-        catch (e) {
-            console.warn('Failed to load map:', e);
-            if (this.onServerError)
-                this.onServerError(e);
-        }
-    }
-    initGame() {
-        this.sv.startTime = Date.now();
-        const imports = {
-            trace: (start, mins, maxs, end, passent, contentmask) => {
-                if (this.entityIndex) {
-                    const result = this.entityIndex.trace({
-                        start,
-                        end,
-                        mins: mins || undefined,
-                        maxs: maxs || undefined,
-                        model: this.sv.collisionModel,
-                        passId: passent ? passent.index : undefined,
-                        contentMask: contentmask
-                    });
-                    let hitEntity = null;
-                    if (result.entityId !== null && result.entityId !== undefined && this.game) {
-                        hitEntity = this.game.entities.getByIndex(result.entityId) ?? null;
-                    }
-                    return {
-                        allsolid: result.allsolid,
-                        startsolid: result.startsolid,
-                        fraction: result.fraction,
-                        endpos: result.endpos,
-                        plane: result.plane || null,
-                        surfaceFlags: result.surfaceFlags || 0,
-                        contents: result.contents || 0,
-                        ent: hitEntity
-                    };
-                }
-                const worldResult = this.sv.collisionModel ? traceBox({
-                    start,
-                    end,
-                    mins: mins || undefined,
-                    maxs: maxs || undefined,
-                    model: this.sv.collisionModel,
-                    contentMask: contentmask
-                }) : {
-                    fraction: 1.0,
-                    endpos: { ...end },
-                    allsolid: false,
-                    startsolid: false,
-                    plane: null,
-                    surfaceFlags: 0,
-                    contents: 0
-                };
-                return {
-                    allsolid: worldResult.allsolid,
-                    startsolid: worldResult.startsolid,
-                    fraction: worldResult.fraction,
-                    endpos: worldResult.endpos,
-                    plane: worldResult.plane || null,
-                    surfaceFlags: worldResult.surfaceFlags || 0,
-                    contents: worldResult.contents || 0,
-                    ent: null
-                };
-            },
-            pointcontents: (p) => 0,
-            linkentity: (ent) => {
-                if (!this.entityIndex)
-                    return;
-                this.entityIndex.link({
-                    id: ent.index,
-                    origin: ent.origin,
-                    mins: ent.mins,
-                    maxs: ent.maxs,
-                    contents: ent.solid === 0 ? 0 : 1,
-                    surfaceFlags: 0
-                });
-            },
-            areaEdicts: (mins, maxs) => {
-                if (!this.entityIndex)
-                    return [];
-                return this.entityIndex.gatherTriggerTouches({ x: 0, y: 0, z: 0 }, mins, maxs, 0xFFFFFFFF);
-            },
-            multicast: (origin, type, event, ...args) => this.multicast(origin, type, event, ...args),
-            unicast: (ent, reliable, event, ...args) => this.unicast(ent, reliable, event, ...args),
-            configstring: (index, value) => this.SV_SetConfigString(index, value),
-            serverCommand: (cmd) => { console.log(`Server command: ${cmd}`); },
-            setLagCompensation: (active, client, lagMs) => this.setLagCompensation(active, client, lagMs)
-        };
-        this.game = createGame(imports, this, {
-            gravity: { x: 0, y: 0, z: -800 },
-            deathmatch: this.options.deathmatch !== false
-        });
-        this.game.init(0);
-        this.game.spawnWorld();
-        this.populateBaselines();
-        this.sv.state = ServerState.Game;
-    }
-    populateBaselines() {
-        if (!this.game)
-            return;
-        this.game.entities.forEachEntity((ent) => {
-            if (ent.index >= MAX_EDICTS)
-                return;
-            if (ent.modelindex > 0 || ent.solid !== Solid.Not) {
-                this.sv.baselines[ent.index] = this.entityToState(ent);
-            }
-        });
-    }
-    entityToState(ent) {
-        return {
-            number: ent.index,
-            origin: { ...ent.origin },
-            angles: { ...ent.angles },
-            modelIndex: ent.modelindex,
-            frame: ent.frame,
-            skinNum: ent.skin,
-            effects: ent.effects,
-            renderfx: ent.renderfx,
-            solid: ent.solid,
-            sound: ent.sounds,
-            event: 0
-        };
-    }
-    stop() {
-        if (this.frameTimeout)
-            clearTimeout(this.frameTimeout);
-        this.transport.close();
-        this.game?.shutdown();
-        this.sv.state = ServerState.Dead;
-    }
-    handleConnection(driver, info) {
-        let clientIndex = -1;
-        for (let i = 0; i < this.options.maxPlayers; i++) {
-            if (this.svs.clients[i] === null || this.svs.clients[i].state === ClientState.Free) {
-                clientIndex = i;
-                break;
-            }
-        }
-        if (clientIndex === -1) {
-            console.log('Server full, rejecting connection');
-            driver.disconnect();
-            return;
-        }
-        const client = createClient(clientIndex, driver);
-        client.lastMessage = this.sv.frame;
-        client.lastCommandTime = Date.now();
-        this.svs.clients[clientIndex] = client;
-        console.log(`Client ${clientIndex} attached to slot from ${info?.socket?.remoteAddress || 'unknown'}`);
-        driver.onMessage((data) => this.onClientMessage(client, data));
-        driver.onClose(() => this.onClientDisconnect(client));
-    }
-    onClientMessage(client, data) {
-        const buffer = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength
-            ? data.buffer
-            : data.slice().buffer;
-        if (buffer instanceof ArrayBuffer) {
-            client.messageQueue.push(new Uint8Array(buffer));
-        }
-        else {
-            // SharedArrayBuffer fallback or other weirdness
-            client.messageQueue.push(new Uint8Array(buffer));
-        }
-    }
-    onClientDisconnect(client) {
-        console.log(`Client ${client.index} disconnected`);
-        if (client.edict && this.game) {
-            this.game.clientDisconnect(client.edict);
-        }
-        if (this.onClientDisconnected) {
-            this.onClientDisconnected(client.index);
-        }
-        client.state = ClientState.Free;
-        this.svs.clients[client.index] = null;
-        if (this.entityIndex && client.edict) {
-            this.entityIndex.unlink(client.edict.index);
-        }
-    }
-    dropClient(client) {
-        if (client.net) {
-            client.net.disconnect();
-        }
-    }
-    handleMove(client, cmd, checksum, lastFrame) {
-        if (lastFrame > 0 && lastFrame <= client.lastFrame && lastFrame > client.lastFrame - UPDATE_BACKUP) {
-            const frameIdx = lastFrame % UPDATE_BACKUP;
-            const frame = client.frames[frameIdx];
-            if (frame.packetCRC !== checksum) {
-                console.warn(`Client ${client.index} checksum mismatch for frame ${lastFrame}: expected ${frame.packetCRC}, got ${checksum}`);
-            }
-        }
-        client.lastCmd = cmd;
-        client.lastMessage = this.sv.frame;
-        client.commandCount++;
-    }
-    handleUserInfo(client, info) {
-        client.userInfo = info;
-    }
-    handleStringCmd(client, cmd) {
-        console.log(`Client ${client.index} stringcmd: ${cmd}`);
-        if (cmd === 'getchallenge') {
-            this.handleGetChallenge(client);
-        }
-        else if (cmd.startsWith('connect ')) {
-            const userInfo = cmd.substring(8);
-            this.handleConnect(client, userInfo);
-        }
-        else if (cmd === 'begin') {
-            this.handleBegin(client);
-        }
-        else if (cmd === 'status') {
-            this.handleStatus(client);
-        }
-    }
-    handleStatus(client) {
-        let activeClients = 0;
-        for (const c of this.svs.clients) {
-            if (c && c.state >= ClientState.Connected) {
-                activeClients++;
-            }
-        }
-        let status = `map: ${this.sv.name}\n`;
-        status += `players: ${activeClients} active (${this.options.maxPlayers} max)\n\n`;
-        status += `num score ping name            lastmsg address               qport rate\n`;
-        status += `--- ----- ---- --------------- ------- --------------------- ----- -----\n`;
-        for (const c of this.svs.clients) {
-            if (c && c.state >= ClientState.Connected) {
-                const score = 0;
-                const ping = 0;
-                const lastMsg = this.sv.frame - c.lastMessage;
-                const address = 'unknown';
-                status += `${c.index.toString().padStart(3)} ${score.toString().padStart(5)} ${ping.toString().padStart(4)} ${c.userInfo.substring(0, 15).padEnd(15)} ${lastMsg.toString().padStart(7)} ${address.padEnd(21)} ${c.netchan.qport.toString().padStart(5)} 0\n`;
-            }
-        }
-        const writer = new BinaryWriter();
-        writer.writeByte(ServerCommand.print);
-        writer.writeByte(2);
-        writer.writeString(status);
-        const packet = client.netchan.transmit(writer.getData());
-        client.net.send(packet);
-    }
-    handleGetChallenge(client) {
-        const challenge = Math.floor(Math.random() * 1000000) + 1;
-        client.challenge = challenge;
-        const writer = new BinaryWriter();
-        writer.writeByte(ServerCommand.stufftext);
-        writer.writeString(`challenge ${challenge}\n`);
-        const packet = client.netchan.transmit(writer.getData());
-        client.net.send(packet);
-    }
-    handleConnect(client, userInfo) {
-        if (!this.game)
-            return;
-        const result = this.game.clientConnect(client.edict || null, userInfo);
-        if (result === true) {
-            client.state = ClientState.Connected;
-            client.userInfo = userInfo;
-            console.log(`Client ${client.index} connected: ${userInfo}`);
-            if (this.onClientConnected) {
-                // Extract name from userinfo if possible, default to Player
-                this.onClientConnected(client.index, 'Player');
-            }
-            try {
-                this.sendServerData(client);
-                client.netchan.writeReliableByte(ServerCommand.stufftext);
-                client.netchan.writeReliableString("precache\n");
-                const packet = client.netchan.transmit();
-                client.net.send(packet);
-            }
-            catch (e) {
-                console.warn(`Client ${client.index} reliable buffer overflow or connection error`);
-                this.dropClient(client);
-            }
-        }
-        else {
-            console.log(`Client ${client.index} rejected: ${result}`);
-            const writer = new BinaryWriter();
-            writer.writeByte(ServerCommand.print);
-            writer.writeByte(2);
-            writer.writeString(`Connection rejected: ${result}\n`);
-            const packet = client.netchan.transmit(writer.getData());
-            client.net.send(packet);
-        }
-    }
-    handleBegin(client) {
-        if (client.state === ClientState.Connected) {
-            this.spawnClient(client);
-        }
-    }
-    spawnClient(client) {
-        if (!this.game)
-            return;
-        const ent = this.game.clientBegin({
-            inventory: createPlayerInventory(),
-            weaponStates: createPlayerWeaponStates(),
-            buttons: 0,
-            pm_type: 0,
-            pm_time: 0,
-            pm_flags: 0,
-            gun_frame: 0,
-            rdflags: 0,
-            fov: 90,
-            pers: {
-                connected: true,
-                inventory: [],
-                health: 100,
-                max_health: 100,
-                savedFlags: 0,
-                selected_item: 0
-            }
-        });
-        client.edict = ent;
-        client.state = ClientState.Active;
-        console.log(`Client ${client.index} entered game`);
-    }
-    sendServerData(client) {
-        client.netchan.writeReliableByte(ServerCommand.serverdata);
-        client.netchan.writeReliableLong(34);
-        client.netchan.writeReliableLong(this.sv.frame);
-        client.netchan.writeReliableByte(0);
-        client.netchan.writeReliableString("baseq2");
-        client.netchan.writeReliableShort(client.index);
-        client.netchan.writeReliableString(this.sv.name || "maps/test.bsp");
-        for (let i = 0; i < MAX_CONFIGSTRINGS; i++) {
-            if (this.sv.configStrings[i]) {
-                client.netchan.writeReliableByte(ServerCommand.configstring);
-                client.netchan.writeReliableShort(i);
-                client.netchan.writeReliableString(this.sv.configStrings[i]);
-            }
-        }
-        const baselineWriter = new BinaryWriter();
-        for (let i = 0; i < MAX_EDICTS; i++) {
-            if (this.sv.baselines[i]) {
-                baselineWriter.reset();
-                baselineWriter.writeByte(ServerCommand.spawnbaseline);
-                writeDeltaEntity({}, this.sv.baselines[i], baselineWriter, true, true);
-                const data = baselineWriter.getData();
-                for (let j = 0; j < data.length; j++) {
-                    client.netchan.writeReliableByte(data[j]);
-                }
-            }
-        }
-    }
-    SV_SetConfigString(index, value) {
-        if (index < 0 || index >= MAX_CONFIGSTRINGS)
-            return;
-        this.sv.configStrings[index] = value;
-        for (const client of this.svs.clients) {
-            if (client && client.state >= ClientState.Connected) {
-                if (client.netchan) {
-                    try {
-                        client.netchan.writeReliableByte(ServerCommand.configstring);
-                        client.netchan.writeReliableShort(index);
-                        client.netchan.writeReliableString(value);
-                        const packet = client.netchan.transmit();
-                        client.net.send(packet);
-                    }
-                    catch (e) {
-                        console.warn(`Client ${client.index} reliable buffer overflow`);
-                        this.dropClient(client);
-                    }
-                }
-            }
-        }
-    }
-    SV_WriteConfigString(writer, index, value) {
-        writer.writeByte(ServerCommand.configstring);
-        writer.writeShort(index);
-        writer.writeString(value);
-    }
-    SV_ReadPackets() {
-        for (const client of this.svs.clients) {
-            if (!client || client.state === ClientState.Free)
-                continue;
-            while (client.messageQueue.length > 0) {
-                const rawData = client.messageQueue.shift();
-                if (!rawData)
-                    continue;
-                if (rawData.byteLength >= 10) {
-                    const view = new DataView(rawData.buffer, rawData.byteOffset, rawData.byteLength);
-                    const incomingQPort = view.getUint16(8, true);
-                    if (client.netchan.qport !== incomingQPort) {
-                        client.netchan.qport = incomingQPort;
-                    }
-                }
-                const data = client.netchan.process(rawData);
-                if (!data) {
-                    continue;
-                }
-                if (data.length === 0) {
-                    continue;
-                }
-                let buffer;
-                if (data.buffer instanceof ArrayBuffer) {
-                    buffer = data.buffer;
-                }
-                else {
-                    buffer = new Uint8Array(data).buffer;
-                }
-                const reader = new BinaryStream(buffer);
-                const parser = new ClientMessageParser(reader, {
-                    onMove: (checksum, lastFrame, cmd) => this.handleMove(client, cmd, checksum, lastFrame),
-                    onUserInfo: (info) => this.handleUserInfo(client, info),
-                    onStringCmd: (cmd) => this.handleStringCmd(client, cmd),
-                    onNop: () => { },
-                    onBad: () => {
-                        console.warn(`Bad command from client ${client.index}`);
-                    }
-                });
-                try {
-                    parser.parseMessage();
-                }
-                catch (e) {
-                    console.error(`Error parsing message from client ${client.index}:`, e);
-                }
-            }
-        }
-    }
-    runFrame() {
-        if (!this.game)
-            return;
-        const startTime = Date.now();
-        this.sv.frame++;
-        this.sv.time += 100; // 100ms per frame
-        // 1. Read network packets
-        this.SV_ReadPackets();
-        // 2. Run client commands
-        for (const client of this.svs.clients) {
-            if (!client || client.state === ClientState.Free)
-                continue;
-            if (client.edict && client.edict.client) {
-                client.edict.client.ping = client.ping;
-            }
-            if (client.state >= ClientState.Connected) {
-                const timeoutFrames = 300;
-                if (this.sv.frame - client.lastMessage > timeoutFrames) {
-                    console.log(`Client ${client.index} timed out`);
-                    this.dropClient(client);
-                    continue;
-                }
-            }
-            if (client && client.state === ClientState.Active && client.edict) {
-                const now = Date.now();
-                if (now - client.lastCommandTime >= 1000) {
-                    client.lastCommandTime = now;
-                    client.commandCount = 0;
-                }
-                if (client.commandCount > 200) {
-                    console.warn(`Client ${client.index} kicked for command flooding (count: ${client.commandCount})`);
-                    this.dropClient(client);
-                    continue;
-                }
-                this.game.clientThink(client.edict, client.lastCmd);
-            }
-        }
-        // 3. Run simulation
-        const snapshot = this.game.frame({
-            frame: this.sv.frame,
-            deltaMs: FRAME_TIME_MS,
-            nowMs: Date.now()
-        });
-        // 3.1 Record History for Lag Compensation
-        this.recordHistory();
-        // 4. Send Updates
-        if (snapshot && snapshot.state) {
-            this.SV_SendClientMessages(snapshot.state);
-        }
-        const endTime = Date.now();
-        const elapsed = endTime - startTime;
-        const sleepTime = Math.max(0, FRAME_TIME_MS - elapsed);
-        if (this.sv.state === ServerState.Game) {
-            this.frameTimeout = setTimeout(() => this.runFrame(), sleepTime);
-        }
-    }
-    SV_SendClientMessages(snapshot) {
-        for (const client of this.svs.clients) {
-            if (client && client.state === ClientState.Active) {
-                this.SV_SendClientFrame(client, snapshot);
-            }
-        }
-    }
-    SV_SendClientFrame(client, snapshot) {
-        const MTU = 1400;
-        const writer = new BinaryWriter(MTU);
-        writer.writeByte(ServerCommand.frame);
-        writer.writeLong(this.sv.frame);
-        let deltaFrame = 0;
-        if (client.lastFrame && client.lastFrame < this.sv.frame && client.lastFrame >= this.sv.frame - UPDATE_BACKUP) {
-            deltaFrame = client.lastFrame;
-        }
-        writer.writeLong(deltaFrame);
-        writer.writeByte(0);
-        writer.writeByte(0);
-        writer.writeByte(ServerCommand.playerinfo);
-        const ps = {
-            pm_type: snapshot.pmType,
-            origin: snapshot.origin,
-            velocity: snapshot.velocity,
-            pm_time: snapshot.pm_time,
-            pm_flags: snapshot.pmFlags,
-            gravity: Math.abs(snapshot.gravity.z),
-            delta_angles: snapshot.deltaAngles,
-            viewoffset: { x: 0, y: 0, z: 22 },
-            viewangles: snapshot.viewangles,
-            kick_angles: snapshot.kick_angles,
-            gun_index: snapshot.gunindex,
-            gun_frame: snapshot.gun_frame,
-            gun_offset: snapshot.gunoffset,
-            gun_angles: snapshot.gunangles,
-            blend: snapshot.blend,
-            fov: snapshot.fov,
-            rdflags: snapshot.rdflags,
-            stats: snapshot.stats,
-            watertype: snapshot.watertype // Populate watertype
-        };
-        writePlayerState(writer, ps);
-        writer.writeByte(ServerCommand.packetentities);
-        const entities = snapshot.packetEntities || [];
-        const currentEntityIds = [];
-        const frameIdx = this.sv.frame % UPDATE_BACKUP;
-        const currentFrame = client.frames[frameIdx];
-        currentFrame.entities = entities;
-        let oldEntities = [];
-        if (deltaFrame > 0) {
-            const oldFrameIdx = deltaFrame % UPDATE_BACKUP;
-            oldEntities = client.frames[oldFrameIdx].entities;
-        }
-        for (const entityState of currentFrame.entities) {
-            if (writer.getOffset() > MTU - 200) {
-                console.warn('Packet MTU limit reached, dropping remaining entities');
-                break;
-            }
-            currentEntityIds.push(entityState.number);
-            const oldState = oldEntities.find(e => e.number === entityState.number);
-            if (oldState) {
-                writeDeltaEntity(oldState, entityState, writer, false, false);
-            }
-            else {
-                writeDeltaEntity({}, entityState, writer, false, true);
-            }
-        }
-        for (const oldId of client.lastPacketEntities) {
-            if (writer.getOffset() > MTU - 10) {
-                console.warn('Packet MTU limit reached, dropping remaining removals');
-                break;
-            }
-            if (!currentEntityIds.includes(oldId)) {
-                writeRemoveEntity(oldId, writer);
-            }
-        }
-        writer.writeShort(0);
-        const frameData = writer.getData();
-        currentFrame.packetCRC = crc8(frameData);
-        const packet = client.netchan.transmit(frameData);
-        client.net.send(packet);
-        client.lastFrame = this.sv.frame;
-        client.lastPacketEntities = currentEntityIds;
-    }
-    // GameEngine Implementation
-    trace(start, end) {
-        return { fraction: 1.0 };
-    }
-    modelIndex(name) {
-        console.log(`modelIndex(${name}) called`);
-        // Find existing
-        const start = ConfigStringIndex.Models;
-        const end = ConfigStringIndex.Sounds;
-        for (let i = start + 1; i < end; i++) {
-            if (this.sv.configStrings[i] === name) {
-                return i - start;
-            }
-        }
-        // Find empty slot
-        for (let i = start + 1; i < end; i++) {
-            if (!this.sv.configStrings[i]) {
-                this.SV_SetConfigString(i, name);
-                return i - start;
-            }
-        }
-        console.warn(`MAX_MODELS overflow for ${name}`);
-        return 0;
-    }
-    soundIndex(name) {
-        const start = ConfigStringIndex.Sounds;
-        const end = ConfigStringIndex.Images;
-        for (let i = start + 1; i < end; i++) {
-            if (this.sv.configStrings[i] === name) {
-                return i - start;
-            }
-        }
-        for (let i = start + 1; i < end; i++) {
-            if (!this.sv.configStrings[i]) {
-                this.SV_SetConfigString(i, name);
-                return i - start;
-            }
-        }
-        console.warn(`MAX_SOUNDS overflow for ${name}`);
-        return 0;
-    }
-    imageIndex(name) {
-        const start = ConfigStringIndex.Images;
-        const end = ConfigStringIndex.Lights;
-        for (let i = start + 1; i < end; i++) {
-            if (this.sv.configStrings[i] === name) {
-                return i - start;
-            }
-        }
-        for (let i = start + 1; i < end; i++) {
-            if (!this.sv.configStrings[i]) {
-                this.SV_SetConfigString(i, name);
-                return i - start;
-            }
-        }
-        console.warn(`MAX_IMAGES overflow for ${name}`);
-        return 0;
-    }
-    multicast(origin, type, event, ...args) {
-        const writer = new BinaryWriter();
-        writeServerCommand(writer, event, ...args);
-        const data = writer.getData();
-        const reliable = false;
-        for (const client of this.svs.clients) {
-            if (!client || client.state < ClientState.Active || !client.edict) {
-                continue;
-            }
-            let send = false;
-            switch (type) {
-                case MulticastType.All:
-                    send = true;
-                    break;
-                case MulticastType.Pvs:
-                    if (this.sv.collisionModel) {
-                        send = inPVS(origin, client.edict.origin, this.sv.collisionModel);
-                    }
-                    else {
-                        send = true;
-                    }
-                    break;
-                case MulticastType.Phs:
-                    if (this.sv.collisionModel) {
-                        send = inPHS(origin, client.edict.origin, this.sv.collisionModel);
-                    }
-                    else {
-                        send = true;
-                    }
-                    break;
-            }
-            if (send) {
-                if (reliable) {
-                    try {
-                        for (let i = 0; i < data.length; i++) {
-                            client.netchan.writeReliableByte(data[i]);
-                        }
-                    }
-                    catch (e) {
-                    }
-                }
-                else {
-                    const packet = client.netchan.transmit(data);
-                    client.net.send(packet);
-                }
-            }
-        }
-    }
-    unicast(ent, reliable, event, ...args) {
-        const client = this.svs.clients.find(c => c?.edict === ent);
-        if (client && client.state >= ClientState.Connected) {
-            const writer = new BinaryWriter();
-            writeServerCommand(writer, event, ...args);
-            const data = writer.getData();
-            if (reliable) {
-                try {
-                    for (let i = 0; i < data.length; i++) {
-                        client.netchan.writeReliableByte(data[i]);
-                    }
-                    const packet = client.netchan.transmit();
-                    client.net.send(packet);
-                }
-                catch (e) {
-                    console.warn(`Client ${client.index} reliable buffer overflow in unicast`);
-                    this.dropClient(client);
-                }
-            }
-            else {
-                const packet = client.netchan.transmit(data);
-                client.net.send(packet);
-            }
-        }
-    }
-    configstring(index, value) {
-        this.SV_SetConfigString(index, value);
-    }
-    recordHistory() {
-        if (!this.game)
-            return;
-        const now = Date.now();
-        const HISTORY_MAX_MS = 1000;
-        this.game.entities.forEachEntity((ent) => {
-            if (ent.solid !== Solid.Not || ent.takedamage) {
-                let hist = this.history.get(ent.index);
-                if (!hist) {
-                    hist = [];
-                    this.history.set(ent.index, hist);
-                }
-                hist.push({
-                    time: now,
-                    origin: { ...ent.origin },
-                    mins: { ...ent.mins },
-                    maxs: { ...ent.maxs },
-                    angles: { ...ent.angles }
-                });
-                while (hist.length > 0 && hist[0].time < now - HISTORY_MAX_MS) {
-                    hist.shift();
-                }
-            }
-        });
-    }
-    setLagCompensation(active, client, lagMs) {
-        if (!this.game || !this.entityIndex)
-            return;
-        if (active) {
-            if (!client || lagMs === undefined)
-                return;
-            const now = Date.now();
-            const targetTime = now - lagMs;
-            this.game.entities.forEachEntity((ent) => {
-                if (ent === client)
-                    return;
-                if (ent.solid === Solid.Not && !ent.takedamage)
-                    return;
-                const hist = this.history.get(ent.index);
-                if (!hist || hist.length === 0)
-                    return;
-                let i = hist.length - 1;
-                while (i >= 0 && hist[i].time > targetTime) {
-                    i--;
-                }
-                if (i < 0) {
-                    i = 0;
-                }
-                const s1 = hist[i];
-                const s2 = (i + 1 < hist.length) ? hist[i + 1] : s1;
-                let frac = 0;
-                if (s1.time !== s2.time) {
-                    frac = (targetTime - s1.time) / (s2.time - s1.time);
-                }
-                if (frac < 0)
-                    frac = 0;
-                if (frac > 1)
-                    frac = 1;
-                const origin = {
-                    x: s1.origin.x + (s2.origin.x - s1.origin.x) * frac,
-                    y: s1.origin.y + (s2.origin.y - s1.origin.y) * frac,
-                    z: s1.origin.z + (s2.origin.z - s1.origin.z) * frac
-                };
-                const angles = {
-                    x: lerpAngle(s1.angles.x, s2.angles.x, frac),
-                    y: lerpAngle(s1.angles.y, s2.angles.y, frac),
-                    z: lerpAngle(s1.angles.z, s2.angles.z, frac)
-                };
-                this.backup.set(ent.index, {
-                    origin: { ...ent.origin },
-                    mins: { ...ent.mins },
-                    maxs: { ...ent.maxs },
-                    angles: { ...ent.angles },
-                    link: true
-                });
-                ent.origin = origin;
-                ent.angles = angles;
-                ent.mins = {
-                    x: s1.mins.x + (s2.mins.x - s1.mins.x) * frac,
-                    y: s1.mins.y + (s2.mins.y - s1.mins.y) * frac,
-                    z: s1.mins.z + (s2.mins.z - s1.mins.z) * frac
-                };
-                ent.maxs = {
-                    x: s1.maxs.x + (s2.maxs.x - s1.maxs.x) * frac,
-                    y: s1.maxs.y + (s2.maxs.y - s1.maxs.y) * frac,
-                    z: s1.maxs.z + (s2.maxs.z - s1.maxs.z) * frac
-                };
-                this.entityIndex.link({
-                    id: ent.index,
-                    origin: ent.origin,
-                    mins: ent.mins,
-                    maxs: ent.maxs,
-                    contents: ent.solid === 0 ? 0 : 1,
-                    surfaceFlags: 0
-                });
-            });
-        }
-        else {
-            this.backup.forEach((state, id) => {
-                const ent = this.game?.entities.getByIndex(id);
-                if (ent) {
-                    ent.origin = state.origin;
-                    ent.mins = state.mins;
-                    ent.maxs = state.maxs;
-                    ent.angles = state.angles;
-                    this.entityIndex.link({
-                        id: ent.index,
-                        origin: ent.origin,
-                        mins: ent.mins,
-                        maxs: ent.maxs,
-                        contents: ent.solid === 0 ? 0 : 1,
-                        surfaceFlags: 0
-                    });
-                }
-            });
-            this.backup.clear();
-        }
-    }
-}
-export function createServer(options = {}) {
-    return new DedicatedServer(options);
-}