quake2ts 0.0.7 → 0.0.39

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

@@ -1,8 +1,258 @@
 // ../shared/dist/esm/index.js
 var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 var DEG_TO_RAD = Math.PI / 180;
+function addVec3(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function subtractVec3(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function scaleVec3(a, scalar) {
+  return { x: a.x * scalar, y: a.y * scalar, z: a.z * scalar };
+}
+function dotVec3(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthSquaredVec3(a) {
+  return dotVec3(a, a);
+}
+function lengthVec3(a) {
+  return Math.sqrt(lengthSquaredVec3(a));
+}
+function normalizeVec3(a) {
+  const len = lengthVec3(a);
+  return len === 0 ? a : scaleVec3(a, 1 / len);
+}
+function closestPointToBox(point, mins, maxs) {
+  return {
+    x: point.x < mins.x ? mins.x : point.x > maxs.x ? maxs.x : point.x,
+    y: point.y < mins.y ? mins.y : point.y > maxs.y ? maxs.y : point.y,
+    z: point.z < mins.z ? mins.z : point.z > maxs.z ? maxs.z : point.z
+  };
+}
+function distanceBetweenBoxesSquared(aMins, aMaxs, bMins, bMaxs) {
+  let lengthSq = 0;
+  if (aMaxs.x < bMins.x) {
+    const d = aMaxs.x - bMins.x;
+    lengthSq += d * d;
+  } else if (aMins.x > bMaxs.x) {
+    const d = aMins.x - bMaxs.x;
+    lengthSq += d * d;
+  }
+  if (aMaxs.y < bMins.y) {
+    const d = aMaxs.y - bMins.y;
+    lengthSq += d * d;
+  } else if (aMins.y > bMaxs.y) {
+    const d = aMins.y - bMaxs.y;
+    lengthSq += d * d;
+  }
+  if (aMaxs.z < bMins.z) {
+    const d = aMaxs.z - bMins.z;
+    lengthSq += d * d;
+  } else if (aMins.z > bMaxs.z) {
+    const d = aMins.z - bMaxs.z;
+    lengthSq += d * d;
+  }
+  return lengthSq;
+}
+function boxesIntersect(a, b) {
+  return a.mins.x <= b.maxs.x && a.maxs.x >= b.mins.x && a.mins.y <= b.maxs.y && a.maxs.y >= b.mins.y && a.mins.z <= b.maxs.z && a.maxs.z >= b.mins.z;
+}
+var PITCH = 0;
+var YAW = 1;
+var ROLL = 2;
 var DEG2RAD_FACTOR = Math.PI / 180;
 var RAD2DEG_FACTOR = 180 / Math.PI;
+function axisComponent(vec, axis) {
+  switch (axis) {
+    case PITCH:
+      return vec.x;
+    case YAW:
+      return vec.y;
+    case ROLL:
+    default:
+      return vec.z;
+  }
+}
+function degToRad(degrees) {
+  return degrees * DEG2RAD_FACTOR;
+}
+function radToDeg(radians) {
+  return radians * RAD2DEG_FACTOR;
+}
+function angleMod(angle) {
+  const value = angle % 360;
+  return value < 0 ? 360 + value : value;
+}
+function angleVectors(angles) {
+  const yaw = degToRad(axisComponent(angles, YAW));
+  const pitch = degToRad(axisComponent(angles, PITCH));
+  const roll = degToRad(axisComponent(angles, ROLL));
+  const sy = Math.sin(yaw);
+  const cy = Math.cos(yaw);
+  const sp = Math.sin(pitch);
+  const cp = Math.cos(pitch);
+  const sr = Math.sin(roll);
+  const cr = Math.cos(roll);
+  const forward = {
+    x: cp * cy,
+    y: cp * sy,
+    z: -sp
+  };
+  const right = {
+    x: -sr * sp * cy - cr * -sy,
+    y: -sr * sp * sy - cr * cy,
+    z: -sr * cp
+  };
+  const up = {
+    x: cr * sp * cy - sr * -sy,
+    y: cr * sp * sy - sr * cy,
+    z: cr * cp
+  };
+  return { forward, right, up };
+}
+function vectorToYaw(vec) {
+  const pitch = axisComponent(vec, PITCH);
+  const yawAxis = axisComponent(vec, YAW);
+  if (pitch === 0) {
+    if (yawAxis === 0) {
+      return 0;
+    }
+    return yawAxis > 0 ? 90 : 270;
+  }
+  const yaw = radToDeg(Math.atan2(yawAxis, pitch));
+  return yaw < 0 ? yaw + 360 : yaw;
+}
+var STATE_SIZE = 624;
+var MIDDLE_WORD = 397;
+var MATRIX_A = 2567483615;
+var UPPER_MASK = 2147483648;
+var LOWER_MASK = 2147483647;
+var TWO_POW_32 = 4294967296;
+var MersenneTwister19937 = class {
+  constructor(seed = 5489) {
+    this.state = new Uint32Array(STATE_SIZE);
+    this.index = STATE_SIZE;
+    this.seed(seed);
+  }
+  seed(seed) {
+    this.state[0] = seed >>> 0;
+    for (let i = 1; i < STATE_SIZE; i++) {
+      const prev = this.state[i - 1] ^ this.state[i - 1] >>> 30;
+      const next = Math.imul(prev >>> 0, 1812433253) + i;
+      this.state[i] = next >>> 0;
+    }
+    this.index = STATE_SIZE;
+  }
+  nextUint32() {
+    if (this.index >= STATE_SIZE) {
+      this.twist();
+    }
+    let y = this.state[this.index++];
+    y ^= y >>> 11;
+    y ^= y << 7 & 2636928640;
+    y ^= y << 15 & 4022730752;
+    y ^= y >>> 18;
+    return y >>> 0;
+  }
+  twist() {
+    for (let i = 0; i < STATE_SIZE; i++) {
+      const y = this.state[i] & UPPER_MASK | this.state[(i + 1) % STATE_SIZE] & LOWER_MASK;
+      let next = this.state[(i + MIDDLE_WORD) % STATE_SIZE] ^ y >>> 1;
+      if ((y & 1) !== 0) {
+        next ^= MATRIX_A;
+      }
+      this.state[i] = next >>> 0;
+    }
+    this.index = 0;
+  }
+  getState() {
+    return {
+      index: this.index,
+      state: Array.from(this.state)
+    };
+  }
+  setState(snapshot) {
+    if (snapshot.state.length !== STATE_SIZE) {
+      throw new Error(`Expected ${STATE_SIZE} MT state values, received ${snapshot.state.length}`);
+    }
+    this.index = snapshot.index;
+    this.state = Uint32Array.from(snapshot.state, (value) => value >>> 0);
+  }
+};
+var RandomGenerator = class {
+  constructor(options = {}) {
+    this.mt = new MersenneTwister19937(options.seed);
+  }
+  /** Uniform float in [0, 1). */
+  frandom() {
+    return this.mt.nextUint32() / TWO_POW_32;
+  }
+  /** Uniform float in [min, max). */
+  frandomRange(minInclusive, maxExclusive) {
+    return minInclusive + (maxExclusive - minInclusive) * this.frandom();
+  }
+  /** Uniform float in [0, max). */
+  frandomMax(maxExclusive) {
+    return this.frandomRange(0, maxExclusive);
+  }
+  /** Uniform float in [-1, 1). */
+  crandom() {
+    return this.frandomRange(-1, 1);
+  }
+  /** Uniform float in (-1, 1). */
+  crandomOpen() {
+    const epsilon = Number.EPSILON;
+    return this.frandomRange(-1 + epsilon, 1);
+  }
+  /** Raw uint32 sample. */
+  irandomUint32() {
+    return this.mt.nextUint32();
+  }
+  /** Uniform integer in [min, max). */
+  irandomRange(minInclusive, maxExclusive) {
+    if (maxExclusive - minInclusive <= 1) {
+      return minInclusive;
+    }
+    const span = maxExclusive - minInclusive;
+    const limit = TWO_POW_32 - TWO_POW_32 % span;
+    let sample;
+    do {
+      sample = this.mt.nextUint32();
+    } while (sample >= limit);
+    return minInclusive + sample % span;
+  }
+  /** Uniform integer in [0, max). */
+  irandom(maxExclusive) {
+    if (maxExclusive <= 0) {
+      return 0;
+    }
+    return this.irandomRange(0, maxExclusive);
+  }
+  /** Uniform time in milliseconds [min, max). */
+  randomTimeRange(minMs, maxMs) {
+    if (maxMs <= minMs) {
+      return minMs;
+    }
+    return this.irandomRange(minMs, maxMs);
+  }
+  /** Uniform time in milliseconds [0, max). */
+  randomTime(maxMs) {
+    return this.irandom(maxMs);
+  }
+  randomIndex(container) {
+    return this.irandom(container.length);
+  }
+  getState() {
+    return { mt: this.mt.getState() };
+  }
+  setState(snapshot) {
+    this.mt.setState(snapshot.mt);
+  }
+};
+function createRandomGenerator(options) {
+  return new RandomGenerator(options);
+}
 var CONTENTS_SOLID = 1 << 0;
 var CONTENTS_WINDOW = 1 << 1;
 var CONTENTS_AUX = 1 << 2;
@@ -55,6 +305,16 @@ 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 CvarFlags = /* @__PURE__ */ ((CvarFlags2) => {
+  CvarFlags2[CvarFlags2["None"] = 0] = "None";
+  CvarFlags2[CvarFlags2["Archive"] = 1] = "Archive";
+  CvarFlags2[CvarFlags2["UserInfo"] = 2] = "UserInfo";
+  CvarFlags2[CvarFlags2["ServerInfo"] = 4] = "ServerInfo";
+  CvarFlags2[CvarFlags2["Latch"] = 8] = "Latch";
+  CvarFlags2[CvarFlags2["Cheat"] = 16] = "Cheat";
+  return CvarFlags2;
+})(CvarFlags || {});
 var MAX_CLIENTS = 256;
 var MAX_LIGHTSTYLES = 256;
 var MAX_MODELS = 8192;
@@ -91,6 +351,13 @@ var ConfigStringIndex = ((ConfigStringIndex2) => {
   return ConfigStringIndex2;
 })(ConfigStringIndex || {});
 var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
+  WaterLevel3[WaterLevel3["None"] = 0] = "None";
+  WaterLevel3[WaterLevel3["Feet"] = 1] = "Feet";
+  WaterLevel3[WaterLevel3["Waist"] = 2] = "Waist";
+  WaterLevel3[WaterLevel3["Under"] = 3] = "Under";
+  return WaterLevel3;
+})(WaterLevel || {});
 var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
 
 // src/entities/entity.ts
@@ -114,6 +381,22 @@ var Solid = /* @__PURE__ */ ((Solid2) => {
   Solid2[Solid2["Bsp"] = 3] = "Bsp";
   return Solid2;
 })(Solid || {});
+var ServerFlags = /* @__PURE__ */ ((ServerFlags2) => {
+  ServerFlags2[ServerFlags2["None"] = 0] = "None";
+  ServerFlags2[ServerFlags2["NoClient"] = 1] = "NoClient";
+  ServerFlags2[ServerFlags2["DeadMonster"] = 2] = "DeadMonster";
+  ServerFlags2[ServerFlags2["Monster"] = 4] = "Monster";
+  ServerFlags2[ServerFlags2["Player"] = 8] = "Player";
+  ServerFlags2[ServerFlags2["Bot"] = 16] = "Bot";
+  ServerFlags2[ServerFlags2["NoBots"] = 32] = "NoBots";
+  ServerFlags2[ServerFlags2["Respawning"] = 64] = "Respawning";
+  ServerFlags2[ServerFlags2["Projectile"] = 128] = "Projectile";
+  ServerFlags2[ServerFlags2["Instanced"] = 256] = "Instanced";
+  ServerFlags2[ServerFlags2["Door"] = 512] = "Door";
+  ServerFlags2[ServerFlags2["NoCull"] = 1024] = "NoCull";
+  ServerFlags2[ServerFlags2["Hull"] = 2048] = "Hull";
+  return ServerFlags2;
+})(ServerFlags || {});
 var DeadFlag = /* @__PURE__ */ ((DeadFlag2) => {
   DeadFlag2[DeadFlag2["Alive"] = 0] = "Alive";
   DeadFlag2[DeadFlag2["Dying"] = 1] = "Dying";
@@ -125,6 +408,7 @@ var ZERO = { ...ZERO_VEC3 };
 function copyVec3() {
   return { ...ZERO };
 }
+var DEFAULT_MONSTER_INFO = Object.freeze({ aiflags: 0 });
 var Entity = class {
   constructor(index) {
     this.inUse = false;
@@ -133,17 +417,20 @@ var Entity = class {
     this.linkNext = null;
     this.classname = "";
     this.spawnflags = 0;
+    this.inventory = {};
     this.origin = copyVec3();
     this.old_origin = copyVec3();
     this.velocity = copyVec3();
     this.avelocity = copyVec3();
     this.angles = copyVec3();
+    this.viewheight = 0;
     this.mins = copyVec3();
     this.maxs = copyVec3();
     this.size = copyVec3();
     this.mass = 0;
     this.gravity = 1;
     this.movetype = 0 /* None */;
+    this.movedir = copyVec3();
     this.modelindex = 0;
     this.frame = 0;
     this.skin = 0;
@@ -153,20 +440,35 @@ var Entity = class {
     this.max_health = 0;
     this.takedamage = false;
     this.dmg = 0;
+    this.speed = 0;
     this.deadflag = 0 /* Alive */;
+    this.count = 0;
+    this.wait = 0;
+    this.delay = 0;
+    this.timestamp = 0;
+    this.sounds = 0;
+    this.noise_index = 0;
+    this.fly_sound_debounce_time = 0;
     this.enemy = null;
     this.movetarget = null;
+    this.target_ent = null;
     this.goalentity = null;
     this.ideal_yaw = 0;
     this.yaw_speed = 0;
+    this.search_time = 0;
+    this.attack_finished_time = 0;
+    this.pain_finished_time = 0;
+    this.trail_time = 0;
     this.groundentity = null;
     this.groundentity_linkcount = 0;
     this.waterlevel = 0;
     this.watertype = 0;
     this.nextthink = 0;
+    this.activator = null;
     this.solid = 0 /* Not */;
     this.flags = 0;
     this.svflags = 0;
+    this.monsterinfo = { ...DEFAULT_MONSTER_INFO };
     this.index = index;
   }
   reset() {
@@ -178,19 +480,26 @@ var Entity = class {
     this.spawnflags = 0;
     this.target = void 0;
     this.targetname = void 0;
+    this.killtarget = void 0;
     this.team = void 0;
     this.message = void 0;
+    this.pathtarget = void 0;
+    this.model = void 0;
+    this.item = void 0;
+    this.inventory = {};
     this.origin = copyVec3();
     this.old_origin = copyVec3();
     this.velocity = copyVec3();
     this.avelocity = copyVec3();
     this.angles = copyVec3();
+    this.viewheight = 0;
     this.mins = copyVec3();
     this.maxs = copyVec3();
     this.size = copyVec3();
     this.mass = 0;
     this.gravity = 1;
     this.movetype = 0 /* None */;
+    this.movedir = copyVec3();
     this.modelindex = 0;
     this.frame = 0;
     this.skin = 0;
@@ -200,12 +509,25 @@ var Entity = class {
     this.max_health = 0;
     this.takedamage = false;
     this.dmg = 0;
+    this.speed = 0;
     this.deadflag = 0 /* Alive */;
+    this.count = 0;
+    this.wait = 0;
+    this.delay = 0;
+    this.timestamp = 0;
+    this.sounds = 0;
+    this.noise_index = 0;
+    this.fly_sound_debounce_time = 0;
     this.enemy = null;
     this.movetarget = null;
+    this.target_ent = null;
     this.goalentity = null;
     this.ideal_yaw = 0;
     this.yaw_speed = 0;
+    this.search_time = 0;
+    this.attack_finished_time = 0;
+    this.pain_finished_time = 0;
+    this.trail_time = 0;
     this.groundentity = null;
     this.groundentity_linkcount = 0;
     this.waterlevel = 0;
@@ -216,9 +538,11 @@ var Entity = class {
     this.use = void 0;
     this.pain = void 0;
     this.die = void 0;
+    this.activator = null;
     this.solid = 0 /* Not */;
     this.flags = 0;
     this.svflags = 0;
+    this.monsterinfo = { ...DEFAULT_MONSTER_INFO };
   }
 };
 var ENTITY_FIELD_METADATA = [
@@ -226,19 +550,26 @@ var ENTITY_FIELD_METADATA = [
   { name: "spawnflags", type: "int", save: true },
   { name: "target", type: "string", save: true },
   { name: "targetname", type: "string", save: true },
+  { name: "killtarget", type: "string", save: true },
   { name: "team", type: "string", save: true },
   { name: "message", type: "string", save: true },
+  { name: "pathtarget", type: "string", save: true },
+  { name: "model", type: "string", save: true },
+  { name: "item", type: "string", save: true },
+  { name: "inventory", type: "inventory", save: true },
   { name: "origin", type: "vec3", save: true },
   { name: "old_origin", type: "vec3", save: true },
   { name: "velocity", type: "vec3", save: true },
   { name: "avelocity", type: "vec3", save: true },
   { name: "angles", type: "vec3", save: true },
+  { name: "viewheight", type: "int", save: true },
   { name: "mins", type: "vec3", save: true },
   { name: "maxs", type: "vec3", save: true },
   { name: "size", type: "vec3", save: true },
   { name: "mass", type: "int", save: true },
   { name: "gravity", type: "float", save: true },
   { name: "movetype", type: "int", save: true },
+  { name: "movedir", type: "vec3", save: true },
   { name: "modelindex", type: "int", save: true },
   { name: "frame", type: "int", save: true },
   { name: "skin", type: "int", save: true },
@@ -248,12 +579,25 @@ var ENTITY_FIELD_METADATA = [
   { name: "max_health", type: "int", save: true },
   { name: "takedamage", type: "boolean", save: true },
   { name: "dmg", type: "int", save: true },
+  { name: "speed", type: "float", save: true },
   { name: "deadflag", type: "int", save: true },
+  { name: "count", type: "int", save: true },
+  { name: "wait", type: "float", save: true },
+  { name: "delay", type: "float", save: true },
+  { name: "timestamp", type: "float", save: true },
+  { name: "sounds", type: "int", save: true },
+  { name: "noise_index", type: "int", save: true },
+  { name: "fly_sound_debounce_time", type: "float", save: true },
   { name: "enemy", type: "entity", save: true },
   { name: "movetarget", type: "entity", save: true },
+  { name: "target_ent", type: "entity", save: true },
   { name: "goalentity", type: "entity", save: true },
   { name: "ideal_yaw", type: "float", save: true },
   { name: "yaw_speed", type: "float", save: true },
+  { name: "search_time", type: "float", save: true },
+  { name: "attack_finished_time", type: "float", save: true },
+  { name: "pain_finished_time", type: "float", save: true },
+  { name: "trail_time", type: "float", save: true },
   { name: "groundentity", type: "entity", save: true },
   { name: "groundentity_linkcount", type: "int", save: true },
   { name: "waterlevel", type: "int", save: true },
@@ -341,6 +685,17 @@ var EntityPool = class {
     entity.freePending = true;
     this.pendingFree.push(entity.index);
   }
+  freeImmediate(entity) {
+    if (entity.index === WORLD_INDEX) {
+      throw new Error("Cannot free world entity");
+    }
+    if (!entity.inUse) {
+      return;
+    }
+    this.unlink(entity);
+    entity.reset();
+    this.freeList.push(entity.index);
+  }
   flushFreeList() {
     if (this.pendingFree.length === 0) {
       return;
@@ -352,6 +707,69 @@ var EntityPool = class {
     }
     this.pendingFree.length = 0;
   }
+  createSnapshot() {
+    const activeOrder = Array.from(this, (entity) => entity.index);
+    return {
+      capacity: this.entities.length,
+      activeOrder,
+      freeList: [...this.freeList],
+      pendingFree: [...this.pendingFree]
+    };
+  }
+  restore(snapshot) {
+    if (snapshot.capacity !== this.entities.length) {
+      throw new Error(`Snapshot capacity ${snapshot.capacity} does not match pool capacity ${this.entities.length}`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const noteIndex = (index, label) => {
+      if (index < 0 || index >= this.entities.length) {
+        throw new Error(`Invalid entity index ${index} in ${label}`);
+      }
+      if (seen.has(index)) {
+        throw new Error(`Duplicate entity index ${index} in snapshot`);
+      }
+      seen.add(index);
+    };
+    for (const index of snapshot.activeOrder) {
+      noteIndex(index, "activeOrder");
+    }
+    for (const index of snapshot.freeList) {
+      noteIndex(index, "freeList");
+    }
+    for (const index of snapshot.pendingFree) {
+      noteIndex(index, "pendingFree");
+    }
+    this.activeHead = null;
+    this.freeList.length = 0;
+    this.pendingFree.length = 0;
+    for (const entity of this.entities) {
+      entity.reset();
+    }
+    for (let i = snapshot.activeOrder.length - 1; i >= 0; i -= 1) {
+      const entity = this.entities[snapshot.activeOrder[i]];
+      entity.inUse = true;
+      this.link(entity);
+    }
+    for (const index of snapshot.pendingFree) {
+      const entity = this.entities[index];
+      entity.inUse = false;
+      entity.freePending = true;
+      entity.linkNext = null;
+      entity.linkPrevious = null;
+      this.pendingFree.push(index);
+    }
+    for (const index of snapshot.freeList) {
+      const entity = this.entities[index];
+      entity.inUse = false;
+      entity.freePending = false;
+      entity.linkNext = null;
+      entity.linkPrevious = null;
+      this.freeList.push(index);
+    }
+    if (!snapshot.activeOrder.includes(WORLD_INDEX)) {
+      throw new Error("Snapshot must include the world entity as active");
+    }
+  }
   link(entity) {
     entity.linkNext = this.activeHead;
     if (this.activeHead) {
@@ -395,6 +813,19 @@ var ThinkScheduler = class {
       }
     }
   }
+  snapshot() {
+    return this.queue.map(({ time, entity }) => ({ time, entityIndex: entity.index }));
+  }
+  restore(entries, resolver) {
+    this.queue.length = 0;
+    for (const entry of entries) {
+      const entity = resolver(entry.entityIndex);
+      if (!entity) {
+        continue;
+      }
+      this.schedule(entity, entry.time);
+    }
+  }
   runDueThinks(currentTimeSeconds) {
     while (this.queue.length > 0) {
       const next = this.queue[0];
@@ -435,8 +866,41 @@ function computeBounds(entity) {
 function boundsIntersect(a, b) {
   return !(a.min.x > b.max.x || a.max.x < b.min.x || a.min.y > b.max.y || a.max.y < b.min.y || a.min.z > b.max.z || a.max.z < b.min.z);
 }
+var SERIALIZABLE_FIELDS = ENTITY_FIELD_METADATA.filter(
+  (field) => field.save
+);
+var DESCRIPTORS = new Map(SERIALIZABLE_FIELDS.map((descriptor) => [descriptor.name, descriptor]));
+function serializeVec3(vec) {
+  return [vec.x, vec.y, vec.z];
+}
+function deserializeVec3(value) {
+  const vec = value;
+  if (!Array.isArray(vec) || vec.length !== 3) {
+    throw new Error("Invalid vec3 serialization");
+  }
+  const [x, y, z] = vec;
+  return { x, y, z };
+}
+function assignField(entity, name, value) {
+  entity[name] = value;
+}
+function serializeInventory(inventory) {
+  return { ...inventory };
+}
+function deserializeInventory(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid inventory serialization");
+  }
+  const parsed = {};
+  for (const [key, entry] of Object.entries(value)) {
+    parsed[key] = Number(entry);
+  }
+  return parsed;
+}
 var EntitySystem = class {
   constructor(maxEntities) {
+    this.targetNameIndex = /* @__PURE__ */ new Map();
+    this.random = createRandomGenerator();
     this.currentTimeSeconds = 0;
     this.pool = new EntityPool(maxEntities);
     this.thinkScheduler = new ThinkScheduler();
@@ -459,20 +923,175 @@ var EntitySystem = class {
     return this.pool.spawn();
   }
   free(entity) {
+    this.unregisterTarget(entity);
     this.thinkScheduler.cancel(entity);
     this.pool.deferFree(entity);
   }
+  freeImmediate(entity) {
+    this.unregisterTarget(entity);
+    this.thinkScheduler.cancel(entity);
+    this.pool.freeImmediate(entity);
+  }
   scheduleThink(entity, nextThinkSeconds) {
     this.thinkScheduler.schedule(entity, nextThinkSeconds);
   }
   beginFrame(timeSeconds) {
     this.currentTimeSeconds = timeSeconds;
   }
+  finalizeSpawn(entity) {
+    if (!entity.inUse || entity.freePending) {
+      return;
+    }
+    this.registerTarget(entity);
+  }
+  findByClassname(classname) {
+    const matches = [];
+    for (const entity of this.pool) {
+      if (entity.classname === classname && entity.inUse && !entity.freePending) {
+        matches.push(entity);
+      }
+    }
+    return matches;
+  }
+  findByTargetName(targetname) {
+    const matches = this.targetNameIndex.get(targetname);
+    if (!matches) {
+      return [];
+    }
+    return Array.from(matches).filter((entity) => entity.inUse && !entity.freePending);
+  }
+  pickTarget(targetname) {
+    if (!targetname) {
+      return null;
+    }
+    const matches = this.findByTargetName(targetname);
+    if (matches.length === 0) {
+      return null;
+    }
+    const choice = this.random.randomIndex(matches);
+    return matches[choice] ?? null;
+  }
+  killBox(entity) {
+    const targetBounds = computeBounds(entity);
+    for (const other of this.pool) {
+      if (other === entity || other === this.pool.world) {
+        continue;
+      }
+      if (!other.inUse || other.freePending || other.solid === 0 /* Not */) {
+        continue;
+      }
+      if (other.svflags & 2 /* DeadMonster */) {
+        continue;
+      }
+      if (!boundsIntersect(targetBounds, computeBounds(other))) {
+        continue;
+      }
+      other.health = 0;
+      other.deadflag = 2 /* Dead */;
+      this.free(other);
+    }
+  }
+  useTargets(entity, activator = null) {
+    if (entity.delay > 0) {
+      const delayed = this.spawn();
+      delayed.classname = "DelayedUse";
+      delayed.target = entity.target;
+      delayed.killtarget = entity.killtarget;
+      delayed.message = entity.message;
+      delayed.think = (self) => {
+        this.useTargetsImmediate(self, activator ?? entity);
+        this.free(self);
+      };
+      this.scheduleThink(delayed, this.currentTimeSeconds + entity.delay);
+      return;
+    }
+    this.useTargetsImmediate(entity, activator ?? entity);
+  }
   runFrame() {
     this.thinkScheduler.runDueThinks(this.currentTimeSeconds);
     this.runTouches();
     this.pool.flushFreeList();
   }
+  createSnapshot() {
+    const entities = [];
+    for (const entity of this.pool) {
+      const fields = {};
+      for (const descriptor of SERIALIZABLE_FIELDS) {
+        const value = entity[descriptor.name];
+        switch (descriptor.type) {
+          case "vec3":
+            fields[descriptor.name] = serializeVec3(value);
+            break;
+          case "entity":
+            fields[descriptor.name] = value?.index ?? null;
+            break;
+          case "inventory":
+            fields[descriptor.name] = serializeInventory(value);
+            break;
+          default:
+            fields[descriptor.name] = value ?? null;
+            break;
+        }
+      }
+      entities.push({
+        index: entity.index,
+        fields
+      });
+    }
+    return {
+      timeSeconds: this.currentTimeSeconds,
+      pool: this.pool.createSnapshot(),
+      entities,
+      thinks: this.thinkScheduler.snapshot()
+    };
+  }
+  restore(snapshot) {
+    this.currentTimeSeconds = snapshot.timeSeconds;
+    this.pool.restore(snapshot.pool);
+    const indexToEntity = /* @__PURE__ */ new Map();
+    for (const entity of this.pool) {
+      indexToEntity.set(entity.index, entity);
+    }
+    const pendingEntityRefs = [];
+    for (const serialized of snapshot.entities) {
+      const entity = indexToEntity.get(serialized.index);
+      if (!entity) {
+        continue;
+      }
+      for (const [name, value] of Object.entries(serialized.fields)) {
+        const descriptor = DESCRIPTORS.get(name);
+        if (!descriptor || value === void 0) {
+          continue;
+        }
+        switch (descriptor.type) {
+          case "vec3":
+            assignField(entity, name, deserializeVec3(value));
+            break;
+          case "entity":
+            pendingEntityRefs.push({
+              entity,
+              name: descriptor.name,
+              targetIndex: value
+            });
+            break;
+          case "inventory":
+            assignField(entity, name, deserializeInventory(value));
+            break;
+          case "boolean":
+            assignField(entity, name, Boolean(value));
+            break;
+          default:
+            assignField(entity, name, value);
+            break;
+        }
+      }
+    }
+    for (const ref of pendingEntityRefs) {
+      const target = ref.targetIndex === null ? null : indexToEntity.get(ref.targetIndex) ?? null;
+      assignField(ref.entity, ref.name, target);
+    }
+    this.thinkScheduler.restore(snapshot.thinks, (index) => indexToEntity.get(index));
+  }
   runTouches() {
     const world = this.pool.world;
     const activeEntities = [];
@@ -480,7 +1099,7 @@ var EntitySystem = class {
       if (entity === world) {
         continue;
       }
-      if (!entity.inUse || entity.freePending) {
+      if (!entity.inUse || entity.freePending || entity.solid === 0 /* Not */) {
         continue;
       }
       activeEntities.push(entity);
@@ -509,113 +1128,904 @@ var EntitySystem = class {
       }
     }
   }
-};
-
-// src/loop.ts
-var orderedStageNames = [
-  "prep",
-  "simulate",
-  "finish"
-];
-var GameFrameLoop = class {
-  constructor(initialStages) {
-    this.timeMs = 0;
-    this.frame = 0;
-    this.stageHandlers = {
-      prep: [],
-      simulate: [],
-      finish: []
-    };
-    this.stageCounts = {
-      prep: 0,
-      simulate: 0,
-      finish: 0
-    };
-    this.stageCompactionNeeded = {
-      prep: false,
-      simulate: false,
-      finish: false
-    };
-    if (initialStages) {
-      for (const stageName of orderedStageNames) {
-        const handler = initialStages[stageName];
-        if (handler) {
-          this.addStage(stageName, handler);
-        }
-      }
+  registerTarget(entity) {
+    if (!entity.targetname) {
+      return;
     }
-  }
-  addStage(stage, handler) {
-    const handlers = this.stageHandlers[stage];
-    handlers.push(handler);
-    this.stageCounts[stage] += 1;
-    return () => {
-      const index = handlers.indexOf(handler);
-      if (index >= 0 && handlers[index]) {
-        handlers[index] = void 0;
-        this.stageCounts[stage] -= 1;
-        this.stageCompactionNeeded[stage] = true;
-      }
-    };
-  }
-  reset(startTimeMs) {
-    this.timeMs = startTimeMs;
-    this.frame = 0;
-  }
-  advance(step) {
-    const previousTimeMs = this.timeMs;
-    this.timeMs = previousTimeMs + step.deltaMs;
-    this.frame = step.frame;
-    const context = {
-      ...step,
-      timeMs: this.timeMs,
-      previousTimeMs,
-      deltaSeconds: step.deltaMs / 1e3
-    };
-    this.runStage("prep", context);
-    if (this.stageCounts.simulate === 0) {
-      throw new Error("GameFrameLoop requires at least one simulate stage");
+    let bucket = this.targetNameIndex.get(entity.targetname);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this.targetNameIndex.set(entity.targetname, bucket);
     }
-    this.runStage("simulate", context);
-    this.runStage("finish", context);
-    return context;
+    bucket.add(entity);
   }
-  runStage(stage, context) {
-    const handlers = this.stageHandlers[stage];
-    for (let i = 0; i < handlers.length; i += 1) {
-      const handler = handlers[i];
-      if (!handler) {
-        continue;
-      }
-      handler(context);
+  unregisterTarget(entity) {
+    if (!entity.targetname) {
+      return;
     }
-    if (this.stageCompactionNeeded[stage]) {
-      this.compactStageHandlers(stage);
+    const bucket = this.targetNameIndex.get(entity.targetname);
+    if (!bucket) {
+      return;
+    }
+    bucket.delete(entity);
+    if (bucket.size === 0) {
+      this.targetNameIndex.delete(entity.targetname);
     }
   }
-  compactStageHandlers(stage) {
-    const handlers = this.stageHandlers[stage];
-    let writeIndex = 0;
-    for (let readIndex = 0; readIndex < handlers.length; readIndex += 1) {
-      const handler = handlers[readIndex];
-      if (handler) {
-        handlers[writeIndex] = handler;
-        writeIndex += 1;
+  useTargetsImmediate(entity, activator) {
+    if (entity.target) {
+      for (const target of this.findByTargetName(entity.target)) {
+        if (target === entity) {
+          continue;
+        }
+        target.use?.(target, entity, activator);
+      }
+    }
+    if (entity.killtarget) {
+      for (const victim of this.findByTargetName(entity.killtarget)) {
+        if (victim === entity) {
+          continue;
+        }
+        this.free(victim);
       }
     }
-    handlers.length = writeIndex;
-    this.stageCompactionNeeded[stage] = false;
-  }
-  get time() {
-    return this.timeMs;
-  }
-  get frameNumber() {
-    return this.frame;
   }
 };
 
-// src/level.ts
-var ZERO_STATE = {
+// src/entities/utils.ts
+var VEC_UP = { x: 0, y: -1, z: 0 };
+var MOVEDIR_UP = { x: 0, y: 0, z: 1 };
+var VEC_DOWN = { x: 0, y: -2, z: 0 };
+var MOVEDIR_DOWN = { x: 0, y: 0, z: -1 };
+function vecEquals(a, b) {
+  return a.x === b.x && a.y === b.y && a.z === b.z;
+}
+function isZeroVector(vector) {
+  return vecEquals(vector, ZERO_VEC3);
+}
+function setMovedir(angles) {
+  if (vecEquals(angles, VEC_UP)) {
+    return { ...MOVEDIR_UP };
+  }
+  if (vecEquals(angles, VEC_DOWN)) {
+    return { ...MOVEDIR_DOWN };
+  }
+  return { ...angleVectors(angles).forward };
+}
+
+// src/entities/triggers.ts
+var FRAME_TIME_SECONDS = 1 / 40;
+var THINK_INTERVAL = 0.1;
+var HURT_INTERVAL = 0.1;
+var TRIGGER_SPAWNFLAGS = {
+  Monster: 1 << 0,
+  NotPlayer: 1 << 1,
+  Triggered: 1 << 2,
+  Toggle: 1 << 3,
+  Latched: 1 << 4,
+  Clip: 1 << 5
+};
+var RELAY_SPAWNFLAGS = {
+  NoSound: 1 << 0
+};
+var COUNTER_SPAWNFLAGS = {
+  NoMessage: 1 << 0
+};
+var PUSH_SPAWNFLAGS = {
+  Once: 1 << 0,
+  Plus: 1 << 1,
+  Silent: 1 << 2,
+  StartOff: 1 << 3,
+  Clip: 1 << 4
+};
+var HURT_SPAWNFLAGS = {
+  StartOff: 1 << 0,
+  Toggle: 1 << 1,
+  Silent: 1 << 2,
+  NoProtection: 1 << 3,
+  Slow: 1 << 4,
+  NoPlayers: 1 << 5,
+  NoMonsters: 1 << 6,
+  Clip: 1 << 7
+};
+var TELEPORT_SPAWNFLAGS = {
+  StartOn: 1 << 3
+};
+var GRAVITY_SPAWNFLAGS = {
+  Toggle: 1 << 0,
+  StartOff: 1 << 1,
+  Clip: 1 << 2
+};
+var MONSTERJUMP_SPAWNFLAGS = {
+  Toggle: 1 << 0,
+  StartOff: 1 << 1,
+  Clip: 1 << 2
+};
+function trainResume(train, entities) {
+  if (!train.think) {
+    train.think = (self) => {
+      self.nextthink = 0;
+    };
+  }
+  entities.scheduleThink(train, entities.timeSeconds + FRAME_TIME_SECONDS);
+}
+function initTrigger(entity) {
+  entity.movetype = 0 /* None */;
+  entity.solid = 1 /* Trigger */;
+  entity.svflags |= 1 /* NoClient */;
+  entity.movedir = setMovedir(entity.angles);
+  entity.angles = { x: 0, y: 0, z: 0 };
+}
+function multiWait(self) {
+  self.nextthink = 0;
+  self.think = void 0;
+}
+function canActivate(trigger, other) {
+  if (trigger.solid === 0 /* Not */) {
+    return false;
+  }
+  if (other.svflags & 8 /* Player */) {
+    if (trigger.spawnflags & TRIGGER_SPAWNFLAGS.NotPlayer) {
+      return false;
+    }
+  } else if (other.svflags & 4 /* Monster */) {
+    if ((trigger.spawnflags & TRIGGER_SPAWNFLAGS.Monster) === 0) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+  if (!isZeroVector(trigger.movedir)) {
+    const forward = angleVectors(other.angles).forward;
+    const dot = forward.x * trigger.movedir.x + forward.y * trigger.movedir.y + forward.z * trigger.movedir.z;
+    if (dot < 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function multiTrigger(self, entities) {
+  if (self.nextthink > entities.timeSeconds) {
+    return;
+  }
+  entities.useTargets(self, self.activator);
+  if (self.wait > 0) {
+    self.think = multiWait;
+    entities.scheduleThink(self, entities.timeSeconds + self.wait);
+  } else {
+    self.touch = void 0;
+    self.think = (entity) => {
+      entities.free(entity);
+    };
+    entities.scheduleThink(self, entities.timeSeconds + FRAME_TIME_SECONDS);
+  }
+}
+function touchMulti(self, other, entities) {
+  if (!other) {
+    return;
+  }
+  if (!canActivate(self, other)) {
+    return;
+  }
+  self.activator = other;
+  multiTrigger(self, entities);
+}
+function useMulti(self, _other, activator, entities) {
+  if (self.spawnflags & TRIGGER_SPAWNFLAGS.Toggle) {
+    self.solid = self.solid === 1 /* Trigger */ ? 0 /* Not */ : 1 /* Trigger */;
+    return;
+  }
+  self.activator = activator;
+  multiTrigger(self, entities);
+}
+function triggerEnable(self) {
+  self.solid = 1 /* Trigger */;
+}
+function registerTriggerMultiple(registry) {
+  registry.register("trigger_multiple", (entity, context) => {
+    initTrigger(entity);
+    if (entity.wait === 0) {
+      entity.wait = 0.2;
+    }
+    if (entity.spawnflags & TRIGGER_SPAWNFLAGS.Latched) {
+    }
+    if (entity.spawnflags & (TRIGGER_SPAWNFLAGS.Triggered | TRIGGER_SPAWNFLAGS.Toggle)) {
+      entity.solid = 0 /* Not */;
+      entity.use = (self, other, activator) => {
+        triggerEnable(self);
+        useMulti(self, other, activator ?? other, context.entities);
+      };
+    } else {
+      entity.use = (self, other, activator) => useMulti(self, other, activator ?? other, context.entities);
+    }
+    entity.touch = (self, other) => touchMulti(self, other, context.entities);
+  });
+}
+function registerTriggerOnce(registry) {
+  registry.register("trigger_once", (entity, context) => {
+    entity.wait = -1;
+    registry.get("trigger_multiple")?.(entity, context);
+  });
+}
+function registerTriggerRelay(registry) {
+  registry.register("trigger_relay", (entity, context) => {
+    if (entity.spawnflags & RELAY_SPAWNFLAGS.NoSound) {
+      entity.noise_index = -1;
+    }
+    entity.use = (self, _other, activator) => {
+      context.entities.useTargets(self, activator ?? self);
+    };
+  });
+}
+function registerTriggerAlways(registry) {
+  registry.register("trigger_always", (entity, context) => {
+    if (entity.delay === 0) {
+      entity.delay = 0.2;
+    }
+    context.entities.useTargets(entity, entity);
+  });
+}
+function counterUse(self, _other, activator, entities) {
+  if (self.count === 0) {
+    return;
+  }
+  self.count -= 1;
+  if (self.count > 0) {
+    return;
+  }
+  self.activator = activator;
+  multiTrigger(self, entities);
+}
+function registerTriggerCounter(registry) {
+  registry.register("trigger_counter", (entity, context) => {
+    entity.wait = -1;
+    if (entity.count === 0) {
+      entity.count = 2;
+    }
+    entity.use = (self, other, activator) => counterUse(self, other, activator ?? other, context.entities);
+    if (!(entity.spawnflags & COUNTER_SPAWNFLAGS.NoMessage)) {
+      entity.message = entity.message ?? "sequence complete";
+    }
+  });
+}
+function triggerKeyUse(self, activator, entities, warn) {
+  if (!self.item || !activator) {
+    return;
+  }
+  const available = activator.inventory[self.item] ?? 0;
+  if (available <= 0) {
+    if (self.timestamp > entities.timeSeconds) {
+      return;
+    }
+    self.timestamp = entities.timeSeconds + 5;
+    warn(`Missing required key item: ${self.item}`);
+    return;
+  }
+  activator.inventory[self.item] = available - 1;
+  if (activator.inventory[self.item] <= 0) {
+    delete activator.inventory[self.item];
+  }
+  entities.useTargets(self, activator);
+  self.use = void 0;
+}
+function registerTriggerKey(registry) {
+  registry.register("trigger_key", (entity, context) => {
+    const requiredItem = context.keyValues.item;
+    if (!requiredItem) {
+      context.warn("trigger_key requires an item");
+      context.free(entity);
+      return;
+    }
+    entity.item = requiredItem;
+    entity.use = (self, other, activator) => triggerKeyUse(self, activator ?? other, context.entities, context.warn);
+  });
+}
+function triggerPushTouch(self, other, entities) {
+  if (!other) {
+    return;
+  }
+  if (other.classname === "grenade" || other.health > 0) {
+    const scale = (self.speed || 1e3) * 10;
+    other.velocity = {
+      x: self.movedir.x * scale,
+      y: self.movedir.y * scale,
+      z: self.movedir.z * scale
+    };
+  }
+  if (self.spawnflags & PUSH_SPAWNFLAGS.Once) {
+    entities.free(self);
+  }
+}
+function toggleSolid(self) {
+  self.solid = self.solid === 0 /* Not */ ? 1 /* Trigger */ : 0 /* Not */;
+}
+function triggerPushInactive(self, entities, touchHandler) {
+  if (self.delay > entities.timeSeconds) {
+    entities.scheduleThink(self, entities.timeSeconds + THINK_INTERVAL);
+    return;
+  }
+  self.touch = touchHandler;
+  self.think = (entity) => triggerPushActive(entity, entities, touchHandler);
+  self.delay = entities.timeSeconds + self.wait;
+  entities.scheduleThink(self, entities.timeSeconds + THINK_INTERVAL);
+}
+function triggerPushActive(self, entities, touchHandler) {
+  if (self.delay > entities.timeSeconds) {
+    entities.scheduleThink(self, entities.timeSeconds + THINK_INTERVAL);
+    return;
+  }
+  self.touch = void 0;
+  self.think = (entity) => triggerPushInactive(entity, entities, touchHandler);
+  self.delay = entities.timeSeconds + self.wait;
+  entities.scheduleThink(self, entities.timeSeconds + THINK_INTERVAL);
+}
+function registerTriggerPush(registry) {
+  registry.register("trigger_push", (entity, context) => {
+    initTrigger(entity);
+    const touchHandler = (self, other) => triggerPushTouch(self, other, context.entities);
+    entity.touch = touchHandler;
+    if (!entity.speed) {
+      entity.speed = 1e3;
+    }
+    if (entity.spawnflags & PUSH_SPAWNFLAGS.Plus) {
+      if (!entity.wait) {
+        entity.wait = 10;
+      }
+      entity.delay = context.entities.timeSeconds + entity.wait;
+      entity.think = (self) => triggerPushActive(self, context.entities, touchHandler);
+      context.entities.scheduleThink(entity, context.entities.timeSeconds + THINK_INTERVAL);
+    }
+    if (entity.targetname) {
+      entity.use = (self) => {
+        toggleSolid(self);
+        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+      };
+      if (entity.spawnflags & PUSH_SPAWNFLAGS.StartOff) {
+        entity.solid = 0 /* Not */;
+        entity.touch = void 0;
+      }
+    } else if (entity.spawnflags & PUSH_SPAWNFLAGS.StartOff) {
+      context.warn("trigger_push is START_OFF but not targeted.");
+      entity.touch = void 0;
+      entity.solid = 3 /* Bsp */;
+      entity.movetype = 2 /* Push */;
+    }
+  });
+}
+function hurtTouch(self, other, entities) {
+  if (!other) {
+    return;
+  }
+  if (!other.takedamage && other.classname !== "grenade") {
+    return;
+  }
+  if (self.spawnflags & HURT_SPAWNFLAGS.NoMonsters && other.svflags & 4 /* Monster */) {
+    return;
+  }
+  if (self.spawnflags & HURT_SPAWNFLAGS.NoPlayers && other.svflags & 8 /* Player */) {
+    return;
+  }
+  if (self.timestamp > entities.timeSeconds) {
+    return;
+  }
+  self.timestamp = entities.timeSeconds + (self.spawnflags & HURT_SPAWNFLAGS.Slow ? 1 : HURT_INTERVAL);
+  const damage = self.dmg || 5;
+  other.health -= damage;
+}
+function registerTriggerHurt(registry) {
+  registry.register("trigger_hurt", (entity, context) => {
+    initTrigger(entity);
+    entity.dmg = entity.dmg || 5;
+    const touchHandler = (self, other) => hurtTouch(self, other, context.entities);
+    entity.touch = touchHandler;
+    if (entity.spawnflags & HURT_SPAWNFLAGS.StartOff) {
+      entity.solid = 0 /* Not */;
+      entity.touch = void 0;
+    }
+    if (entity.spawnflags & HURT_SPAWNFLAGS.Toggle) {
+      entity.use = (self) => {
+        toggleSolid(self);
+        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+      };
+    }
+  });
+}
+function teleportTouch(self, other, entities, warn) {
+  if (!other) {
+    return;
+  }
+  if (self.delay > 0) {
+    return;
+  }
+  const destination = entities.pickTarget(self.target);
+  if (!destination) {
+    warn("trigger_teleport target not found");
+    return;
+  }
+  const destOrigin = {
+    x: destination.origin.x,
+    y: destination.origin.y,
+    z: destination.origin.z + 10
+  };
+  other.origin = { ...destOrigin };
+  other.old_origin = { ...destOrigin };
+  other.velocity = { x: 0, y: 0, z: 0 };
+  other.groundentity = null;
+  other.angles = { ...destination.angles };
+  entities.killBox(other);
+}
+function registerTriggerTeleport(registry) {
+  registry.register("trigger_teleport", (entity, context) => {
+    if (!entity.wait) {
+      entity.wait = 0.2;
+    }
+    initTrigger(entity);
+    if (entity.targetname) {
+      entity.use = (self) => {
+        self.delay = self.delay > 0 ? 0 : 1;
+      };
+      if ((entity.spawnflags & TELEPORT_SPAWNFLAGS.StartOn) === 0) {
+        entity.delay = 1;
+      }
+    }
+    entity.touch = (self, other) => teleportTouch(self, other, context.entities, context.warn);
+  });
+}
+function gravityTouch(self, other) {
+  if (!other) {
+    return;
+  }
+  if (self.spawnflags & GRAVITY_SPAWNFLAGS.Clip) {
+  }
+  other.gravity = self.gravity;
+}
+function registerTriggerGravity(registry) {
+  registry.register("trigger_gravity", (entity, context) => {
+    const gravityText = context.keyValues.gravity;
+    if (!gravityText) {
+      context.warn("trigger_gravity requires a gravity value");
+      context.free(entity);
+      return;
+    }
+    initTrigger(entity);
+    entity.gravity = Number.parseFloat(gravityText) || 0;
+    const touchHandler = (self, other) => gravityTouch(self, other);
+    entity.touch = touchHandler;
+    if (entity.spawnflags & GRAVITY_SPAWNFLAGS.StartOff) {
+      entity.solid = 0 /* Not */;
+      entity.touch = void 0;
+    }
+    if (entity.spawnflags & GRAVITY_SPAWNFLAGS.Toggle) {
+      entity.use = (self) => {
+        toggleSolid(self);
+        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+      };
+    }
+  });
+}
+function monsterJumpTouch(self, other) {
+  if (!other) {
+    return;
+  }
+  if ((other.flags & (1 /* Fly */ | 2 /* Swim */)) !== 0) {
+    return;
+  }
+  if (other.svflags & 2 /* DeadMonster */) {
+    return;
+  }
+  if ((other.svflags & 4 /* Monster */) === 0) {
+    return;
+  }
+  other.velocity = {
+    x: self.movedir.x * self.speed,
+    y: self.movedir.y * self.speed,
+    z: other.velocity.z
+  };
+  if (!other.groundentity) {
+    return;
+  }
+  other.groundentity = null;
+  other.velocity = { x: other.velocity.x, y: other.velocity.y, z: self.movedir.z };
+}
+function triggerElevatorUse(self, other, entities, warn) {
+  if (!self.movetarget) {
+    return;
+  }
+  if (self.movetarget.nextthink > 0) {
+    return;
+  }
+  if (!other?.pathtarget) {
+    warn("trigger_elevator used with no pathtarget");
+    return;
+  }
+  const target = entities.pickTarget(other.pathtarget);
+  if (!target) {
+    warn(`trigger_elevator used with bad pathtarget: ${other.pathtarget}`);
+    return;
+  }
+  self.movetarget.target_ent = target;
+  trainResume(self.movetarget, entities);
+}
+function triggerElevatorInit(self, entities, warn) {
+  if (!self.target) {
+    warn("trigger_elevator has no target");
+    return;
+  }
+  const target = entities.pickTarget(self.target);
+  if (!target) {
+    warn(`trigger_elevator unable to find target ${self.target}`);
+    return;
+  }
+  self.movetarget = target;
+  if (target.classname !== "func_train") {
+    warn(`trigger_elevator target ${self.target} is not a train`);
+    return;
+  }
+  self.use = (entity, other, activator) => triggerElevatorUse(entity, other ?? activator ?? null, entities, warn);
+  self.svflags |= 1 /* NoClient */;
+}
+function registerTriggerElevator(registry) {
+  registry.register("trigger_elevator", (entity, context) => {
+    entity.think = (self) => triggerElevatorInit(self, context.entities, context.warn);
+    context.entities.scheduleThink(entity, context.entities.timeSeconds + FRAME_TIME_SECONDS);
+  });
+}
+function registerTriggerMonsterJump(registry) {
+  registry.register("trigger_monsterjump", (entity, context) => {
+    const heightText = context.keyValues.height;
+    const height = heightText ? Number.parseFloat(heightText) || 0 : 200;
+    if (entity.angles.y === 0) {
+      entity.angles = { ...entity.angles, y: 360 };
+    }
+    if (!entity.speed) {
+      entity.speed = 200;
+    }
+    initTrigger(entity);
+    entity.movedir = { ...entity.movedir, z: height };
+    const touchHandler = (self, other) => monsterJumpTouch(self, other);
+    entity.touch = touchHandler;
+    if (entity.spawnflags & MONSTERJUMP_SPAWNFLAGS.StartOff) {
+      entity.solid = 0 /* Not */;
+      entity.touch = void 0;
+    }
+    if (entity.spawnflags & MONSTERJUMP_SPAWNFLAGS.Toggle) {
+      entity.use = (self) => {
+        toggleSolid(self);
+        self.touch = self.solid === 1 /* Trigger */ ? touchHandler : void 0;
+      };
+    }
+  });
+}
+function registerTriggerSpawns(registry) {
+  registerTriggerMultiple(registry);
+  registerTriggerOnce(registry);
+  registerTriggerRelay(registry);
+  registerTriggerAlways(registry);
+  registerTriggerCounter(registry);
+  registerTriggerKey(registry);
+  registerTriggerPush(registry);
+  registerTriggerHurt(registry);
+  registerTriggerTeleport(registry);
+  registerTriggerGravity(registry);
+  registerTriggerElevator(registry);
+  registerTriggerMonsterJump(registry);
+}
+
+// src/entities/spawn.ts
+var FIELD_LOOKUP = new Map(
+  ENTITY_FIELD_METADATA.map((field) => [field.name, field])
+);
+function parseVec3(text) {
+  const parts = text.trim().split(/\s+/);
+  const [x = 0, y = 0, z = 0] = parts.map((part) => Number.parseFloat(part)).map((value) => Number.isNaN(value) ? 0 : value);
+  return { x, y, z };
+}
+function parseBoolean(text) {
+  const normalized = text.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function parseValue(type, value) {
+  switch (type) {
+    case "int":
+      return Number.parseInt(value, 10) || 0;
+    case "float":
+      return Number.parseFloat(value) || 0;
+    case "boolean":
+      return parseBoolean(value);
+    case "vec3":
+      return parseVec3(value);
+    case "string":
+      return value;
+    case "entity":
+    case "callback":
+      return void 0;
+    default:
+      return value;
+  }
+}
+function applyEntityKeyValues(entity, values) {
+  if ("angle" in values && !("angles" in values)) {
+    entity.angles = { x: 0, y: Number.parseFloat(values.angle) || 0, z: 0 };
+  }
+  for (const [key, rawValue] of Object.entries(values)) {
+    if (key.startsWith("_")) {
+      continue;
+    }
+    const descriptor = FIELD_LOOKUP.get(key);
+    if (!descriptor) {
+      continue;
+    }
+    const parsed = parseValue(descriptor.type, rawValue);
+    if (parsed !== void 0) {
+      entity[descriptor.name] = parsed;
+    }
+  }
+  entity.size = {
+    x: entity.maxs.x - entity.mins.x,
+    y: entity.maxs.y - entity.mins.y,
+    z: entity.maxs.z - entity.mins.z
+  };
+}
+function parseQuoted(text, start) {
+  let index = start;
+  let result = "";
+  while (index < text.length) {
+    const char = text[index];
+    if (char === '"') {
+      return { value: result, nextIndex: index + 1 };
+    }
+    result += char;
+    index += 1;
+  }
+  throw new Error("Unterminated quoted string in entity lump");
+}
+function consumeWhitespace(text, start) {
+  let index = start;
+  while (index < text.length && /\s/.test(text[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function parseToken(text, start) {
+  const index = consumeWhitespace(text, start);
+  if (index >= text.length) {
+    return { token: null, nextIndex: index };
+  }
+  const current = text[index];
+  if (current === "{" || current === "}") {
+    return { token: current, nextIndex: index + 1 };
+  }
+  if (current !== '"') {
+    throw new Error(`Unexpected token in entity lump: ${current}`);
+  }
+  const quoted = parseQuoted(text, index + 1);
+  return { token: quoted.value, nextIndex: quoted.nextIndex };
+}
+function parseEntityLump(text) {
+  const entities = [];
+  let index = 0;
+  while (index < text.length) {
+    const open = parseToken(text, index);
+    index = open.nextIndex;
+    if (open.token === null) {
+      break;
+    }
+    if (open.token !== "{") {
+      throw new Error("Expected { at start of entity definition");
+    }
+    const entity = {};
+    while (true) {
+      const keyToken = parseToken(text, index);
+      index = keyToken.nextIndex;
+      if (keyToken.token === null) {
+        throw new Error("EOF reached while parsing entity");
+      }
+      if (keyToken.token === "}") {
+        break;
+      }
+      const valueToken = parseToken(text, index);
+      index = valueToken.nextIndex;
+      if (valueToken.token === null || valueToken.token === "{" || valueToken.token === "}") {
+        throw new Error("Malformed entity key/value pair");
+      }
+      if (!keyToken.token.startsWith("_")) {
+        entity[keyToken.token] = valueToken.token;
+      }
+    }
+    entities.push(entity);
+  }
+  return entities;
+}
+var SpawnRegistry = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
+  register(classname, spawn) {
+    this.registry.set(classname, spawn);
+  }
+  get(classname) {
+    return this.registry.get(classname);
+  }
+};
+function defaultWarn(message) {
+  void message;
+}
+function spawnEntityFromDictionary(dictionary, options) {
+  const warn = options.onWarning ?? defaultWarn;
+  const classname = dictionary.classname;
+  if (!classname) {
+    warn("Encountered entity with no classname");
+    return null;
+  }
+  const isWorld = classname === "worldspawn";
+  const entity = isWorld ? options.entities.world : options.entities.spawn();
+  applyEntityKeyValues(entity, dictionary);
+  const context = {
+    keyValues: dictionary,
+    entities: options.entities,
+    warn,
+    free(target) {
+      options.entities.freeImmediate(target);
+    }
+  };
+  const spawnFunc = options.registry.get(classname);
+  if (!spawnFunc) {
+    warn(`${classname} does not have a spawn function`);
+    if (!isWorld) {
+      options.entities.freeImmediate(entity);
+    }
+    return null;
+  }
+  spawnFunc(entity, context);
+  if (!entity.inUse) {
+    return null;
+  }
+  options.entities.finalizeSpawn(entity);
+  return entity;
+}
+function spawnEntitiesFromText(text, options) {
+  const parsed = parseEntityLump(text);
+  const spawned = [];
+  for (const dictionary of parsed) {
+    const entity = spawnEntityFromDictionary(dictionary, options);
+    if (entity) {
+      spawned.push(entity);
+    }
+  }
+  return spawned;
+}
+function registerDefaultSpawns(registry) {
+  registry.register("worldspawn", (entity) => {
+    entity.movetype = 2 /* Push */;
+    entity.solid = 3 /* Bsp */;
+    entity.modelindex = entity.modelindex || 1;
+  });
+  registry.register("info_player_start", () => {
+  });
+  registry.register("info_player_deathmatch", () => {
+  });
+  registry.register("info_player_coop", () => {
+  });
+  registry.register("info_null", (entity, context) => {
+    context.free(entity);
+  });
+  registry.register("info_notnull", () => {
+  });
+  registry.register("info_teleport_destination", () => {
+  });
+  registerTriggerSpawns(registry);
+}
+function createDefaultSpawnRegistry() {
+  const registry = new SpawnRegistry();
+  registerDefaultSpawns(registry);
+  return registry;
+}
+
+// src/loop.ts
+var orderedStageNames = [
+  "prep",
+  "simulate",
+  "finish"
+];
+var GameFrameLoop = class {
+  constructor(initialStages) {
+    this.timeMs = 0;
+    this.frame = 0;
+    this.stageHandlers = {
+      prep: [],
+      simulate: [],
+      finish: []
+    };
+    this.stageCounts = {
+      prep: 0,
+      simulate: 0,
+      finish: 0
+    };
+    this.stageCompactionNeeded = {
+      prep: false,
+      simulate: false,
+      finish: false
+    };
+    if (initialStages) {
+      for (const stageName of orderedStageNames) {
+        const handler = initialStages[stageName];
+        if (handler) {
+          this.addStage(stageName, handler);
+        }
+      }
+    }
+  }
+  addStage(stage, handler) {
+    const handlers = this.stageHandlers[stage];
+    handlers.push(handler);
+    this.stageCounts[stage] += 1;
+    return () => {
+      const index = handlers.indexOf(handler);
+      if (index >= 0 && handlers[index]) {
+        handlers[index] = void 0;
+        this.stageCounts[stage] -= 1;
+        this.stageCompactionNeeded[stage] = true;
+      }
+    };
+  }
+  reset(startTimeMs) {
+    this.timeMs = startTimeMs;
+    this.frame = 0;
+  }
+  advance(step) {
+    const previousTimeMs = this.timeMs;
+    this.timeMs = previousTimeMs + step.deltaMs;
+    this.frame = step.frame;
+    const context = {
+      ...step,
+      timeMs: this.timeMs,
+      previousTimeMs,
+      deltaSeconds: step.deltaMs / 1e3
+    };
+    this.runStage("prep", context);
+    if (this.stageCounts.simulate === 0) {
+      throw new Error("GameFrameLoop requires at least one simulate stage");
+    }
+    this.runStage("simulate", context);
+    this.runStage("finish", context);
+    return context;
+  }
+  runStage(stage, context) {
+    const handlers = this.stageHandlers[stage];
+    for (let i = 0; i < handlers.length; i += 1) {
+      const handler = handlers[i];
+      if (!handler) {
+        continue;
+      }
+      handler(context);
+    }
+    if (this.stageCompactionNeeded[stage]) {
+      this.compactStageHandlers(stage);
+    }
+  }
+  compactStageHandlers(stage) {
+    const handlers = this.stageHandlers[stage];
+    let writeIndex = 0;
+    for (let readIndex = 0; readIndex < handlers.length; readIndex += 1) {
+      const handler = handlers[readIndex];
+      if (handler) {
+        handlers[writeIndex] = handler;
+        writeIndex += 1;
+      }
+    }
+    handlers.length = writeIndex;
+    this.stageCompactionNeeded[stage] = false;
+  }
+  get time() {
+    return this.timeMs;
+  }
+  get frameNumber() {
+    return this.frame;
+  }
+};
+
+// src/level.ts
+var ZERO_STATE = {
   frameNumber: 0,
   timeSeconds: 0,
   previousTimeSeconds: 0,
@@ -623,30 +2033,1306 @@ var ZERO_STATE = {
 };
 var LevelClock = class {
   constructor() {
-    this.state = ZERO_STATE;
+    this.state = ZERO_STATE;
+  }
+  start(startTimeMs) {
+    const startSeconds = startTimeMs / 1e3;
+    this.state = {
+      frameNumber: 0,
+      timeSeconds: startSeconds,
+      previousTimeSeconds: startSeconds,
+      deltaSeconds: 0
+    };
+  }
+  tick(context) {
+    this.state = {
+      frameNumber: context.frame,
+      timeSeconds: context.timeMs / 1e3,
+      previousTimeSeconds: context.previousTimeMs / 1e3,
+      deltaSeconds: context.deltaSeconds
+    };
+    return this.state;
+  }
+  get current() {
+    return this.state;
+  }
+  restore(state) {
+    this.state = { ...state };
+  }
+};
+
+// src/ai/constants.ts
+var RANGE_MELEE = 20;
+var RANGE_NEAR = 440;
+var RANGE_MID = 940;
+var FL_NOVISIBLE = 1 << 24;
+var SPAWNFLAG_MONSTER_AMBUSH = 1 << 0;
+var AIFlags = /* @__PURE__ */ ((AIFlags2) => {
+  AIFlags2[AIFlags2["Pathing"] = 1073741824] = "Pathing";
+  return AIFlags2;
+})(AIFlags || {});
+var TraceMask = /* @__PURE__ */ ((TraceMask2) => {
+  TraceMask2[TraceMask2["Opaque"] = 1] = "Opaque";
+  TraceMask2[TraceMask2["Window"] = 2] = "Window";
+  return TraceMask2;
+})(TraceMask || {});
+
+// src/ai/movement.ts
+function yawVector(yawDegrees, distance) {
+  if (distance === 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const radians = degToRad(yawDegrees);
+  return {
+    x: Math.cos(radians) * distance,
+    y: Math.sin(radians) * distance,
+    z: 0
+  };
+}
+function walkMove(self, yawDegrees, distance) {
+  const delta = yawVector(yawDegrees, distance);
+  const origin = self.origin;
+  origin.x += delta.x;
+  origin.y += delta.y;
+  origin.z += delta.z;
+  return true;
+}
+function changeYaw(self, deltaSeconds) {
+  const current = angleMod(self.angles.y);
+  const ideal = self.ideal_yaw;
+  if (current === ideal) {
+    self.angles.y = current;
+    return;
+  }
+  const speed = self.yaw_speed * deltaSeconds * 10;
+  let move = ideal - current;
+  if (ideal > current) {
+    if (move >= 180) move -= 360;
+  } else if (move <= -180) {
+    move += 360;
+  }
+  if (move > speed) move = speed;
+  else if (move < -speed) move = -speed;
+  self.angles.y = angleMod(current + move);
+}
+function facingIdeal(self) {
+  const delta = angleMod(self.angles.y - self.ideal_yaw);
+  const hasPathing = (self.monsterinfo.aiflags & 1073741824 /* Pathing */) !== 0;
+  if (hasPathing) {
+    return !(delta > 5 && delta < 355);
+  }
+  return !(delta > 45 && delta < 315);
+}
+function ai_move(self, distance) {
+  walkMove(self, self.angles.y, distance);
+}
+function setIdealYawTowards(self, target) {
+  if (!target) return;
+  const toTarget = {
+    x: target.origin.x - self.origin.x,
+    y: target.origin.y - self.origin.y,
+    z: target.origin.z - self.origin.z
+  };
+  self.ideal_yaw = vectorToYaw(toTarget);
+}
+function ai_stand(self, deltaSeconds) {
+  changeYaw(self, deltaSeconds);
+}
+function ai_walk(self, distance, deltaSeconds) {
+  setIdealYawTowards(self, self.goalentity);
+  changeYaw(self, deltaSeconds);
+  if (distance !== 0) {
+    walkMove(self, self.angles.y, distance);
+  }
+}
+function ai_turn(self, distance, deltaSeconds) {
+  if (distance !== 0) {
+    walkMove(self, self.angles.y, distance);
+  }
+  changeYaw(self, deltaSeconds);
+}
+function ai_run(self, distance, deltaSeconds) {
+  setIdealYawTowards(self, self.enemy ?? self.goalentity);
+  changeYaw(self, deltaSeconds);
+  if (distance !== 0) {
+    walkMove(self, self.angles.y, distance);
+  }
+}
+function ai_face(self, enemy, distance, deltaSeconds) {
+  if (enemy) {
+    setIdealYawTowards(self, enemy);
+  }
+  changeYaw(self, deltaSeconds);
+  if (distance !== 0) {
+    walkMove(self, self.angles.y, distance);
+  }
+}
+function ai_charge(self, distance, deltaSeconds) {
+  setIdealYawTowards(self, self.enemy);
+  changeYaw(self, deltaSeconds);
+  if (distance !== 0) {
+    walkMove(self, self.angles.y, distance);
+  }
+}
+
+// src/ai/perception.ts
+var RangeCategory = /* @__PURE__ */ ((RangeCategory2) => {
+  RangeCategory2["Melee"] = "melee";
+  RangeCategory2["Near"] = "near";
+  RangeCategory2["Mid"] = "mid";
+  RangeCategory2["Far"] = "far";
+  return RangeCategory2;
+})(RangeCategory || {});
+function absBounds(entity) {
+  return {
+    mins: {
+      x: entity.origin.x + entity.mins.x,
+      y: entity.origin.y + entity.mins.y,
+      z: entity.origin.z + entity.mins.z
+    },
+    maxs: {
+      x: entity.origin.x + entity.maxs.x,
+      y: entity.origin.y + entity.maxs.y,
+      z: entity.origin.z + entity.maxs.z
+    }
+  };
+}
+function rangeTo(self, other) {
+  const a = absBounds(self);
+  const b = absBounds(other);
+  const distanceSquared = distanceBetweenBoxesSquared(a.mins, a.maxs, b.mins, b.maxs);
+  return Math.sqrt(distanceSquared);
+}
+function classifyRange(distance) {
+  if (distance <= RANGE_MELEE) {
+    return "melee" /* Melee */;
+  }
+  if (distance <= RANGE_NEAR) {
+    return "near" /* Near */;
+  }
+  if (distance <= RANGE_MID) {
+    return "mid" /* Mid */;
+  }
+  return "far" /* Far */;
+}
+function infront(self, other) {
+  const { forward } = angleVectors(self.angles);
+  const direction = normalizeVec3(subtractVec3(other.origin, self.origin));
+  const dot = dotVec3(direction, forward);
+  if ((self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) !== 0 && self.trail_time === 0 && self.enemy === null) {
+    return dot > 0.15;
+  }
+  return dot > -0.3;
+}
+function visible(self, other, trace, options) {
+  if ((other.flags & FL_NOVISIBLE) !== 0) {
+    return false;
+  }
+  const start = { x: self.origin.x, y: self.origin.y, z: self.origin.z + self.viewheight };
+  const end = { x: other.origin.x, y: other.origin.y, z: other.origin.z + other.viewheight };
+  const mask = options?.throughGlass ? 1 /* Opaque */ : 1 /* Opaque */ | 2 /* Window */;
+  const result = trace(start, end, self, mask);
+  return result.fraction === 1 || result.entity === other;
+}
+
+// src/checksum.ts
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+function hashBytes(hash, bytes) {
+  let h = hash >>> 0;
+  for (let i = 0; i < bytes.length; i += 1) {
+    h ^= bytes[i] & 255;
+    h = Math.imul(h, FNV_PRIME) >>> 0;
+  }
+  return h >>> 0;
+}
+function hashNumber(hash, value) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setFloat64(0, value, true);
+  const bytes = new Uint8Array(buffer);
+  return hashBytes(hash, bytes);
+}
+function hashString(hash, value) {
+  const bytes = new Uint8Array(value.length);
+  for (let i = 0; i < value.length; i += 1) {
+    bytes[i] = value.charCodeAt(i) & 255;
+  }
+  return hashBytes(hash, bytes);
+}
+function hashGameState(state) {
+  let hash = FNV_OFFSET_BASIS;
+  hash = hashNumber(hash, state.gravity.x);
+  hash = hashNumber(hash, state.gravity.y);
+  hash = hashNumber(hash, state.gravity.z);
+  hash = hashNumber(hash, state.origin.x);
+  hash = hashNumber(hash, state.origin.y);
+  hash = hashNumber(hash, state.origin.z);
+  hash = hashNumber(hash, state.velocity.x);
+  hash = hashNumber(hash, state.velocity.y);
+  hash = hashNumber(hash, state.velocity.z);
+  hash = hashNumber(hash, state.level.frameNumber);
+  hash = hashNumber(hash, state.level.timeSeconds);
+  hash = hashNumber(hash, state.level.previousTimeSeconds);
+  hash = hashNumber(hash, state.level.deltaSeconds);
+  hash = hashNumber(hash, state.entities.activeCount);
+  hash = hashString(hash, state.entities.worldClassname);
+  return hash >>> 0;
+}
+
+// src/save/save.ts
+var SAVE_FORMAT_VERSION = 1;
+var MIN_SUPPORTED_VERSION = 1;
+function ensureObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureNumber(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  return value;
+}
+function ensureNumberOrDefault(value, label, defaultValue) {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return ensureNumber(value, label);
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureNumberArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  for (const element of value) {
+    ensureNumber(element, `${label} element`);
+  }
+  return value;
+}
+function parseLevelState(raw) {
+  if (raw === void 0) {
+    return { frameNumber: 0, timeSeconds: 0, previousTimeSeconds: 0, deltaSeconds: 0 };
+  }
+  const level = ensureObject(raw, "level");
+  return {
+    frameNumber: ensureNumberOrDefault(level.frameNumber, "level.frameNumber", 0),
+    timeSeconds: ensureNumberOrDefault(level.timeSeconds, "level.timeSeconds", 0),
+    previousTimeSeconds: ensureNumberOrDefault(level.previousTimeSeconds, "level.previousTimeSeconds", 0),
+    deltaSeconds: ensureNumberOrDefault(level.deltaSeconds, "level.deltaSeconds", 0)
+  };
+}
+function parseRngState(raw) {
+  if (raw === void 0) {
+    return new RandomGenerator().getState();
+  }
+  const rng = ensureObject(raw, "rng");
+  const mt = ensureObject(rng.mt, "rng.mt");
+  const state = ensureNumberArray(mt.state, "rng.mt.state");
+  return {
+    mt: {
+      index: ensureNumber(mt.index, "rng.mt.index"),
+      state
+    }
+  };
+}
+function parseThinkEntries(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("thinks must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const think = ensureObject(entry, `thinks[${idx}]`);
+    return {
+      time: ensureNumber(think.time, `thinks[${idx}].time`),
+      entityIndex: ensureNumber(think.entityIndex, `thinks[${idx}].entityIndex`)
+    };
+  });
+}
+function parseEntityFields(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  const fields = ensureObject(raw, "entity.fields");
+  const parsed = {};
+  for (const [name, value] of Object.entries(fields)) {
+    if (value === null) {
+      parsed[name] = null;
+      continue;
+    }
+    switch (typeof value) {
+      case "number":
+      case "string":
+      case "boolean":
+        parsed[name] = value;
+        break;
+      default: {
+        if (!Array.isArray(value)) {
+          const object = ensureObject(value, name);
+          const inventory = {};
+          for (const [entryName, entryValue] of Object.entries(object)) {
+            inventory[entryName] = ensureNumber(entryValue, `${name}.${entryName}`);
+          }
+          parsed[name] = inventory;
+          break;
+        }
+        if (Array.isArray(value) && value.length === 3) {
+          const [x, y, z] = value;
+          parsed[name] = [
+            ensureNumber(x, `${name}[0]`),
+            ensureNumber(y, `${name}[1]`),
+            ensureNumber(z, `${name}[2]`)
+          ];
+          break;
+        }
+        throw new Error(`Unsupported entity field value for ${name}`);
+      }
+    }
+  }
+  return parsed;
+}
+function parseEntities(raw) {
+  if (!Array.isArray(raw)) {
+    throw new Error("entities must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const entity = ensureObject(entry, `entities[${idx}]`);
+    return {
+      index: ensureNumber(entity.index, `entities[${idx}].index`),
+      fields: parseEntityFields(entity.fields)
+    };
+  });
+}
+function parsePool(raw) {
+  const pool = ensureObject(raw, "pool");
+  return {
+    capacity: ensureNumber(pool.capacity, "pool.capacity"),
+    activeOrder: ensureNumberArray(pool.activeOrder, "pool.activeOrder"),
+    freeList: ensureNumberArray(pool.freeList, "pool.freeList"),
+    pendingFree: ensureNumberArray(pool.pendingFree, "pool.pendingFree")
+  };
+}
+function parseEntitySnapshot(raw) {
+  const snapshot = ensureObject(raw, "entities");
+  return {
+    timeSeconds: ensureNumber(snapshot.timeSeconds, "entities.timeSeconds"),
+    pool: parsePool(snapshot.pool),
+    entities: parseEntities(snapshot.entities),
+    thinks: parseThinkEntries(snapshot.thinks)
+  };
+}
+function parseCvars(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("cvars must be an array");
+  }
+  return raw.map((entry, idx) => {
+    const cvar = ensureObject(entry, `cvars[${idx}]`);
+    return {
+      name: ensureString(cvar.name, `cvars[${idx}].name`),
+      value: ensureString(cvar.value, `cvars[${idx}].value`),
+      flags: ensureNumber(cvar.flags, `cvars[${idx}].flags`)
+    };
+  });
+}
+function parseConfigstrings(raw) {
+  if (raw === void 0) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("configstrings must be an array");
+  }
+  return raw.map((value, idx) => ensureString(value, `configstrings[${idx}]`));
+}
+function parseGameState(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  return ensureObject(raw, "gameState");
+}
+function serializeCvars(registry) {
+  if (!registry) {
+    return [];
+  }
+  return registry.list().filter((cvar) => (cvar.flags & CvarFlags.Archive) !== 0).map((cvar) => ({ name: cvar.name, value: cvar.string, flags: cvar.flags }));
+}
+function applyCvars(entries, registry) {
+  if (!registry) {
+    return;
+  }
+  for (const entry of entries) {
+    const existing = registry.get(entry.name);
+    if (existing) {
+      existing.set(entry.value);
+    } else {
+      registry.register({ name: entry.name, defaultValue: entry.value, flags: entry.flags });
+    }
+  }
+}
+function cloneRngState(state) {
+  return {
+    mt: {
+      index: state.mt.index,
+      state: [...state.mt.state]
+    }
+  };
+}
+function createSaveFile(options) {
+  const {
+    map,
+    difficulty,
+    playtimeSeconds,
+    levelState,
+    entitySystem,
+    rngState,
+    configstrings = [],
+    cvars,
+    gameState = {},
+    timestamp = Date.now()
+  } = options;
+  return {
+    version: SAVE_FORMAT_VERSION,
+    timestamp,
+    map,
+    difficulty,
+    playtimeSeconds,
+    gameState: { ...gameState },
+    level: { ...levelState },
+    rng: cloneRngState(rngState),
+    entities: entitySystem.createSnapshot(),
+    cvars: serializeCvars(cvars),
+    configstrings: [...configstrings]
+  };
+}
+function parseSaveFile(serialized, options = {}) {
+  const { allowNewerVersion = true } = options;
+  const raw = typeof serialized === "string" ? JSON.parse(serialized) : serialized;
+  const save = ensureObject(raw, "save");
+  const versionValue = save.version ?? SAVE_FORMAT_VERSION;
+  const version = ensureNumber(versionValue, "version");
+  if (version < MIN_SUPPORTED_VERSION) {
+    throw new Error(`Unsupported save version ${version}`);
+  }
+  if (version > SAVE_FORMAT_VERSION && !allowNewerVersion) {
+    throw new Error(`Save version ${version} is newer than supported ${SAVE_FORMAT_VERSION}`);
+  }
+  return {
+    version,
+    timestamp: ensureNumber(save.timestamp, "timestamp"),
+    map: ensureString(save.map, "map"),
+    difficulty: ensureNumber(save.difficulty, "difficulty"),
+    playtimeSeconds: ensureNumber(save.playtimeSeconds, "playtimeSeconds"),
+    gameState: parseGameState(save.gameState),
+    level: parseLevelState(save.level),
+    rng: parseRngState(save.rng),
+    entities: parseEntitySnapshot(save.entities),
+    cvars: parseCvars(save.cvars),
+    configstrings: parseConfigstrings(save.configstrings)
+  };
+}
+function applySaveFile(save, targets) {
+  targets.levelClock.restore(save.level);
+  targets.entitySystem.restore(save.entities);
+  targets.rng.setState(save.rng);
+  applyCvars(save.cvars, targets.cvars);
+}
+
+// src/save/rerelease.ts
+function ensureObject2(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureNumber2(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  return value;
+}
+function ensureArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  return value;
+}
+function parseEntityMap(raw) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [rawIndex, value] of Object.entries(raw)) {
+    const index = Number(rawIndex);
+    if (!Number.isInteger(index)) {
+      throw new Error(`entities[${rawIndex}] must use an integer key`);
+    }
+    map.set(index, ensureObject2(value, `entities[${rawIndex}]`));
+  }
+  return map;
+}
+function parseRereleaseSave(raw) {
+  const root = ensureObject2(raw, "rerelease save");
+  const saveVersion = ensureNumber2(root.save_version, "save_version");
+  const hasGame = "game" in root;
+  const hasLevel = "level" in root;
+  if (hasGame === hasLevel) {
+    throw new Error("save must contain either game or level data");
+  }
+  if (hasGame) {
+    const game = ensureObject2(root.game, "game");
+    const clients = ensureArray(root.clients, "clients").map(
+      (entry, idx) => ensureObject2(entry, `clients[${idx}]`)
+    );
+    const maxclients = game.maxclients !== void 0 ? ensureNumber2(game.maxclients, "game.maxclients") : clients.length;
+    if (clients.length !== maxclients) {
+      throw new Error(`clients length ${clients.length} does not match game.maxclients ${maxclients}`);
+    }
+    return { saveVersion, game, clients };
+  }
+  const level = ensureObject2(root.level, "level");
+  const entitiesRoot = ensureObject2(root.entities, "entities");
+  const entities = parseEntityMap(entitiesRoot);
+  return { saveVersion, level, entities };
+}
+function summarizeRereleaseSave(raw) {
+  const parsed = parseRereleaseSave(raw);
+  if ("game" in parsed) {
+    const maxClients = parsed.game.maxclients ?? parsed.clients.length;
+    return {
+      version: parsed.saveVersion,
+      kind: "game",
+      maxClients,
+      clientCount: parsed.clients.length
+    };
+  }
+  let highestEntityIndex = -1;
+  for (const index of parsed.entities.keys()) {
+    if (index > highestEntityIndex) {
+      highestEntityIndex = index;
+    }
+  }
+  return {
+    version: parsed.saveVersion,
+    kind: "level",
+    entityCount: parsed.entities.size,
+    highestEntityIndex: highestEntityIndex >= 0 ? highestEntityIndex : void 0
+  };
+}
+
+// src/save/storage.ts
+var TEXT_ENCODER_CTOR = globalThis.TextEncoder;
+function cloneSave(save) {
+  return parseSaveFile({ ...save }, { allowNewerVersion: true });
+}
+function estimateSizeBytes(save) {
+  if (TEXT_ENCODER_CTOR) {
+    const encoder = new TEXT_ENCODER_CTOR();
+    return encoder.encode(JSON.stringify(save)).length;
+  }
+  return JSON.stringify(save).length;
+}
+var MemorySaveAdapter = class {
+  constructor() {
+    this.records = /* @__PURE__ */ new Map();
   }
-  start(startTimeMs) {
-    const startSeconds = startTimeMs / 1e3;
-    this.state = {
-      frameNumber: 0,
-      timeSeconds: startSeconds,
-      previousTimeSeconds: startSeconds,
-      deltaSeconds: 0
+  async init() {
+    return Promise.resolve();
+  }
+  async put(record) {
+    const copy = {
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
     };
+    this.records.set(record.id, copy);
   }
-  tick(context) {
-    this.state = {
-      frameNumber: context.frame,
-      timeSeconds: context.timeMs / 1e3,
-      previousTimeSeconds: context.previousTimeMs / 1e3,
-      deltaSeconds: context.deltaSeconds
+  async get(id) {
+    const record = this.records.get(id);
+    if (!record) {
+      return null;
+    }
+    return {
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
     };
-    return this.state;
   }
-  get current() {
-    return this.state;
+  async delete(id) {
+    return this.records.delete(id);
+  }
+  async list() {
+    return Array.from(this.records.values()).map((record) => ({
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    }));
+  }
+};
+var IndexedDbSaveAdapter = class {
+  constructor(indexedDB, dbName, storeName) {
+    this.indexedDB = indexedDB;
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.db = null;
+  }
+  async init() {
+    if (this.db) {
+      return;
+    }
+    this.db = await new Promise((resolve, reject) => {
+      const request = this.indexedDB.open(this.dbName, 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore(this.storeName, { keyPath: "id" });
+      };
+      request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  async runTransaction(mode, operation) {
+    await this.init();
+    const database = this.db;
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction(this.storeName, mode);
+      const store = transaction.objectStore(this.storeName);
+      const request = operation(store);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+    });
+  }
+  async put(record) {
+    await this.runTransaction("readwrite", (store) => store.put(record));
+  }
+  async get(id) {
+    const record = await this.runTransaction("readonly", (store) => store.get(id));
+    if (!record) {
+      return null;
+    }
+    return {
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    };
+  }
+  async delete(id) {
+    const existing = await this.get(id);
+    if (!existing) {
+      return false;
+    }
+    await this.runTransaction("readwrite", (store) => store.delete(id));
+    return true;
+  }
+  async list() {
+    const all = await this.runTransaction("readonly", (store) => store.getAll());
+    return all.map((record) => ({
+      id: record.id,
+      metadata: { ...record.metadata },
+      save: cloneSave(record.save)
+    }));
+  }
+};
+var _SaveStorage = class _SaveStorage {
+  constructor(options = {}) {
+    const { dbName = _SaveStorage.DEFAULT_DB_NAME, storeName = _SaveStorage.DEFAULT_STORE } = options;
+    const indexedDBFactory = options.indexedDB ?? globalThis.indexedDB;
+    if (indexedDBFactory) {
+      this.adapter = new IndexedDbSaveAdapter(indexedDBFactory, dbName, storeName);
+    } else {
+      this.adapter = new MemorySaveAdapter();
+    }
+  }
+  async save(slotId, save, options = {}) {
+    const normalized = cloneSave(save);
+    const metadata = {
+      id: slotId,
+      name: options.name ?? slotId,
+      map: normalized.map,
+      difficulty: normalized.difficulty,
+      playtimeSeconds: normalized.playtimeSeconds,
+      timestamp: normalized.timestamp,
+      version: normalized.version,
+      bytes: estimateSizeBytes(normalized)
+    };
+    await this.adapter.init();
+    await this.adapter.put({ id: slotId, metadata, save: normalized });
+    return metadata;
+  }
+  async load(slotId, options = {}) {
+    await this.adapter.init();
+    const record = await this.adapter.get(slotId);
+    if (!record) {
+      throw new Error(`Save slot ${slotId} not found`);
+    }
+    return parseSaveFile(record.save, options);
+  }
+  async delete(slotId) {
+    await this.adapter.init();
+    return this.adapter.delete(slotId);
+  }
+  async list() {
+    await this.adapter.init();
+    const records = await this.adapter.list();
+    return records.map((record) => ({ ...record.metadata })).sort((a, b) => b.timestamp - a.timestamp || a.id.localeCompare(b.id));
+  }
+  async quickSave(save) {
+    return this.save(_SaveStorage.QUICK_SLOT, save, { name: "Quick Save" });
+  }
+  async quickLoad(options = {}) {
+    return this.load(_SaveStorage.QUICK_SLOT, options);
+  }
+};
+_SaveStorage.DEFAULT_DB_NAME = "quake2ts-saves";
+_SaveStorage.DEFAULT_STORE = "saves";
+_SaveStorage.QUICK_SLOT = "quicksave";
+var SaveStorage = _SaveStorage;
+
+// src/combat/damageFlags.ts
+var DamageFlags = /* @__PURE__ */ ((DamageFlags2) => {
+  DamageFlags2[DamageFlags2["NONE"] = 0] = "NONE";
+  DamageFlags2[DamageFlags2["RADIUS"] = 1] = "RADIUS";
+  DamageFlags2[DamageFlags2["NO_ARMOR"] = 2] = "NO_ARMOR";
+  DamageFlags2[DamageFlags2["ENERGY"] = 4] = "ENERGY";
+  DamageFlags2[DamageFlags2["NO_KNOCKBACK"] = 8] = "NO_KNOCKBACK";
+  DamageFlags2[DamageFlags2["BULLET"] = 16] = "BULLET";
+  DamageFlags2[DamageFlags2["NO_PROTECTION"] = 32] = "NO_PROTECTION";
+  DamageFlags2[DamageFlags2["DESTROY_ARMOR"] = 64] = "DESTROY_ARMOR";
+  DamageFlags2[DamageFlags2["NO_REG_ARMOR"] = 128] = "NO_REG_ARMOR";
+  DamageFlags2[DamageFlags2["NO_POWER_ARMOR"] = 256] = "NO_POWER_ARMOR";
+  DamageFlags2[DamageFlags2["NO_INDICATOR"] = 512] = "NO_INDICATOR";
+  return DamageFlags2;
+})(DamageFlags || {});
+function hasAnyDamageFlag(flags, mask) {
+  return (flags & mask) !== 0;
+}
+
+// src/combat/armor.ts
+var ArmorType = /* @__PURE__ */ ((ArmorType2) => {
+  ArmorType2["BODY"] = "body";
+  ArmorType2["COMBAT"] = "combat";
+  ArmorType2["JACKET"] = "jacket";
+  return ArmorType2;
+})(ArmorType || {});
+var ARMOR_INFO = {
+  ["jacket" /* JACKET */]: {
+    baseCount: 25,
+    maxCount: 50,
+    normalProtection: 0.3,
+    energyProtection: 0
+  },
+  ["combat" /* COMBAT */]: {
+    baseCount: 50,
+    maxCount: 100,
+    normalProtection: 0.6,
+    energyProtection: 0.3
+  },
+  ["body" /* BODY */]: {
+    baseCount: 100,
+    maxCount: 200,
+    normalProtection: 0.8,
+    energyProtection: 0.6
   }
 };
+function applyRegularArmor(damage, flags, state) {
+  if (damage <= 0 || hasAnyDamageFlag(flags, 2 /* NO_ARMOR */ | 128 /* NO_REG_ARMOR */) || !state.armorType || state.armorCount <= 0) {
+    return { saved: 0, remainingArmor: state.armorCount };
+  }
+  const info = ARMOR_INFO[state.armorType];
+  const protection = hasAnyDamageFlag(flags, 4 /* ENERGY */) ? info.energyProtection : info.normalProtection;
+  let saved = Math.ceil(protection * damage);
+  if (saved >= state.armorCount) {
+    saved = state.armorCount;
+  }
+  if (saved <= 0) {
+    return { saved: 0, remainingArmor: state.armorCount };
+  }
+  return { saved, remainingArmor: state.armorCount - saved };
+}
+function applyPowerArmor(damage, flags, hitPoint, _hitNormal, state, options = {}) {
+  if (state.health <= 0 || damage <= 0) {
+    return { saved: 0, remainingCells: state.cellCount };
+  }
+  if (hasAnyDamageFlag(flags, 2 /* NO_ARMOR */ | 256 /* NO_POWER_ARMOR */)) {
+    return { saved: 0, remainingCells: state.cellCount };
+  }
+  if (!state.type || state.cellCount <= 0) {
+    return { saved: 0, remainingCells: state.cellCount };
+  }
+  const { forward } = angleVectors(state.angles);
+  const toImpact = {
+    x: hitPoint.x - state.origin.x,
+    y: hitPoint.y - state.origin.y,
+    z: hitPoint.z - state.origin.z
+  };
+  const toImpactLength = Math.hypot(toImpact.x, toImpact.y, toImpact.z);
+  if (state.type === "screen" && toImpactLength > 0) {
+    const dir = {
+      x: toImpact.x / toImpactLength,
+      y: toImpact.y / toImpactLength,
+      z: toImpact.z / toImpactLength
+    };
+    const dot = dir.x * forward.x + dir.y * forward.y + dir.z * forward.z;
+    if (dot <= 0.3) {
+      return { saved: 0, remainingCells: state.cellCount };
+    }
+  }
+  const ctfMode = options.ctfMode ?? false;
+  const damagePerCell = state.type === "screen" ? 1 : ctfMode ? 1 : 2;
+  let adjustedDamage = state.type === "screen" ? damage / 3 : 2 * damage / 3;
+  adjustedDamage = Math.max(1, adjustedDamage);
+  let saved = state.cellCount * damagePerCell;
+  if (hasAnyDamageFlag(flags, 4 /* ENERGY */)) {
+    saved = Math.max(1, Math.floor(saved / 2));
+  }
+  if (saved > adjustedDamage) {
+    saved = Math.floor(adjustedDamage);
+  }
+  let powerUsed = saved / damagePerCell;
+  if (hasAnyDamageFlag(flags, 4 /* ENERGY */)) {
+    powerUsed *= 2;
+  }
+  powerUsed = Math.max(1, Math.floor(powerUsed));
+  const cellsSpent = Math.max(damagePerCell, powerUsed);
+  const remainingCells = Math.max(0, state.cellCount - cellsSpent);
+  return { saved, remainingCells };
+}
+
+// src/combat/damage.ts
+var EntityDamageFlags = /* @__PURE__ */ ((EntityDamageFlags2) => {
+  EntityDamageFlags2[EntityDamageFlags2["GODMODE"] = 1] = "GODMODE";
+  EntityDamageFlags2[EntityDamageFlags2["IMMORTAL"] = 2] = "IMMORTAL";
+  EntityDamageFlags2[EntityDamageFlags2["NO_KNOCKBACK"] = 4] = "NO_KNOCKBACK";
+  EntityDamageFlags2[EntityDamageFlags2["NO_DAMAGE_EFFECTS"] = 8] = "NO_DAMAGE_EFFECTS";
+  return EntityDamageFlags2;
+})(EntityDamageFlags || {});
+function applyKnockback(targ, attacker, dir, knockback, dflags) {
+  const hasNoKnockback = hasAnyDamageFlag(dflags, 8 /* NO_KNOCKBACK */) || ((targ.flags ?? 0) & 4 /* NO_KNOCKBACK */) !== 0;
+  if (hasNoKnockback || knockback === 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const mass = Math.max(50, targ.mass ?? 200);
+  const normalized = normalizeVec3(dir);
+  const scale = attacker === targ ? 1600 : 500;
+  const delta = scaleVec3(normalized, scale * knockback / mass);
+  targ.velocity = addVec3(targ.velocity, delta);
+  return delta;
+}
+function applyProtection(targ, point, normal, damage, dflags) {
+  let take = damage;
+  let psave = 0;
+  let asave = 0;
+  let remainingCells;
+  let remainingArmor;
+  if (targ.powerArmor) {
+    const result = applyPowerArmor(damage, dflags, point, normal, targ.powerArmor);
+    psave = result.saved;
+    remainingCells = result.remainingCells;
+    take -= psave;
+  }
+  if (targ.regularArmor) {
+    const result = applyRegularArmor(take, dflags, targ.regularArmor);
+    asave = result.saved;
+    remainingArmor = result.remainingArmor;
+    take -= asave;
+  }
+  return [Math.max(0, take), psave, asave, remainingCells, remainingArmor];
+}
+function targetCenter(ent) {
+  if (ent.mins && ent.maxs) {
+    return {
+      x: ent.origin.x + (ent.mins.x + ent.maxs.x) * 0.5,
+      y: ent.origin.y + (ent.mins.y + ent.maxs.y) * 0.5,
+      z: ent.origin.z + (ent.mins.z + ent.maxs.z) * 0.5
+    };
+  }
+  return ent.origin;
+}
+function T_Damage(targ, inflictor, attacker, dir, point, normal, damage, knockback, dflags, mod) {
+  if (!targ.takedamage || damage <= 0) {
+    return null;
+  }
+  const protectedByGod = !hasAnyDamageFlag(dflags, 32 /* NO_PROTECTION */) && ((targ.flags ?? 0) & 1 /* GODMODE */) !== 0;
+  if (protectedByGod) {
+    return {
+      take: 0,
+      psave: 0,
+      asave: damage,
+      knocked: { x: 0, y: 0, z: 0 },
+      killed: false
+    };
+  }
+  const knocked = applyKnockback(targ, attacker, dir, knockback, dflags);
+  const [take, psave, asave, remainingCells, remainingArmor] = applyProtection(targ, point, normal, damage, dflags);
+  if (targ.powerArmor && remainingCells !== void 0) {
+    targ.powerArmor.cellCount = remainingCells;
+  }
+  if (targ.regularArmor) {
+    targ.regularArmor.armorCount = remainingArmor ?? targ.regularArmor.armorCount;
+  }
+  let actualTake = take;
+  if (actualTake > 0) {
+    targ.health -= actualTake;
+  }
+  const killed = targ.health <= 0;
+  if (killed) {
+    if (targ.flags && targ.flags & 2 /* IMMORTAL */) {
+      targ.health = Math.max(1, targ.health);
+    } else if (targ.die) {
+      targ.die(targ, inflictor, attacker, actualTake, point, mod);
+    }
+  } else if (actualTake > 0 && targ.pain) {
+    targ.pain(targ, attacker, knockback, actualTake, mod);
+  }
+  return { take: actualTake, psave, asave, knocked, killed, remainingCells, remainingArmor };
+}
+function T_RadiusDamage(entities, inflictor, attacker, damage, ignore, radius, dflags, mod, options = {}) {
+  const hits = [];
+  const inflictorCenter = targetCenter(inflictor);
+  const canDamage = options.canDamage ?? (() => true);
+  for (const ent of entities) {
+    if (ent === ignore || !ent.takedamage || !canDamage(ent, inflictor)) {
+      continue;
+    }
+    const entCenter = ent.mins && ent.maxs ? closestPointToBox(inflictorCenter, addVec3(ent.origin, ent.mins), addVec3(ent.origin, ent.maxs)) : targetCenter(ent);
+    const toTarget = subtractVec3(inflictorCenter, entCenter);
+    const distance = lengthVec3(toTarget);
+    if (radius > 0 && distance > radius) {
+      continue;
+    }
+    const points = damage - 0.5 * distance;
+    if (points <= 0) {
+      continue;
+    }
+    const adjustedDamage = ent === attacker ? points * 0.5 : points;
+    const dir = normalizeVec3(subtractVec3(ent.origin, inflictorCenter));
+    const result = T_Damage(ent, inflictor, attacker, dir, entCenter, dir, adjustedDamage, adjustedDamage, dflags | 1 /* RADIUS */, mod);
+    hits.push({ target: ent, result, appliedDamage: adjustedDamage });
+  }
+  return hits;
+}
+
+// src/combat/damageMods.ts
+var DamageMod = /* @__PURE__ */ ((DamageMod2) => {
+  DamageMod2[DamageMod2["UNKNOWN"] = 0] = "UNKNOWN";
+  DamageMod2[DamageMod2["BLASTER"] = 1] = "BLASTER";
+  DamageMod2[DamageMod2["SHOTGUN"] = 2] = "SHOTGUN";
+  DamageMod2[DamageMod2["SSHOTGUN"] = 3] = "SSHOTGUN";
+  DamageMod2[DamageMod2["MACHINEGUN"] = 4] = "MACHINEGUN";
+  DamageMod2[DamageMod2["CHAINGUN"] = 5] = "CHAINGUN";
+  DamageMod2[DamageMod2["GRENADE"] = 6] = "GRENADE";
+  DamageMod2[DamageMod2["G_SPLASH"] = 7] = "G_SPLASH";
+  DamageMod2[DamageMod2["ROCKET"] = 8] = "ROCKET";
+  DamageMod2[DamageMod2["R_SPLASH"] = 9] = "R_SPLASH";
+  DamageMod2[DamageMod2["HYPERBLASTER"] = 10] = "HYPERBLASTER";
+  DamageMod2[DamageMod2["RAILGUN"] = 11] = "RAILGUN";
+  DamageMod2[DamageMod2["BFG_LASER"] = 12] = "BFG_LASER";
+  DamageMod2[DamageMod2["BFG_BLAST"] = 13] = "BFG_BLAST";
+  DamageMod2[DamageMod2["BFG_EFFECT"] = 14] = "BFG_EFFECT";
+  DamageMod2[DamageMod2["HANDGRENADE"] = 15] = "HANDGRENADE";
+  DamageMod2[DamageMod2["HG_SPLASH"] = 16] = "HG_SPLASH";
+  DamageMod2[DamageMod2["WATER"] = 17] = "WATER";
+  DamageMod2[DamageMod2["SLIME"] = 18] = "SLIME";
+  DamageMod2[DamageMod2["LAVA"] = 19] = "LAVA";
+  DamageMod2[DamageMod2["CRUSH"] = 20] = "CRUSH";
+  DamageMod2[DamageMod2["TELEFRAG"] = 21] = "TELEFRAG";
+  DamageMod2[DamageMod2["TELEFRAG_SPAWN"] = 22] = "TELEFRAG_SPAWN";
+  DamageMod2[DamageMod2["FALLING"] = 23] = "FALLING";
+  DamageMod2[DamageMod2["SUICIDE"] = 24] = "SUICIDE";
+  DamageMod2[DamageMod2["HELD_GRENADE"] = 25] = "HELD_GRENADE";
+  DamageMod2[DamageMod2["EXPLOSIVE"] = 26] = "EXPLOSIVE";
+  DamageMod2[DamageMod2["BARREL"] = 27] = "BARREL";
+  DamageMod2[DamageMod2["BOMB"] = 28] = "BOMB";
+  DamageMod2[DamageMod2["EXIT"] = 29] = "EXIT";
+  DamageMod2[DamageMod2["SPLASH"] = 30] = "SPLASH";
+  DamageMod2[DamageMod2["TARGET_LASER"] = 31] = "TARGET_LASER";
+  DamageMod2[DamageMod2["TRIGGER_HURT"] = 32] = "TRIGGER_HURT";
+  DamageMod2[DamageMod2["HIT"] = 33] = "HIT";
+  DamageMod2[DamageMod2["TARGET_BLASTER"] = 34] = "TARGET_BLASTER";
+  DamageMod2[DamageMod2["RIPPER"] = 35] = "RIPPER";
+  DamageMod2[DamageMod2["PHALANX"] = 36] = "PHALANX";
+  DamageMod2[DamageMod2["BRAINTENTACLE"] = 37] = "BRAINTENTACLE";
+  DamageMod2[DamageMod2["BLASTOFF"] = 38] = "BLASTOFF";
+  DamageMod2[DamageMod2["GEKK"] = 39] = "GEKK";
+  DamageMod2[DamageMod2["TRAP"] = 40] = "TRAP";
+  DamageMod2[DamageMod2["CHAINFIST"] = 41] = "CHAINFIST";
+  DamageMod2[DamageMod2["DISINTEGRATOR"] = 42] = "DISINTEGRATOR";
+  DamageMod2[DamageMod2["ETF_RIFLE"] = 43] = "ETF_RIFLE";
+  DamageMod2[DamageMod2["BLASTER2"] = 44] = "BLASTER2";
+  DamageMod2[DamageMod2["HEATBEAM"] = 45] = "HEATBEAM";
+  DamageMod2[DamageMod2["TESLA"] = 46] = "TESLA";
+  DamageMod2[DamageMod2["PROX"] = 47] = "PROX";
+  DamageMod2[DamageMod2["NUKE"] = 48] = "NUKE";
+  DamageMod2[DamageMod2["VENGEANCE_SPHERE"] = 49] = "VENGEANCE_SPHERE";
+  DamageMod2[DamageMod2["HUNTER_SPHERE"] = 50] = "HUNTER_SPHERE";
+  DamageMod2[DamageMod2["DEFENDER_SPHERE"] = 51] = "DEFENDER_SPHERE";
+  DamageMod2[DamageMod2["TRACKER"] = 52] = "TRACKER";
+  DamageMod2[DamageMod2["DBALL_CRUSH"] = 53] = "DBALL_CRUSH";
+  DamageMod2[DamageMod2["DOPPLE_EXPLODE"] = 54] = "DOPPLE_EXPLODE";
+  DamageMod2[DamageMod2["DOPPLE_VENGEANCE"] = 55] = "DOPPLE_VENGEANCE";
+  DamageMod2[DamageMod2["DOPPLE_HUNTER"] = 56] = "DOPPLE_HUNTER";
+  DamageMod2[DamageMod2["GRAPPLE"] = 57] = "GRAPPLE";
+  DamageMod2[DamageMod2["BLUEBLASTER"] = 58] = "BLUEBLASTER";
+  return DamageMod2;
+})(DamageMod || {});
+var ORDERED_DAMAGE_MODS = [
+  0 /* UNKNOWN */,
+  1 /* BLASTER */,
+  2 /* SHOTGUN */,
+  3 /* SSHOTGUN */,
+  4 /* MACHINEGUN */,
+  5 /* CHAINGUN */,
+  6 /* GRENADE */,
+  7 /* G_SPLASH */,
+  8 /* ROCKET */,
+  9 /* R_SPLASH */,
+  10 /* HYPERBLASTER */,
+  11 /* RAILGUN */,
+  12 /* BFG_LASER */,
+  13 /* BFG_BLAST */,
+  14 /* BFG_EFFECT */,
+  15 /* HANDGRENADE */,
+  16 /* HG_SPLASH */,
+  17 /* WATER */,
+  18 /* SLIME */,
+  19 /* LAVA */,
+  20 /* CRUSH */,
+  21 /* TELEFRAG */,
+  22 /* TELEFRAG_SPAWN */,
+  23 /* FALLING */,
+  24 /* SUICIDE */,
+  25 /* HELD_GRENADE */,
+  26 /* EXPLOSIVE */,
+  27 /* BARREL */,
+  28 /* BOMB */,
+  29 /* EXIT */,
+  30 /* SPLASH */,
+  31 /* TARGET_LASER */,
+  32 /* TRIGGER_HURT */,
+  33 /* HIT */,
+  34 /* TARGET_BLASTER */,
+  35 /* RIPPER */,
+  36 /* PHALANX */,
+  37 /* BRAINTENTACLE */,
+  38 /* BLASTOFF */,
+  39 /* GEKK */,
+  40 /* TRAP */,
+  41 /* CHAINFIST */,
+  42 /* DISINTEGRATOR */,
+  43 /* ETF_RIFLE */,
+  44 /* BLASTER2 */,
+  45 /* HEATBEAM */,
+  46 /* TESLA */,
+  47 /* PROX */,
+  48 /* NUKE */,
+  49 /* VENGEANCE_SPHERE */,
+  50 /* HUNTER_SPHERE */,
+  51 /* DEFENDER_SPHERE */,
+  52 /* TRACKER */,
+  53 /* DBALL_CRUSH */,
+  54 /* DOPPLE_EXPLODE */,
+  55 /* DOPPLE_VENGEANCE */,
+  56 /* DOPPLE_HUNTER */,
+  57 /* GRAPPLE */,
+  58 /* BLUEBLASTER */
+];
+function damageModName(mod) {
+  return `MOD_${DamageMod[mod]}`;
+}
+
+// src/combat/specialDamage.ts
+var ZERO2 = { x: 0, y: 0, z: 0 };
+var EnvironmentalFlags = /* @__PURE__ */ ((EnvironmentalFlags2) => {
+  EnvironmentalFlags2[EnvironmentalFlags2["IN_WATER"] = 1] = "IN_WATER";
+  EnvironmentalFlags2[EnvironmentalFlags2["IMMUNE_LAVA"] = 2] = "IMMUNE_LAVA";
+  EnvironmentalFlags2[EnvironmentalFlags2["IMMUNE_SLIME"] = 4] = "IMMUNE_SLIME";
+  return EnvironmentalFlags2;
+})(EnvironmentalFlags || {});
+function applyDamageEvent(target, amount, mod) {
+  return T_Damage(target, null, null, ZERO2, target.origin, ZERO2, amount, 0, 2 /* NO_ARMOR */, mod);
+}
+function applyEnvironmentalDamage(target, nowMs) {
+  const events = [];
+  let flags = target.environmentFlags ?? 0;
+  let enteredWater = false;
+  let leftWater = false;
+  if (target.waterlevel === WaterLevel.None) {
+    if ((flags & 1 /* IN_WATER */) !== 0) {
+      flags &= ~1 /* IN_WATER */;
+      leftWater = true;
+    }
+    if (target.airFinished < nowMs && target.painDebounceTime <= nowMs) {
+      const elapsedSeconds = Math.floor((nowMs - target.airFinished) / 1e3);
+      const amount = Math.min(15, 2 + 2 * elapsedSeconds);
+      const result = applyDamageEvent(target, amount, 17 /* WATER */);
+      target.painDebounceTime = nowMs + 1e3;
+      events.push({ mod: 17 /* WATER */, amount, result });
+    }
+  } else {
+    target.airFinished = nowMs + 9e3;
+    if ((flags & 1 /* IN_WATER */) === 0) {
+      flags |= 1 /* IN_WATER */;
+      enteredWater = true;
+      target.damageDebounceTime = 0;
+    }
+    if (target.damageDebounceTime <= nowMs) {
+      if ((target.watertype & CONTENTS_LAVA) !== 0 && (flags & 2 /* IMMUNE_LAVA */) === 0) {
+        const amount = 10 * target.waterlevel;
+        const result = applyDamageEvent(target, amount, 19 /* LAVA */);
+        target.damageDebounceTime = nowMs + 100;
+        events.push({ mod: 19 /* LAVA */, amount, result });
+      } else if ((target.watertype & CONTENTS_SLIME) !== 0 && (flags & 4 /* IMMUNE_SLIME */) === 0) {
+        const amount = 4 * target.waterlevel;
+        const result = applyDamageEvent(target, amount, 18 /* SLIME */);
+        target.damageDebounceTime = nowMs + 100;
+        events.push({ mod: 18 /* SLIME */, amount, result });
+      }
+    }
+  }
+  target.environmentFlags = flags;
+  return { events, enteredWater, leftWater };
+}
+function calculateFallingDamage(context) {
+  const {
+    impactDelta,
+    waterLevel,
+    onLadder = false,
+    isDead = false,
+    isPlayerModel = true,
+    isNoClip = false,
+    grappleBlockingFallDamage = false,
+    clampFreeFall = false,
+    skipDamage = false
+  } = context;
+  if (isDead || !isPlayerModel || isNoClip || grappleBlockingFallDamage || waterLevel === WaterLevel.Under) {
+    return { damage: 0, event: null, fallValue: 0, adjustedDelta: 0 };
+  }
+  let delta = impactDelta * impactDelta * 1e-4;
+  if (waterLevel === WaterLevel.Waist) {
+    delta *= 0.25;
+  } else if (waterLevel === WaterLevel.Feet) {
+    delta *= 0.5;
+  }
+  if (clampFreeFall) {
+    delta = Math.min(30, delta);
+  }
+  if (delta < 1) {
+    return { damage: 0, event: null, fallValue: 0, adjustedDelta: delta };
+  }
+  let event = null;
+  let damage = 0;
+  let fallValue = 0;
+  if (delta < 15) {
+    event = onLadder ? null : "footstep";
+  } else {
+    fallValue = Math.min(delta * 0.5, 40);
+    if (delta > 30) {
+      event = delta >= 55 ? "fallfar" : "fall";
+      damage = Math.max(1, (delta - 30) * 0.5);
+    } else {
+      event = "fallshort";
+    }
+  }
+  if (skipDamage) {
+    damage = 0;
+  }
+  return { damage, event, fallValue, adjustedDelta: delta };
+}
+function applyFallingDamage(target, context) {
+  const result = calculateFallingDamage(context);
+  if (result.damage > 0 && !context.skipDamage) {
+    T_Damage(
+      target,
+      null,
+      null,
+      { x: 0, y: 0, z: 1 },
+      target.origin,
+      ZERO2,
+      result.damage,
+      0,
+      2 /* NO_ARMOR */,
+      23 /* FALLING */
+    );
+  }
+  return result;
+}
+function applyCrushDamage(crusher, target, options = {}) {
+  const nonLivingDamage = options.nonLivingDamage ?? 1e5;
+  const gibDamage = options.gibDamage ?? 100;
+  const baseDamage = options.baseDamage ?? crusher.dmg ?? 10;
+  const amount = !target.isMonster && !target.isClient ? nonLivingDamage : target.health < 1 ? gibDamage : baseDamage;
+  const result = T_Damage(target, crusher, crusher, ZERO2, target.origin, ZERO2, amount, 1, 0 /* NONE */, 20 /* CRUSH */);
+  return { amount, result };
+}
+function absoluteBounds(ent) {
+  const mins = ent.mins ?? ZERO2;
+  const maxs = ent.maxs ?? ZERO2;
+  return {
+    mins: addVec3(ent.origin, mins),
+    maxs: addVec3(ent.origin, maxs)
+  };
+}
+function killBox(teleporter, targets, options = {}) {
+  if (teleporter.movetype === 1 /* Noclip */) {
+    return { events: [], cleared: true };
+  }
+  const mod = options.mod ?? 21 /* TELEFRAG */;
+  const teleBounds = absoluteBounds(teleporter);
+  const events = [];
+  let cleared = true;
+  for (const target of targets) {
+    if (target === teleporter || target.inUse === false) {
+      continue;
+    }
+    const solidity = target.solid ?? 0 /* Not */;
+    if (!target.takedamage || solidity === 0 /* Not */ || solidity === 1 /* Trigger */ || solidity === 3 /* Bsp */) {
+      continue;
+    }
+    if (!boxesIntersect(teleBounds, absoluteBounds(target))) {
+      continue;
+    }
+    const result = T_Damage(target, teleporter, teleporter, ZERO2, target.origin, ZERO2, 1e5, 0, 32 /* NO_PROTECTION */, mod);
+    events.push({ target, result });
+    if (!result || !result.killed || target.health > 0) {
+      cleared = false;
+    }
+  }
+  return { events, cleared };
+}
+
+// src/inventory/ammo.ts
+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";
+  return AmmoType2;
+})(AmmoType || {});
+var AMMO_TYPE_COUNT = Object.keys(AmmoType).length / 2;
+function createBaseAmmoCaps() {
+  const caps = Array(AMMO_TYPE_COUNT).fill(50);
+  caps[0 /* Bullets */] = 200;
+  caps[1 /* Shells */] = 100;
+  caps[4 /* Cells */] = 200;
+  return caps;
+}
+function clampAmmoCounts(counts, caps) {
+  const limit = Math.min(counts.length, caps.length);
+  const clamped = counts.slice(0, limit);
+  for (let i = 0; i < limit; i++) {
+    const cap = caps[i];
+    if (cap !== void 0) {
+      clamped[i] = Math.min(counts[i], cap);
+    }
+  }
+  return clamped;
+}
 
 // src/index.ts
 var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
@@ -714,12 +3400,74 @@ function createGame(engine, options) {
   };
 }
 export {
+  AIFlags,
+  AMMO_TYPE_COUNT,
+  ARMOR_INFO,
+  AmmoType,
+  ArmorType,
+  DamageFlags,
+  DamageMod,
   DeadFlag,
   ENTITY_FIELD_METADATA,
   Entity,
+  EntityDamageFlags,
   EntitySystem,
+  EnvironmentalFlags,
+  FL_NOVISIBLE,
   MoveType,
+  ORDERED_DAMAGE_MODS,
+  RANGE_MELEE,
+  RANGE_MID,
+  RANGE_NEAR,
+  RangeCategory,
+  SAVE_FORMAT_VERSION,
+  SPAWNFLAG_MONSTER_AMBUSH,
+  SaveStorage,
+  ServerFlags,
   Solid,
-  createGame
+  SpawnRegistry,
+  T_Damage,
+  T_RadiusDamage,
+  TraceMask,
+  ai_charge,
+  ai_face,
+  ai_move,
+  ai_run,
+  ai_stand,
+  ai_turn,
+  ai_walk,
+  applyCrushDamage,
+  applyEntityKeyValues,
+  applyEnvironmentalDamage,
+  applyFallingDamage,
+  applyPowerArmor,
+  applyRegularArmor,
+  applySaveFile,
+  calculateFallingDamage,
+  changeYaw,
+  clampAmmoCounts,
+  classifyRange,
+  createBaseAmmoCaps,
+  createDefaultSpawnRegistry,
+  createGame,
+  createSaveFile,
+  damageModName,
+  facingIdeal,
+  hasAnyDamageFlag,
+  hashGameState,
+  infront,
+  isZeroVector,
+  killBox,
+  parseEntityLump,
+  parseRereleaseSave,
+  parseSaveFile,
+  rangeTo,
+  registerDefaultSpawns,
+  setMovedir,
+  spawnEntitiesFromText,
+  spawnEntityFromDictionary,
+  summarizeRereleaseSave,
+  visible,
+  walkMove
 };
 //# sourceMappingURL=index.js.map