@quake2ts/server 0.0.1 → 0.0.739

package/dist/cjs/index.cjs

@@ -0,0 +1,1537 @@
+'use strict';
+
+var WebSocket = require('ws');
+var game = require('@quake2ts/game');
+var shared = require('@quake2ts/shared');
+var engine = require('@quake2ts/engine');
+var fs = require('fs/promises');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/net/nodeWsDriver.ts
+var WebSocketNetDriver = class {
+  constructor() {
+    this.socket = null;
+    this.messageCallback = null;
+    this.closeCallback = null;
+    this.errorCallback = null;
+  }
+  async connect(url) {
+    return new Promise((resolve2, reject) => {
+      try {
+        this.socket = new WebSocket__default.default(url);
+        this.socket.binaryType = "arraybuffer";
+        this.socket.onopen = () => {
+          resolve2();
+        };
+        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)) {
+              this.messageCallback(new Uint8Array(event.data));
+            } else if (Array.isArray(event.data)) {
+              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)) {
+          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__default.default.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__default.default.OPEN;
+  }
+};
+var ClientState = /* @__PURE__ */ ((ClientState2) => {
+  ClientState2[ClientState2["Free"] = 0] = "Free";
+  ClientState2[ClientState2["Zombie"] = 1] = "Zombie";
+  ClientState2[ClientState2["Connected"] = 2] = "Connected";
+  ClientState2[ClientState2["Spawned"] = 3] = "Spawned";
+  ClientState2[ClientState2["Active"] = 4] = "Active";
+  return ClientState2;
+})(ClientState || {});
+function createClient(index, net) {
+  const frames = [];
+  for (let i = 0; i < shared.UPDATE_BACKUP; i++) {
+    frames.push({
+      areaBytes: 0,
+      areaBits: new Uint8Array(0),
+      // Size depends on map areas
+      playerState: createEmptyPlayerState(),
+      numEntities: 0,
+      firstEntity: 0,
+      sentTime: 0,
+      entities: [],
+      packetCRC: 0
+    });
+  }
+  const netchan = new shared.NetChan();
+  netchan.setup(Math.floor(Math.random() * 65536));
+  return {
+    index,
+    state: 2 /* Connected */,
+    net,
+    netchan,
+    userInfo: "",
+    lastFrame: 0,
+    lastCmd: createEmptyUserCommand(),
+    commandMsec: 0,
+    frameLatency: [],
+    ping: 0,
+    messageSize: [],
+    rate: 25e3,
+    // Default rate
+    suppressCount: 0,
+    edict: null,
+    name: `Player ${index}`,
+    messageLevel: 0,
+    datagram: new Uint8Array(0),
+    frames,
+    downloadSize: 0,
+    downloadCount: 0,
+    lastMessage: 0,
+    lastConnect: Date.now(),
+    challenge: 0,
+    messageQueue: [],
+    lastPacketEntities: [],
+    commandQueue: [],
+    lastCommandTime: 0,
+    commandCount: 0
+  };
+}
+function createEmptyUserCommand() {
+  return {
+    msec: 0,
+    buttons: 0,
+    angles: { x: 0, y: 0, z: 0 },
+    forwardmove: 0,
+    sidemove: 0,
+    upmove: 0,
+    sequence: 0,
+    lightlevel: 0,
+    impulse: 0
+  };
+}
+function createEmptyPlayerState() {
+  return {
+    origin: { x: 0, y: 0, z: 0 },
+    velocity: { x: 0, y: 0, z: 0 },
+    viewAngles: { x: 0, y: 0, z: 0 },
+    onGround: false,
+    waterLevel: 0,
+    watertype: 0,
+    mins: { x: -16, y: -16, z: -24 },
+    maxs: { x: 16, y: 16, z: 32 },
+    damageAlpha: 0,
+    damageIndicators: [],
+    blend: [0, 0, 0, 0],
+    // Stubs for new fields
+    stats: [],
+    kick_angles: { x: 0, y: 0, z: 0 },
+    kick_origin: { x: 0, y: 0, z: 0 },
+    gunoffset: { x: 0, y: 0, z: 0 },
+    gunangles: { x: 0, y: 0, z: 0 },
+    gunindex: 0,
+    pm_type: 0,
+    pm_time: 0,
+    pm_flags: 0,
+    gun_frame: 0,
+    rdflags: 0,
+    fov: 90,
+    renderfx: 0
+  };
+}
+var ClientMessageParser = class {
+  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 shared.ClientCommand.move:
+          this.parseMove();
+          break;
+        case shared.ClientCommand.userinfo:
+          this.parseUserInfo();
+          break;
+        case shared.ClientCommand.stringcmd:
+          this.parseStringCmd();
+          break;
+        case shared.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();
+    const msec = this.stream.readByte();
+    const buttons = this.stream.readByte();
+    const angles = {
+      x: this.stream.readShort() * (360 / 65536),
+      y: this.stream.readShort() * (360 / 65536),
+      z: this.stream.readShort() * (360 / 65536)
+    };
+    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();
+    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);
+  }
+};
+
+// 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 || {});
+function writeServerCommand(writer, event, ...args) {
+  writer.writeByte(event);
+  switch (event) {
+    case shared.ServerCommand.print: {
+      const level = args[0];
+      const text = args[1];
+      writer.writeByte(level);
+      writer.writeString(text);
+      break;
+    }
+    case shared.ServerCommand.centerprint: {
+      const text = args[0];
+      writer.writeString(text);
+      break;
+    }
+    case shared.ServerCommand.stufftext: {
+      const text = args[0];
+      writer.writeString(text);
+      break;
+    }
+    case shared.ServerCommand.sound: {
+      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) {
+        writer.writeByte(volume || 0);
+      }
+      if (flags & 2) {
+        writer.writeByte(attenuation || 0);
+      }
+      if (flags & 16) {
+        writer.writeByte(offset || 0);
+      }
+      if (flags & 8) {
+        writer.writeShort(ent || 0);
+      }
+      if (flags & 4) {
+        if (pos) {
+          writer.writePos(pos);
+        } else {
+          writer.writePos({ x: 0, y: 0, z: 0 });
+        }
+      }
+      break;
+    }
+    case shared.ServerCommand.muzzleflash: {
+      const entIndex = args[0];
+      const flashType = args[1];
+      writer.writeShort(entIndex);
+      writer.writeByte(flashType);
+      break;
+    }
+    case shared.ServerCommand.temp_entity: {
+      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 shared.TempEntity.ROCKET_EXPLOSION:
+    case shared.TempEntity.GRENADE_EXPLOSION:
+    case shared.TempEntity.EXPLOSION1:
+    case shared.TempEntity.EXPLOSION2:
+    case shared.TempEntity.ROCKET_EXPLOSION_WATER:
+    case shared.TempEntity.GRENADE_EXPLOSION_WATER:
+    case shared.TempEntity.BFG_EXPLOSION:
+    case shared.TempEntity.BFG_BIGEXPLOSION:
+    case shared.TempEntity.PLASMA_EXPLOSION:
+    case shared.TempEntity.PLAIN_EXPLOSION:
+    case shared.TempEntity.TRACKER_EXPLOSION:
+    case shared.TempEntity.EXPLOSION1_BIG:
+    case shared.TempEntity.EXPLOSION1_NP:
+    case shared.TempEntity.EXPLOSION1_NL:
+    case shared.TempEntity.EXPLOSION2_NL:
+    case shared.TempEntity.BERSERK_SLAM:
+      writer.writePos(args[0]);
+      break;
+    case shared.TempEntity.BLASTER:
+    case shared.TempEntity.FLECHETTE:
+      writer.writePos(args[0]);
+      writer.writeDir(args[1]);
+      break;
+    case shared.TempEntity.RAILTRAIL:
+    case shared.TempEntity.DEBUGTRAIL:
+    case shared.TempEntity.BUBBLETRAIL:
+    case shared.TempEntity.BUBBLETRAIL2:
+    case shared.TempEntity.BFG_LASER:
+    case shared.TempEntity.LIGHTNING_BEAM:
+    case shared.TempEntity.LIGHTNING:
+      writer.writePos(args[0]);
+      writer.writePos(args[1]);
+      break;
+    case shared.TempEntity.LASER_SPARKS:
+    case shared.TempEntity.WELDING_SPARKS:
+    case shared.TempEntity.TUNNEL_SPARKS:
+    case shared.TempEntity.ELECTRIC_SPARKS:
+    case shared.TempEntity.HEATBEAM_SPARKS:
+    case shared.TempEntity.HEATBEAM_STEAM:
+    case shared.TempEntity.STEAM:
+      writer.writeByte(args[0]);
+      writer.writePos(args[1]);
+      writer.writeDir(args[2]);
+      writer.writeByte(args[3] || 0);
+      break;
+    case shared.TempEntity.PARASITE_ATTACK:
+    case shared.TempEntity.MEDIC_CABLE_ATTACK:
+      const ent = args[0];
+      writer.writeShort(ent ? ent.index : 0);
+      writer.writePos(args[1]);
+      writer.writePos(args[2]);
+      break;
+    case shared.TempEntity.GUNSHOT:
+    case shared.TempEntity.BLOOD:
+    case shared.TempEntity.SPARKS:
+    case shared.TempEntity.BULLET_SPARKS:
+    case shared.TempEntity.SCREEN_SPARKS:
+    case shared.TempEntity.SHIELD_SPARKS:
+      writer.writePos(args[0]);
+      writer.writeDir(args[1]);
+      break;
+    case shared.TempEntity.SPLASH:
+    case shared.TempEntity.POWER_SPLASH:
+    case shared.TempEntity.WIDOWSPLASH:
+      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;
+  }
+}
+var WebSocketTransport = class {
+  constructor() {
+    this.wss = null;
+    this.connectionCallback = null;
+    this.errorCallback = null;
+  }
+  async listen(port) {
+    return new Promise((resolve2) => {
+      this.wss = new WebSocket.WebSocketServer({ port });
+      this.wss.on("listening", () => resolve2());
+      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;
+  }
+};
+
+// src/dedicated.ts
+var DEFAULT_MAX_CLIENTS = 16;
+var FRAME_RATE = 10;
+var FRAME_TIME_MS = 1e3 / FRAME_RATE;
+var DedicatedServer = class {
+  constructor(optionsOrPort = {}) {
+    this.game = null;
+    this.frameTimeout = null;
+    this.entityIndex = null;
+    // History buffer: Map<EntityIndex, HistoryArray>
+    this.history = /* @__PURE__ */ new Map();
+    this.backup = /* @__PURE__ */ 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: 0 /* Dead */,
+      attractLoop: false,
+      loadGame: false,
+      startTime: 0,
+      // Initialize startTime
+      time: 0,
+      frame: 0,
+      name: "",
+      collisionModel: null,
+      configStrings: new Array(shared.MAX_CONFIGSTRINGS).fill(""),
+      baselines: new Array(shared.MAX_EDICTS).fill(null),
+      multicastBuf: new Uint8Array(0)
+    };
+    this.entityIndex = new shared.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 >= 2 /* Connected */) {
+      console.log(`Kicking client ${clientId}`);
+      if (client.netchan) {
+        const writer = new shared.BinaryWriter();
+        writer.writeByte(shared.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}`);
+    this.multicast(
+      { x: 0, y: 0, z: 0 },
+      game.MulticastType.All,
+      shared.ServerCommand.print,
+      2,
+      `Changing map to ${mapName}...
+`
+    );
+    if (this.frameTimeout) clearTimeout(this.frameTimeout);
+    this.sv.state = 1 /* 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 shared.CollisionEntityIndex();
+    await this.loadMap(mapName);
+    this.initGame();
+    for (const client of this.svs.clients) {
+      if (client && client.state >= 2 /* Connected */) {
+        client.edict = null;
+        client.state = 2 /* Connected */;
+        this.sendServerData(client);
+        client.netchan.writeReliableByte(shared.ServerCommand.stufftext);
+        client.netchan.writeReliableString(`map ${mapName}
+`);
+        this.handleBegin(client);
+      }
+    }
+    this.runFrame();
+  }
+  getConnectedClients() {
+    const list = [];
+    for (const client of this.svs.clients) {
+      if (client && client.state >= 2 /* 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++;
+    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);
+    await this.loadMap(mapName);
+    this.initGame();
+    this.runFrame();
+    console.log("Server started.");
+  }
+  async loadMap(mapName) {
+    try {
+      console.log(`Loading map ${mapName}...`);
+      this.sv.state = 1 /* Loading */;
+      this.sv.name = mapName;
+      let arrayBuffer;
+      try {
+        await fs__default.default.access(mapName);
+        const mapData = await fs__default.default.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...`);
+        const possiblePakPaths = [
+          path__namespace.resolve(process.cwd(), "pak.pak"),
+          path__namespace.resolve(process.cwd(), "../pak.pak"),
+          path__namespace.resolve(process.cwd(), "../../pak.pak"),
+          path__namespace.resolve("baseq2/pak.pak")
+        ];
+        let pakPath = null;
+        for (const p of possiblePakPaths) {
+          try {
+            await fs__default.default.access(p);
+            pakPath = p;
+            break;
+          } catch {
+          }
+        }
+        if (!pakPath) {
+          throw new Error(`Map ${mapName} not found and pak.pak not found.`);
+        }
+        const pakBuffer = await fs__default.default.readFile(pakPath);
+        const pakArrayBuffer = pakBuffer.buffer.slice(pakBuffer.byteOffset, pakBuffer.byteOffset + pakBuffer.byteLength);
+        const pak = engine.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 = engine.parseBsp(arrayBuffer);
+      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 brushes2 = bspMap.leafLists.leafBrushes[i];
+        const firstLeafBrush = leafBrushes.length;
+        leafBrushes.push(...brushes2);
+        return {
+          contents: l.contents,
+          cluster: l.cluster,
+          area: l.area,
+          firstLeafBrush,
+          numLeafBrushes: brushes2.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 || void 0,
+            maxs: maxs || void 0,
+            model: this.sv.collisionModel,
+            passId: passent ? passent.index : void 0,
+            contentMask: contentmask
+          });
+          let hitEntity = null;
+          if (result.entityId !== null && result.entityId !== void 0 && 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 ? shared.traceBox({
+          start,
+          end,
+          mins: mins || void 0,
+          maxs: maxs || void 0,
+          model: this.sv.collisionModel,
+          contentMask: contentmask
+        }) : {
+          fraction: 1,
+          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, 4294967295);
+      },
+      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 = 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 = 2 /* Game */;
+  }
+  populateBaselines() {
+    if (!this.game) return;
+    this.game.entities.forEachEntity((ent) => {
+      if (ent.index >= shared.MAX_EDICTS) return;
+      if (ent.modelindex > 0 || ent.solid !== game.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 = 0 /* 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 === 0 /* 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 {
+      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 = 0 /* 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 - shared.UPDATE_BACKUP) {
+      const frameIdx = lastFrame % shared.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 >= 2 /* Connected */) {
+        activeClients++;
+      }
+    }
+    let status = `map: ${this.sv.name}
+`;
+    status += `players: ${activeClients} active (${this.options.maxPlayers} max)
+
+`;
+    status += `num score ping name            lastmsg address               qport rate
+`;
+    status += `--- ----- ---- --------------- ------- --------------------- ----- -----
+`;
+    for (const c of this.svs.clients) {
+      if (c && c.state >= 2 /* 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
+`;
+      }
+    }
+    const writer = new shared.BinaryWriter();
+    writer.writeByte(shared.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() * 1e6) + 1;
+    client.challenge = challenge;
+    const writer = new shared.BinaryWriter();
+    writer.writeByte(shared.ServerCommand.stufftext);
+    writer.writeString(`challenge ${challenge}
+`);
+    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 = 2 /* Connected */;
+      client.userInfo = userInfo;
+      console.log(`Client ${client.index} connected: ${userInfo}`);
+      if (this.onClientConnected) {
+        this.onClientConnected(client.index, "Player");
+      }
+      try {
+        this.sendServerData(client);
+        client.netchan.writeReliableByte(shared.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 shared.BinaryWriter();
+      writer.writeByte(shared.ServerCommand.print);
+      writer.writeByte(2);
+      writer.writeString(`Connection rejected: ${result}
+`);
+      const packet = client.netchan.transmit(writer.getData());
+      client.net.send(packet);
+    }
+  }
+  handleBegin(client) {
+    if (client.state === 2 /* Connected */) {
+      this.spawnClient(client);
+    }
+  }
+  spawnClient(client) {
+    if (!this.game) return;
+    const ent = this.game.clientBegin({
+      inventory: game.createPlayerInventory(),
+      weaponStates: game.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 = 4 /* Active */;
+    console.log(`Client ${client.index} entered game`);
+  }
+  sendServerData(client) {
+    client.netchan.writeReliableByte(shared.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 < shared.MAX_CONFIGSTRINGS; i++) {
+      if (this.sv.configStrings[i]) {
+        client.netchan.writeReliableByte(shared.ServerCommand.configstring);
+        client.netchan.writeReliableShort(i);
+        client.netchan.writeReliableString(this.sv.configStrings[i]);
+      }
+    }
+    const baselineWriter = new shared.BinaryWriter();
+    for (let i = 0; i < shared.MAX_EDICTS; i++) {
+      if (this.sv.baselines[i]) {
+        baselineWriter.reset();
+        baselineWriter.writeByte(shared.ServerCommand.spawnbaseline);
+        shared.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 >= shared.MAX_CONFIGSTRINGS) return;
+    this.sv.configStrings[index] = value;
+    for (const client of this.svs.clients) {
+      if (client && client.state >= 2 /* Connected */) {
+        if (client.netchan) {
+          try {
+            client.netchan.writeReliableByte(shared.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(shared.ServerCommand.configstring);
+    writer.writeShort(index);
+    writer.writeString(value);
+  }
+  SV_ReadPackets() {
+    for (const client of this.svs.clients) {
+      if (!client || client.state === 0 /* 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 shared.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;
+    this.SV_ReadPackets();
+    for (const client of this.svs.clients) {
+      if (!client || client.state === 0 /* Free */) continue;
+      if (client.edict && client.edict.client) {
+        client.edict.client.ping = client.ping;
+      }
+      if (client.state >= 2 /* 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 === 4 /* Active */ && client.edict) {
+        const now = Date.now();
+        if (now - client.lastCommandTime >= 1e3) {
+          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);
+      }
+    }
+    const snapshot = this.game.frame({
+      frame: this.sv.frame,
+      deltaMs: FRAME_TIME_MS,
+      nowMs: Date.now()
+    });
+    this.recordHistory();
+    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 === 2 /* Game */) {
+      this.frameTimeout = setTimeout(() => this.runFrame(), sleepTime);
+    }
+  }
+  SV_SendClientMessages(snapshot) {
+    for (const client of this.svs.clients) {
+      if (client && client.state === 4 /* Active */) {
+        this.SV_SendClientFrame(client, snapshot);
+      }
+    }
+  }
+  SV_SendClientFrame(client, snapshot) {
+    const MTU = 1400;
+    const writer = new shared.BinaryWriter(MTU);
+    writer.writeByte(shared.ServerCommand.frame);
+    writer.writeLong(this.sv.frame);
+    let deltaFrame = 0;
+    if (client.lastFrame && client.lastFrame < this.sv.frame && client.lastFrame >= this.sv.frame - shared.UPDATE_BACKUP) {
+      deltaFrame = client.lastFrame;
+    }
+    writer.writeLong(deltaFrame);
+    writer.writeByte(0);
+    writer.writeByte(0);
+    writer.writeByte(shared.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
+    };
+    shared.writePlayerState(writer, ps);
+    writer.writeByte(shared.ServerCommand.packetentities);
+    const entities = snapshot.packetEntities || [];
+    const currentEntityIds = [];
+    const frameIdx = this.sv.frame % shared.UPDATE_BACKUP;
+    const currentFrame = client.frames[frameIdx];
+    currentFrame.entities = entities;
+    let oldEntities = [];
+    if (deltaFrame > 0) {
+      const oldFrameIdx = deltaFrame % shared.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) {
+        shared.writeDeltaEntity(oldState, entityState, writer, false, false);
+      } else {
+        shared.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)) {
+        shared.writeRemoveEntity(oldId, writer);
+      }
+    }
+    writer.writeShort(0);
+    const frameData = writer.getData();
+    currentFrame.packetCRC = shared.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 };
+  }
+  modelIndex(name) {
+    console.log(`modelIndex(${name}) called`);
+    const start = shared.ConfigStringIndex.Models;
+    const end = shared.ConfigStringIndex.Sounds;
+    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_MODELS overflow for ${name}`);
+    return 0;
+  }
+  soundIndex(name) {
+    const start = shared.ConfigStringIndex.Sounds;
+    const end = shared.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 = shared.ConfigStringIndex.Images;
+    const end = shared.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 shared.BinaryWriter();
+    writeServerCommand(writer, event, ...args);
+    const data = writer.getData();
+    for (const client of this.svs.clients) {
+      if (!client || client.state < 4 /* Active */ || !client.edict) {
+        continue;
+      }
+      let send = false;
+      switch (type) {
+        case game.MulticastType.All:
+          send = true;
+          break;
+        case game.MulticastType.Pvs:
+          if (this.sv.collisionModel) {
+            send = shared.inPVS(origin, client.edict.origin, this.sv.collisionModel);
+          } else {
+            send = true;
+          }
+          break;
+        case game.MulticastType.Phs:
+          if (this.sv.collisionModel) {
+            send = shared.inPHS(origin, client.edict.origin, this.sv.collisionModel);
+          } else {
+            send = true;
+          }
+          break;
+      }
+      if (send) {
+        {
+          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 >= 2 /* Connected */) {
+      const writer = new shared.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 = 1e3;
+    this.game.entities.forEachEntity((ent) => {
+      if (ent.solid !== game.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 === void 0) return;
+      const now = Date.now();
+      const targetTime = now - lagMs;
+      this.game.entities.forEachEntity((ent) => {
+        if (ent === client) return;
+        if (ent.solid === game.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: shared.lerpAngle(s1.angles.x, s2.angles.x, frac),
+          y: shared.lerpAngle(s1.angles.y, s2.angles.y, frac),
+          z: shared.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();
+    }
+  }
+};
+function createServer(options = {}) {
+  return new DedicatedServer(options);
+}
+
+exports.ClientMessageParser = ClientMessageParser;
+exports.ClientState = ClientState;
+exports.DedicatedServer = DedicatedServer;
+exports.ServerState = ServerState;
+exports.WebSocketNetDriver = WebSocketNetDriver;
+exports.createClient = createClient;
+exports.createServer = createServer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map