quake2ts 0.0.577 → 0.0.580

package/packages/tools/dist/esm/index.js

@@ -165,6 +165,973 @@ function exportMd3ToGltf(model) {
   };
 }
 
+// ../shared/dist/esm/index.js
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var DEG_TO_RAD = Math.PI / 180;
+var DEG2RAD_FACTOR = Math.PI / 180;
+var RAD2DEG_FACTOR = 180 / Math.PI;
+var ANORMS = [
+  [-0.525731, 0, 0.850651],
+  [-0.442863, 0.238856, 0.864188],
+  [-0.295242, 0, 0.955423],
+  [-0.309017, 0.5, 0.809017],
+  [-0.16246, 0.262866, 0.951056],
+  [0, 0, 1],
+  [0, 0.850651, 0.525731],
+  [-0.147621, 0.716567, 0.681718],
+  [0.147621, 0.716567, 0.681718],
+  [0, 0.525731, 0.850651],
+  [0.309017, 0.5, 0.809017],
+  [0.525731, 0, 0.850651],
+  [0.295242, 0, 0.955423],
+  [0.442863, 0.238856, 0.864188],
+  [0.16246, 0.262866, 0.951056],
+  [-0.681718, 0.147621, 0.716567],
+  [-0.809017, 0.309017, 0.5],
+  [-0.587785, 0.425325, 0.688191],
+  [-0.850651, 0.525731, 0],
+  [-0.864188, 0.442863, 0.238856],
+  [-0.716567, 0.681718, 0.147621],
+  [-0.688191, 0.587785, 0.425325],
+  [-0.5, 0.809017, 0.309017],
+  [-0.238856, 0.864188, 0.442863],
+  [-0.425325, 0.688191, 0.587785],
+  [-0.716567, 0.681718, -0.147621],
+  [-0.5, 0.809017, -0.309017],
+  [-0.525731, 0.850651, 0],
+  [0, 0.850651, -0.525731],
+  [-0.238856, 0.864188, -0.442863],
+  [0, 0.955423, -0.295242],
+  [-0.262866, 0.951056, -0.16246],
+  [0, 1, 0],
+  [0, 0.955423, 0.295242],
+  [-0.262866, 0.951056, 0.16246],
+  [0.238856, 0.864188, 0.442863],
+  [0.262866, 0.951056, 0.16246],
+  [0.5, 0.809017, 0.309017],
+  [0.238856, 0.864188, -0.442863],
+  [0.262866, 0.951056, -0.16246],
+  [0.5, 0.809017, -0.309017],
+  [0.850651, 0.525731, 0],
+  [0.716567, 0.681718, 0.147621],
+  [0.716567, 0.681718, -0.147621],
+  [0.525731, 0.850651, 0],
+  [0.425325, 0.688191, 0.587785],
+  [0.864188, 0.442863, 0.238856],
+  [0.688191, 0.587785, 0.425325],
+  [0.809017, 0.309017, 0.5],
+  [0.681718, 0.147621, 0.716567],
+  [0.587785, 0.425325, 0.688191],
+  [0.955423, 0.295242, 0],
+  [1, 0, 0],
+  [0.951056, 0.16246, 0.262866],
+  [0.850651, -0.525731, 0],
+  [0.955423, -0.295242, 0],
+  [0.864188, -0.442863, 0.238856],
+  [0.951056, -0.16246, 0.262866],
+  [0.809017, -0.309017, 0.5],
+  [0.681718, -0.147621, 0.716567],
+  [0.850651, 0, 0.525731],
+  [0.864188, 0.442863, -0.238856],
+  [0.809017, 0.309017, -0.5],
+  [0.951056, 0.16246, -0.262866],
+  [0.525731, 0, -0.850651],
+  [0.681718, 0.147621, -0.716567],
+  [0.681718, -0.147621, -0.716567],
+  [0.850651, 0, -0.525731],
+  [0.809017, -0.309017, -0.5],
+  [0.864188, -0.442863, -0.238856],
+  [0.951056, -0.16246, -0.262866],
+  [0.147621, 0.716567, -0.681718],
+  [0.309017, 0.5, -0.809017],
+  [0.425325, 0.688191, -0.587785],
+  [0.442863, 0.238856, -0.864188],
+  [0.587785, 0.425325, -0.688191],
+  [0.688191, 0.587785, -0.425325],
+  [-0.147621, 0.716567, -0.681718],
+  [-0.309017, 0.5, -0.809017],
+  [0, 0.525731, -0.850651],
+  [-0.525731, 0, -0.850651],
+  [-0.442863, 0.238856, -0.864188],
+  [-0.295242, 0, -0.955423],
+  [-0.16246, 0.262866, -0.951056],
+  [0, 0, -1],
+  [0.295242, 0, -0.955423],
+  [0.16246, 0.262866, -0.951056],
+  [-0.442863, -0.238856, -0.864188],
+  [-0.309017, -0.5, -0.809017],
+  [-0.16246, -0.262866, -0.951056],
+  [0, -0.850651, -0.525731],
+  [-0.147621, -0.716567, -0.681718],
+  [0.147621, -0.716567, -0.681718],
+  [0, -0.525731, -0.850651],
+  [0.309017, -0.5, -0.809017],
+  [0.442863, -0.238856, -0.864188],
+  [0.16246, -0.262866, -0.951056],
+  [0.238856, -0.864188, -0.442863],
+  [0.5, -0.809017, -0.309017],
+  [0.425325, -0.688191, -0.587785],
+  [0.716567, -0.681718, -0.147621],
+  [0.688191, -0.587785, -0.425325],
+  [0.587785, -0.425325, -0.688191],
+  [0, -0.955423, -0.295242],
+  [0, -1, 0],
+  [0.262866, -0.951056, -0.16246],
+  [0, -0.850651, 0.525731],
+  [0, -0.955423, 0.295242],
+  [0.238856, -0.864188, 0.442863],
+  [0.262866, -0.951056, 0.16246],
+  [0.5, -0.809017, 0.309017],
+  [0.716567, -0.681718, 0.147621],
+  [0.525731, -0.850651, 0],
+  [-0.238856, -0.864188, -0.442863],
+  [-0.5, -0.809017, -0.309017],
+  [-0.262866, -0.951056, -0.16246],
+  [-0.850651, -0.525731, 0],
+  [-0.716567, -0.681718, -0.147621],
+  [-0.716567, -0.681718, 0.147621],
+  [-0.525731, -0.850651, 0],
+  [-0.5, -0.809017, 0.309017],
+  [-0.238856, -0.864188, 0.442863],
+  [-0.262866, -0.951056, 0.16246],
+  [-0.864188, -0.442863, 0.238856],
+  [-0.809017, -0.309017, 0.5],
+  [-0.688191, -0.587785, 0.425325],
+  [-0.681718, -0.147621, 0.716567],
+  [-0.442863, -0.238856, 0.864188],
+  [-0.587785, -0.425325, 0.688191],
+  [-0.309017, -0.5, 0.809017],
+  [-0.147621, -0.716567, 0.681718],
+  [-0.425325, -0.688191, 0.587785],
+  [-0.16246, -0.262866, 0.951056],
+  [0.442863, -0.238856, 0.864188],
+  [0.16246, -0.262866, 0.951056],
+  [0.309017, -0.5, 0.809017],
+  [0.147621, -0.716567, 0.681718],
+  [0, -0.525731, 0.850651],
+  [0.425325, -0.688191, 0.587785],
+  [0.587785, -0.425325, 0.688191],
+  [0.688191, -0.587785, 0.425325],
+  [-0.955423, 0.295242, 0],
+  [-0.951056, 0.16246, 0.262866],
+  [-1, 0, 0],
+  [-0.850651, 0, 0.525731],
+  [-0.955423, -0.295242, 0],
+  [-0.951056, -0.16246, 0.262866],
+  [-0.864188, 0.442863, -0.238856],
+  [-0.951056, 0.16246, -0.262866],
+  [-0.809017, 0.309017, -0.5],
+  [-0.864188, -0.442863, -0.238856],
+  [-0.951056, -0.16246, -0.262866],
+  [-0.809017, -0.309017, -0.5],
+  [-0.681718, 0.147621, -0.716567],
+  [-0.681718, -0.147621, -0.716567],
+  [-0.850651, 0, -0.525731],
+  [-0.688191, 0.587785, -0.425325],
+  [-0.587785, 0.425325, -0.688191],
+  [-0.425325, 0.688191, -0.587785],
+  [-0.425325, -0.688191, -0.587785],
+  [-0.587785, -0.425325, -0.688191],
+  [-0.688191, -0.587785, -0.425325]
+];
+var CONTENTS_SOLID = 1 << 0;
+var CONTENTS_WINDOW = 1 << 1;
+var CONTENTS_AUX = 1 << 2;
+var CONTENTS_LAVA = 1 << 3;
+var CONTENTS_SLIME = 1 << 4;
+var CONTENTS_WATER = 1 << 5;
+var CONTENTS_MIST = 1 << 6;
+var CONTENTS_NO_WATERJUMP = 1 << 13;
+var CONTENTS_PROJECTILECLIP = 1 << 14;
+var CONTENTS_AREAPORTAL = 1 << 15;
+var CONTENTS_PLAYERCLIP = 1 << 16;
+var CONTENTS_MONSTERCLIP = 1 << 17;
+var CONTENTS_CURRENT_0 = 1 << 18;
+var CONTENTS_CURRENT_90 = 1 << 19;
+var CONTENTS_CURRENT_180 = 1 << 20;
+var CONTENTS_CURRENT_270 = 1 << 21;
+var CONTENTS_CURRENT_UP = 1 << 22;
+var CONTENTS_CURRENT_DOWN = 1 << 23;
+var CONTENTS_ORIGIN = 1 << 24;
+var CONTENTS_MONSTER = 1 << 25;
+var CONTENTS_DEADMONSTER = 1 << 26;
+var CONTENTS_DETAIL = 1 << 27;
+var CONTENTS_TRANSLUCENT = 1 << 28;
+var CONTENTS_LADDER = 1 << 29;
+var CONTENTS_PLAYER = 1 << 30;
+var CONTENTS_PROJECTILE = 1 << 31;
+var SURF_LIGHT = 1 << 0;
+var SURF_SLICK = 1 << 1;
+var SURF_SKY = 1 << 2;
+var SURF_WARP = 1 << 3;
+var SURF_TRANS33 = 1 << 4;
+var SURF_TRANS66 = 1 << 5;
+var SURF_FLOWING = 1 << 6;
+var SURF_NODRAW = 1 << 7;
+var SURF_ALPHATEST = 1 << 25;
+var SURF_N64_UV = 1 << 28;
+var SURF_N64_SCROLL_X = 1 << 29;
+var SURF_N64_SCROLL_Y = 1 << 30;
+var SURF_N64_SCROLL_FLIP = 1 << 31;
+var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
+var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+var MAX_CHECKCOUNT = Number.MAX_SAFE_INTEGER - 1;
+var MAX_CLIENTS = 256;
+var MAX_LIGHTSTYLES = 256;
+var MAX_MODELS = 8192;
+var MAX_SOUNDS = 2048;
+var MAX_IMAGES = 512;
+var MAX_ITEMS = 256;
+var MAX_GENERAL = MAX_CLIENTS * 2;
+var MAX_SHADOW_LIGHTS = 256;
+var MAX_WHEEL_ITEMS = 32;
+var ConfigStringIndex = ((ConfigStringIndex2) => {
+  ConfigStringIndex2[ConfigStringIndex2["Name"] = 0] = "Name";
+  ConfigStringIndex2[ConfigStringIndex2["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex2[ConfigStringIndex2["Sky"] = 2] = "Sky";
+  ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex2[ConfigStringIndex2["HealthBarName"] = 55] = "HealthBarName";
+  ConfigStringIndex2[ConfigStringIndex2["CONFIG_N64_PHYSICS"] = 56] = "CONFIG_N64_PHYSICS";
+  ConfigStringIndex2[ConfigStringIndex2["CONFIG_CTF_TEAMS"] = 57] = "CONFIG_CTF_TEAMS";
+  ConfigStringIndex2[ConfigStringIndex2["CONFIG_COOP_RESPAWN_STRING"] = 58] = "CONFIG_COOP_RESPAWN_STRING";
+  ConfigStringIndex2[ConfigStringIndex2["Story"] = 54] = "Story";
+  ConfigStringIndex2[ConfigStringIndex2["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex2[ConfigStringIndex2["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex2[ConfigStringIndex2["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex2[ConfigStringIndex2["Models"] = 62] = "Models";
+  ConfigStringIndex2[ConfigStringIndex2["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex2[ConfigStringIndex2["Images"] = ConfigStringIndex2.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex2[ConfigStringIndex2["Lights"] = ConfigStringIndex2.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex2[ConfigStringIndex2["ShadowLights"] = ConfigStringIndex2.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex2[ConfigStringIndex2["Items"] = ConfigStringIndex2.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex2[ConfigStringIndex2["Players"] = ConfigStringIndex2.Items + MAX_ITEMS] = "Players";
+  ConfigStringIndex2[ConfigStringIndex2["PlayerSkins"] = ConfigStringIndex2.Players] = "PlayerSkins";
+  ConfigStringIndex2[ConfigStringIndex2["General"] = ConfigStringIndex2.Players + MAX_CLIENTS] = "General";
+  ConfigStringIndex2[ConfigStringIndex2["WheelWeapons"] = ConfigStringIndex2.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex2[ConfigStringIndex2["WheelAmmo"] = ConfigStringIndex2.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex2[ConfigStringIndex2["WheelPowerups"] = ConfigStringIndex2.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex2[ConfigStringIndex2["CdLoopCount"] = ConfigStringIndex2.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex2[ConfigStringIndex2["GameStyle"] = ConfigStringIndex2.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex2[ConfigStringIndex2["MaxConfigStrings"] = ConfigStringIndex2.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex2;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var CS_SOUNDS = ConfigStringIndex.Sounds;
+var CS_IMAGES = ConfigStringIndex.Images;
+var CS_LIGHTS = ConfigStringIndex.Lights;
+var CS_ITEMS = ConfigStringIndex.Items;
+var CS_PLAYERS = ConfigStringIndex.Players;
+var CS_GENERAL = ConfigStringIndex.General;
+var replay_exports = {};
+__export(replay_exports, {
+  addReplayFrame: () => addReplayFrame,
+  createReplaySession: () => createReplaySession,
+  deserializeReplay: () => deserializeReplay,
+  serializeReplay: () => serializeReplay
+});
+function serializeReplay(session) {
+  return JSON.stringify(session, null, 2);
+}
+function deserializeReplay(json) {
+  const session = JSON.parse(json);
+  if (!session.metadata || !Array.isArray(session.frames)) {
+    throw new Error("Invalid replay format: missing metadata or frames");
+  }
+  return session;
+}
+function createReplaySession(map, seed) {
+  return {
+    metadata: {
+      map,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0",
+      seed
+    },
+    frames: []
+  };
+}
+function addReplayFrame(session, cmd, serverFrame, startTime) {
+  session.frames.push({
+    serverFrame,
+    cmd,
+    timestamp: Date.now() - startTime
+  });
+}
+var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+var AMMO_MAX = 12;
+var NUM_BITS_FOR_AMMO = 9;
+var NUM_AMMO_STATS = Math.ceil(AMMO_MAX * NUM_BITS_FOR_AMMO / 16);
+var POWERUP_MAX = 23;
+var NUM_BITS_FOR_POWERUP = 2;
+var NUM_POWERUP_STATS = Math.ceil(POWERUP_MAX * NUM_BITS_FOR_POWERUP / 16);
+var U_ORIGIN1 = 1 << 0;
+var U_ORIGIN2 = 1 << 1;
+var U_ANGLE2 = 1 << 2;
+var U_ANGLE3 = 1 << 3;
+var U_FRAME8 = 1 << 4;
+var U_EVENT = 1 << 5;
+var U_REMOVE = 1 << 6;
+var U_MOREBITS1 = 1 << 7;
+var U_NUMBER16 = 1 << 8;
+var U_ORIGIN3 = 1 << 9;
+var U_ANGLE1 = 1 << 10;
+var U_MODEL = 1 << 11;
+var U_RENDERFX8 = 1 << 12;
+var U_ALPHA = 1 << 13;
+var U_EFFECTS8 = 1 << 14;
+var U_MOREBITS2 = 1 << 15;
+var U_SKIN8 = 1 << 16;
+var U_FRAME16 = 1 << 17;
+var U_RENDERFX16 = 1 << 18;
+var U_EFFECTS16 = 1 << 19;
+var U_MODEL2 = 1 << 20;
+var U_MODEL3 = 1 << 21;
+var U_MODEL4 = 1 << 22;
+var U_MOREBITS3 = 1 << 23;
+var U_OLDORIGIN = 1 << 24;
+var U_SKIN16 = 1 << 25;
+var U_SOUND = 1 << 26;
+var U_SOLID = 1 << 27;
+var U_SCALE = 1 << 28;
+var U_INSTANCE_BITS = 1 << 29;
+var U_LOOP_VOLUME = 1 << 30;
+var U_MOREBITS4 = 2147483648 | 0;
+var U_LOOP_ATTENUATION_HIGH = 1 << 0;
+var U_OWNER_HIGH = 1 << 1;
+var U_OLD_FRAME_HIGH = 1 << 2;
+var PS_M_TYPE = 1 << 0;
+var PS_M_ORIGIN = 1 << 1;
+var PS_M_VELOCITY = 1 << 2;
+var PS_M_TIME = 1 << 3;
+var PS_M_FLAGS = 1 << 4;
+var PS_M_GRAVITY = 1 << 5;
+var PS_M_DELTA_ANGLES = 1 << 6;
+var PS_VIEWOFFSET = 1 << 7;
+var PS_VIEWANGLES = 1 << 8;
+var PS_KICKANGLES = 1 << 9;
+var PS_BLEND = 1 << 10;
+var PS_FOV = 1 << 11;
+var PS_WEAPONINDEX = 1 << 12;
+var PS_WEAPONFRAME = 1 << 13;
+var PS_RDFLAGS = 1 << 14;
+var BinaryStream = class {
+  constructor(buffer) {
+    if (buffer instanceof Uint8Array) {
+      this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    } else {
+      this.view = new DataView(buffer);
+    }
+    this.offset = 0;
+    this.length = this.view.byteLength;
+  }
+  getPosition() {
+    return this.offset;
+  }
+  getReadPosition() {
+    return this.offset;
+  }
+  getLength() {
+    return this.length;
+  }
+  getRemaining() {
+    return this.length - this.offset;
+  }
+  seek(position) {
+    if (position < 0 || position > this.length) {
+      throw new Error(`Seek out of bounds: ${position} (length: ${this.length})`);
+    }
+    this.offset = position;
+  }
+  setReadPosition(position) {
+    this.seek(position);
+  }
+  hasMore() {
+    return this.offset < this.length;
+  }
+  hasBytes(count) {
+    return this.offset + count <= this.length;
+  }
+  readChar() {
+    const value = this.view.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readByte() {
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readShort() {
+    const value = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readUShort() {
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  readLong() {
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readULong() {
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readFloat() {
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readString() {
+    let str = "";
+    while (this.offset < this.length) {
+      const charCode = this.readChar();
+      if (charCode === -1 || charCode === 0) {
+        break;
+      }
+      str += String.fromCharCode(charCode);
+    }
+    return str;
+  }
+  readStringLine() {
+    let str = "";
+    while (this.offset < this.length) {
+      const charCode = this.readChar();
+      if (charCode === -1 || charCode === 0 || charCode === 10) {
+        break;
+      }
+      str += String.fromCharCode(charCode);
+    }
+    return str;
+  }
+  readCoord() {
+    return this.readShort() * (1 / 8);
+  }
+  readAngle() {
+    return this.readChar() * (360 / 256);
+  }
+  readAngle16() {
+    return this.readShort() * 360 / 65536;
+  }
+  readData(length) {
+    if (this.offset + length > this.length) {
+      throw new Error(`Read out of bounds: ${this.offset + length} (length: ${this.length})`);
+    }
+    const data = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
+    this.offset += length;
+    return new Uint8Array(data);
+  }
+  readPos(out) {
+    out.x = this.readCoord();
+    out.y = this.readCoord();
+    out.z = this.readCoord();
+  }
+  readDir(out) {
+    const b = this.readByte();
+    if (b >= 162) {
+      out.x = 0;
+      out.y = 0;
+      out.z = 0;
+      return;
+    }
+    const norm = ANORMS[b];
+    out.x = norm[0];
+    out.y = norm[1];
+    out.z = norm[2];
+  }
+};
+var BinaryWriter = class {
+  constructor(sizeOrBuffer = 1400) {
+    if (typeof sizeOrBuffer === "number") {
+      this.buffer = new Uint8Array(sizeOrBuffer);
+      this.fixed = false;
+    } else {
+      this.buffer = sizeOrBuffer;
+      this.fixed = true;
+    }
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    this.offset = 0;
+  }
+  ensureSpace(bytes) {
+    if (this.offset + bytes > this.buffer.byteLength) {
+      if (this.fixed) {
+        throw new Error(`Buffer overflow: capacity ${this.buffer.byteLength}, needed ${this.offset + bytes}`);
+      }
+      const newSize = Math.max(this.buffer.byteLength * 2, this.offset + bytes);
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this.buffer);
+      this.buffer = newBuffer;
+      this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    }
+  }
+  writeByte(value) {
+    this.ensureSpace(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeBytes(data) {
+    this.ensureSpace(data.byteLength);
+    this.buffer.set(data, this.offset);
+    this.offset += data.byteLength;
+  }
+  writeChar(value) {
+    this.ensureSpace(1);
+    this.view.setInt8(this.offset, value);
+    this.offset += 1;
+  }
+  writeShort(value) {
+    this.ensureSpace(2);
+    this.view.setInt16(this.offset, value, true);
+    this.offset += 2;
+  }
+  writeLong(value) {
+    this.ensureSpace(4);
+    this.view.setInt32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeFloat(value) {
+    this.ensureSpace(4);
+    this.view.setFloat32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeString(value) {
+    const len = value.length;
+    this.ensureSpace(len + 1);
+    for (let i = 0; i < len; i++) {
+      this.view.setUint8(this.offset + i, value.charCodeAt(i));
+    }
+    this.view.setUint8(this.offset + len, 0);
+    this.offset += len + 1;
+  }
+  writeCoord(value) {
+    this.writeShort(Math.trunc(value * 8));
+  }
+  writeAngle(value) {
+    this.writeByte(Math.trunc(value * 256 / 360) & 255);
+  }
+  writeAngle16(value) {
+    this.writeShort(Math.trunc(value * 65536 / 360) & 65535);
+  }
+  writePos(pos) {
+    this.writeCoord(pos.x);
+    this.writeCoord(pos.y);
+    this.writeCoord(pos.z);
+  }
+  writeDir(dir) {
+    let maxDot = -1;
+    let bestIndex = 0;
+    if (dir.x === 0 && dir.y === 0 && dir.z === 0) {
+      this.writeByte(0);
+      return;
+    }
+    for (let i = 0; i < ANORMS.length; i++) {
+      const norm = ANORMS[i];
+      const dot = dir.x * norm[0] + dir.y * norm[1] + dir.z * norm[2];
+      if (dot > maxDot) {
+        maxDot = dot;
+        bestIndex = i;
+      }
+    }
+    this.writeByte(bestIndex);
+  }
+  getData() {
+    return this.buffer.slice(0, this.offset);
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  getOffset() {
+    return this.offset;
+  }
+  reset() {
+    this.offset = 0;
+  }
+};
+var _NetChan = class _NetChan2 {
+  constructor() {
+    this.qport = 0;
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.fragmentSendOffset = 0;
+    this.fragmentBuffer = null;
+    this.fragmentLength = 0;
+    this.fragmentReceived = 0;
+    this.lastReceived = 0;
+    this.lastSent = 0;
+    this.remoteAddress = null;
+    this.reliableMessage = new BinaryWriter(_NetChan2.MAX_RELIABLE_BUFFER);
+    const now = Date.now();
+    this.lastReceived = now;
+    this.lastSent = now;
+    this.qport = Math.floor(Math.random() * 65536);
+  }
+  /**
+   * Setup the netchan with specific settings
+   */
+  setup(qport, address = null) {
+    this.qport = qport;
+    this.remoteAddress = address;
+    this.reset();
+  }
+  /**
+   * Reset the netchan state
+   */
+  reset() {
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.reliableMessage.reset();
+    this.fragmentSendOffset = 0;
+    this.fragmentBuffer = null;
+    this.fragmentLength = 0;
+    this.fragmentReceived = 0;
+    this.lastReceived = Date.now();
+    this.lastSent = Date.now();
+  }
+  /**
+   * Transmits a packet containing reliable and unreliable data
+   */
+  transmit(unreliableData) {
+    this.outgoingSequence++;
+    this.lastSent = Date.now();
+    let sendReliableLength = 0;
+    let isFragment = false;
+    let fragmentStart = 0;
+    if (this.reliableLength > 0) {
+      if (this.reliableLength > _NetChan2.FRAGMENT_SIZE) {
+        isFragment = true;
+        if (this.fragmentSendOffset >= this.reliableLength) {
+          this.fragmentSendOffset = 0;
+        }
+        const remaining = this.reliableLength - this.fragmentSendOffset;
+        sendReliableLength = remaining;
+        if (sendReliableLength > _NetChan2.FRAGMENT_SIZE) {
+          sendReliableLength = _NetChan2.FRAGMENT_SIZE;
+        }
+        fragmentStart = this.fragmentSendOffset;
+        this.fragmentSendOffset += sendReliableLength;
+      } else {
+        sendReliableLength = this.reliableLength;
+      }
+    }
+    const headerSize = _NetChan2.PACKET_HEADER;
+    const reliableHeaderSize = sendReliableLength > 0 ? 2 + (isFragment ? 8 : 0) : 0;
+    let unreliableSize = unreliableData ? unreliableData.length : 0;
+    if (headerSize + reliableHeaderSize + sendReliableLength + unreliableSize > _NetChan2.MAX_MSGLEN) {
+      unreliableSize = _NetChan2.MAX_MSGLEN - headerSize - reliableHeaderSize - sendReliableLength;
+      if (unreliableSize < 0) unreliableSize = 0;
+    }
+    const buffer = new ArrayBuffer(headerSize + reliableHeaderSize + sendReliableLength + unreliableSize);
+    const view = new DataView(buffer);
+    const result = new Uint8Array(buffer);
+    let sequence = this.outgoingSequence;
+    if (sendReliableLength > 0) {
+      sequence |= 2147483648;
+      if ((this.outgoingReliableSequence & 1) !== 0) {
+        sequence |= 1073741824;
+      }
+    }
+    view.setUint32(0, sequence, true);
+    let ack = this.incomingSequence;
+    if ((this.incomingReliableSequence & 1) !== 0) {
+      ack |= 2147483648;
+    }
+    view.setUint32(4, ack, true);
+    view.setUint16(8, this.qport, true);
+    let offset = headerSize;
+    if (sendReliableLength > 0) {
+      let lengthField = sendReliableLength;
+      if (isFragment) {
+        lengthField |= 32768;
+      }
+      view.setUint16(offset, lengthField, true);
+      offset += 2;
+      if (isFragment) {
+        view.setUint32(offset, fragmentStart, true);
+        offset += 4;
+        view.setUint32(offset, this.reliableLength, true);
+        offset += 4;
+      }
+      const reliableBuffer = this.reliableMessage.getBuffer();
+      const reliableBytes = reliableBuffer.subarray(fragmentStart, fragmentStart + sendReliableLength);
+      result.set(reliableBytes, offset);
+      offset += sendReliableLength;
+    }
+    if (unreliableData && unreliableSize > 0) {
+      const chunk = unreliableData.slice(0, unreliableSize);
+      result.set(chunk, offset);
+    }
+    return result;
+  }
+  /**
+   * Processes a received packet
+   * Returns the payload data (reliable + unreliable) to be processed, or null if discarded
+   */
+  process(packet) {
+    if (packet.length < _NetChan2.PACKET_HEADER) {
+      return null;
+    }
+    this.lastReceived = Date.now();
+    const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const sequence = view.getUint32(0, true);
+    const ack = view.getUint32(4, true);
+    const qport = view.getUint16(8, true);
+    if (this.qport !== qport) {
+      return null;
+    }
+    const seqNumberClean = sequence & ~(2147483648 | 1073741824);
+    if ((seqNumberClean - this.incomingSequence | 0) <= 0) {
+      return null;
+    }
+    this.incomingSequence = seqNumberClean;
+    const ackNumber = ack & ~2147483648;
+    const ackReliable = (ack & 2147483648) !== 0;
+    if (ackNumber > this.incomingAcknowledged) {
+      this.incomingAcknowledged = ackNumber;
+    }
+    if (this.reliableLength > 0) {
+      const receivedAckBit = ackReliable ? 1 : 0;
+      const currentReliableBit = this.outgoingReliableSequence & 1;
+      if (receivedAckBit !== currentReliableBit) {
+        this.reliableLength = 0;
+        this.reliableMessage.reset();
+        this.outgoingReliableSequence ^= 1;
+        this.fragmentSendOffset = 0;
+      }
+    }
+    const hasReliableData = (sequence & 2147483648) !== 0;
+    const reliableSeqBit = (sequence & 1073741824) !== 0 ? 1 : 0;
+    let payloadOffset = _NetChan2.PACKET_HEADER;
+    let reliableData = null;
+    if (hasReliableData) {
+      if (payloadOffset + 2 > packet.byteLength) return null;
+      let reliableLen = view.getUint16(payloadOffset, true);
+      payloadOffset += 2;
+      const isFragment = (reliableLen & 32768) !== 0;
+      reliableLen &= 32767;
+      const expectedBit = this.incomingReliableSequence & 1;
+      if (reliableSeqBit === expectedBit) {
+        if (isFragment) {
+          if (payloadOffset + 8 > packet.byteLength) return null;
+          const fragStart = view.getUint32(payloadOffset, true);
+          payloadOffset += 4;
+          const fragTotal = view.getUint32(payloadOffset, true);
+          payloadOffset += 4;
+          if (fragTotal > _NetChan2.MAX_RELIABLE_BUFFER) {
+            console.warn(`NetChan: received invalid fragment total ${fragTotal} > ${_NetChan2.MAX_RELIABLE_BUFFER}`);
+            return null;
+          }
+          if (!this.fragmentBuffer || this.fragmentBuffer.length !== fragTotal) {
+            this.fragmentBuffer = new Uint8Array(fragTotal);
+            this.fragmentLength = fragTotal;
+            this.fragmentReceived = 0;
+          }
+          if (payloadOffset + reliableLen > packet.byteLength) return null;
+          const data = packet.subarray(payloadOffset, payloadOffset + reliableLen);
+          if (fragStart === this.fragmentReceived && fragStart + reliableLen <= fragTotal) {
+            this.fragmentBuffer.set(data, fragStart);
+            this.fragmentReceived += reliableLen;
+            if (this.fragmentReceived >= fragTotal) {
+              reliableData = this.fragmentBuffer;
+              this.incomingReliableSequence++;
+              this.fragmentBuffer = null;
+              this.fragmentLength = 0;
+              this.fragmentReceived = 0;
+            }
+          }
+        } else {
+          this.incomingReliableSequence++;
+          if (payloadOffset + reliableLen > packet.byteLength) return null;
+          reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+        }
+      }
+      payloadOffset += reliableLen;
+    }
+    const unreliableData = packet.slice(payloadOffset);
+    if (reliableData && reliableData.length > 0) {
+      const totalLen = reliableData.length + unreliableData.length;
+      const result = new Uint8Array(totalLen);
+      result.set(reliableData, 0);
+      result.set(unreliableData, reliableData.length);
+      return result;
+    }
+    if (unreliableData) {
+      return unreliableData;
+    }
+    return new Uint8Array(0);
+  }
+  /**
+   * Checks if reliable message buffer is empty and ready for new data
+   */
+  canSendReliable() {
+    return this.reliableLength === 0;
+  }
+  /**
+   * Writes a byte to the reliable message buffer
+   */
+  writeReliableByte(value) {
+    if (this.reliableLength + 1 > _NetChan2.MAX_RELIABLE_BUFFER) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeByte(value);
+    this.reliableLength++;
+  }
+  /**
+   * Writes a short to the reliable message buffer
+   */
+  writeReliableShort(value) {
+    if (this.reliableLength + 2 > _NetChan2.MAX_RELIABLE_BUFFER) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeShort(value);
+    this.reliableLength += 2;
+  }
+  /**
+   * Writes a long to the reliable message buffer
+   */
+  writeReliableLong(value) {
+    if (this.reliableLength + 4 > _NetChan2.MAX_RELIABLE_BUFFER) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeLong(value);
+    this.reliableLength += 4;
+  }
+  /**
+   * Writes a string to the reliable message buffer
+   */
+  writeReliableString(value) {
+    const len = value.length + 1;
+    if (this.reliableLength + len > _NetChan2.MAX_RELIABLE_BUFFER) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeString(value);
+    this.reliableLength += len;
+  }
+  /**
+   * Returns the current reliable data buffer
+   */
+  getReliableData() {
+    if (this.reliableLength === 0) {
+      return new Uint8Array(0);
+    }
+    const buffer = this.reliableMessage.getBuffer();
+    return buffer.subarray(0, this.reliableLength);
+  }
+  /**
+   * Checks if we need to send a keepalive packet
+   */
+  needsKeepalive(currentTime) {
+    return currentTime - this.lastSent > 1e3;
+  }
+  /**
+   * Checks if the connection has timed out
+   */
+  isTimedOut(currentTime, timeoutMs = 3e4) {
+    return currentTime - this.lastReceived > timeoutMs;
+  }
+};
+_NetChan.MAX_MSGLEN = 1400;
+_NetChan.FRAGMENT_SIZE = 1024;
+_NetChan.PACKET_HEADER = 10;
+_NetChan.HEADER_OVERHEAD = _NetChan.PACKET_HEADER + 2;
+_NetChan.MAX_RELIABLE_BUFFER = 262144;
+var AmmoType = /* @__PURE__ */ ((AmmoType2) => {
+  AmmoType2[AmmoType2["Bullets"] = 0] = "Bullets";
+  AmmoType2[AmmoType2["Shells"] = 1] = "Shells";
+  AmmoType2[AmmoType2["Rockets"] = 2] = "Rockets";
+  AmmoType2[AmmoType2["Grenades"] = 3] = "Grenades";
+  AmmoType2[AmmoType2["Cells"] = 4] = "Cells";
+  AmmoType2[AmmoType2["Slugs"] = 5] = "Slugs";
+  AmmoType2[AmmoType2["MagSlugs"] = 6] = "MagSlugs";
+  AmmoType2[AmmoType2["Trap"] = 7] = "Trap";
+  AmmoType2[AmmoType2["Flechettes"] = 8] = "Flechettes";
+  AmmoType2[AmmoType2["Tesla"] = 9] = "Tesla";
+  AmmoType2[AmmoType2["Disruptor"] = 10] = "Disruptor";
+  AmmoType2[AmmoType2["Prox"] = 11] = "Prox";
+  AmmoType2[AmmoType2["Nuke"] = 12] = "Nuke";
+  AmmoType2[AmmoType2["Rounds"] = 13] = "Rounds";
+  return AmmoType2;
+})(AmmoType || {});
+var AMMO_TYPE_COUNT = Object.keys(AmmoType).length / 2;
+
+// src/bspTools.ts
+import { serializeEntLump } from "@quake2ts/engine";
+function replaceBspEntities(bspData, entities) {
+  const reader = new BinaryStream(bspData);
+  const magic = reader.readLong();
+  const version = reader.readLong();
+  if (magic !== 1347633737 || version !== 38) {
+    throw new Error("Invalid BSP file");
+  }
+  const LUMP_ENTITIES = 0;
+  const lumps = [];
+  for (let i = 0; i < 19; i++) {
+    lumps.push({
+      offset: reader.readLong(),
+      length: reader.readLong()
+    });
+  }
+  const entitiesLump = lumps[LUMP_ENTITIES];
+  const newEntitiesText = serializeEntLump(entities);
+  const encoder = new TextEncoder();
+  const newEntitiesData = encoder.encode(newEntitiesText);
+  const newEntitiesBuffer = new Uint8Array(newEntitiesData.length + 1);
+  newEntitiesBuffer.set(newEntitiesData);
+  newEntitiesBuffer[newEntitiesData.length] = 0;
+  const lengthDiff = newEntitiesBuffer.length - entitiesLump.length;
+  const newBspLength = bspData.length + lengthDiff;
+  const newBsp = new Uint8Array(newBspLength);
+  const entOffset = entitiesLump.offset;
+  const entEnd = entOffset + entitiesLump.length;
+  newBsp.set(bspData.subarray(0, entOffset), 0);
+  newBsp.set(newEntitiesBuffer, entOffset);
+  if (entEnd < bspData.length) {
+    newBsp.set(bspData.subarray(entEnd), entOffset + newEntitiesBuffer.length);
+  }
+  const view = new DataView(newBsp.buffer);
+  view.setInt32(8, entOffset, true);
+  view.setInt32(12, newEntitiesBuffer.length, true);
+  for (let i = 0; i < 19; i++) {
+    if (i === LUMP_ENTITIES) continue;
+    const originalOffset = lumps[i].offset;
+    if (originalOffset >= entEnd) {
+      const newOffset = originalOffset + lengthDiff;
+      view.setInt32(4 + 4 + i * 8, newOffset, true);
+    }
+  }
+  return newBsp;
+}
+
 // src/index.ts
 function describeAsset(name, origin) {
   return { name, origin };
@@ -172,6 +1139,7 @@ function describeAsset(name, origin) {
 export {
   describeAsset,
   exportMd2ToObj,
-  exportMd3ToGltf
+  exportMd3ToGltf,
+  replaceBspEntities
 };
 //# sourceMappingURL=index.js.map