quake2ts 0.0.74 → 0.0.75

package/packages/game/dist/cjs/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   HEALTH_ITEMS: () => HEALTH_ITEMS,
   KEY_ITEMS: () => KEY_ITEMS,
   KeyId: () => KeyId,
+  M_MoveFrame: () => M_MoveFrame,
   MoveType: () => MoveType,
   ORDERED_DAMAGE_MODS: () => ORDERED_DAMAGE_MODS,
   POWERUP_ITEMS: () => POWERUP_ITEMS,
@@ -116,6 +117,7 @@ __export(index_exports, {
   infront: () => infront,
   isZeroVector: () => isZeroVector,
   killBox: () => killBox,
+  monster_think: () => monster_think,
   parseEntityLump: () => parseEntityLump,
   parseRereleaseSave: () => parseRereleaseSave,
   parseSaveFile: () => parseSaveFile,
@@ -3474,704 +3476,849 @@ function registerLightSpawns(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 };
+// src/ai/constants.ts
+var RANGE_MELEE = 20;
+var RANGE_NEAR = 440;
+var RANGE_MID = 940;
+var FL_NOTARGET = 1 << 5;
+var FL_NOVISIBLE = 1 << 24;
+var SPAWNFLAG_MONSTER_AMBUSH = 1 << 0;
+var AIFlags = /* @__PURE__ */ ((AIFlags2) => {
+  AIFlags2[AIFlags2["StandGround"] = 1] = "StandGround";
+  AIFlags2[AIFlags2["TempStandGround"] = 2] = "TempStandGround";
+  AIFlags2[AIFlags2["SoundTarget"] = 4] = "SoundTarget";
+  AIFlags2[AIFlags2["LostSight"] = 8] = "LostSight";
+  AIFlags2[AIFlags2["PursuitLastSeen"] = 16] = "PursuitLastSeen";
+  AIFlags2[AIFlags2["PursueNext"] = 32] = "PursueNext";
+  AIFlags2[AIFlags2["PursueTemp"] = 64] = "PursueTemp";
+  AIFlags2[AIFlags2["HoldFrame"] = 128] = "HoldFrame";
+  AIFlags2[AIFlags2["GoodGuy"] = 256] = "GoodGuy";
+  AIFlags2[AIFlags2["Brutal"] = 512] = "Brutal";
+  AIFlags2[AIFlags2["NoStep"] = 1024] = "NoStep";
+  AIFlags2[AIFlags2["Ducked"] = 2048] = "Ducked";
+  AIFlags2[AIFlags2["CombatPoint"] = 4096] = "CombatPoint";
+  AIFlags2[AIFlags2["Medic"] = 8192] = "Medic";
+  AIFlags2[AIFlags2["Resurrecting"] = 16384] = "Resurrecting";
+  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, distance2) {
+  if (distance2 === 0) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const radians = degToRad(yawDegrees);
+  return {
+    x: Math.cos(radians) * distance2,
+    y: Math.sin(radians) * distance2,
+    z: 0
+  };
 }
-function parseBoolean(text) {
-  const normalized = text.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes";
+function walkMove(self, yawDegrees, distance2) {
+  const delta = yawVector(yawDegrees, distance2);
+  const origin = self.origin;
+  origin.x += delta.x;
+  origin.y += delta.y;
+  origin.z += delta.z;
+  return true;
 }
-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 changeYaw(self, deltaSeconds) {
+  const current = angleMod(self.angles.y);
+  const ideal = self.ideal_yaw;
+  if (current === ideal) {
+    self.angles.y = current;
+    return;
   }
-}
-function applyEntityKeyValues(entity, values) {
-  if ("angle" in values && !("angles" in values)) {
-    entity.angles = { x: 0, y: Number.parseFloat(values.angle) || 0, z: 0 };
+  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;
   }
-  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;
-    }
+  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);
   }
-  entity.size = {
-    x: entity.maxs.x - entity.mins.x,
-    y: entity.maxs.y - entity.mins.y,
-    z: entity.maxs.z - entity.mins.z
+  return !(delta > 45 && delta < 315);
+}
+function ai_move(self, distance2) {
+  walkMove(self, self.angles.y, distance2);
+}
+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 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 ai_stand(self, deltaSeconds) {
+  changeYaw(self, deltaSeconds);
 }
-function consumeWhitespace(text, start) {
-  let index = start;
-  while (index < text.length && /\s/.test(text[index] ?? "")) {
-    index += 1;
+function ai_walk(self, distance2, deltaSeconds) {
+  setIdealYawTowards(self, self.goalentity);
+  changeYaw(self, deltaSeconds);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
-  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}`);
+function ai_turn(self, distance2, deltaSeconds) {
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
-  const quoted = parseQuoted(text, index + 1);
-  return { token: quoted.value, nextIndex: quoted.nextIndex };
+  changeYaw(self, deltaSeconds);
 }
-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);
+function ai_run(self, distance2, deltaSeconds) {
+  setIdealYawTowards(self, self.enemy ?? self.goalentity);
+  changeYaw(self, deltaSeconds);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
-  return entities;
 }
-var SpawnRegistry = class {
-  constructor() {
-    this.registry = /* @__PURE__ */ new Map();
-  }
-  register(classname, spawn) {
-    this.registry.set(classname, spawn);
+function ai_face(self, enemy, distance2, deltaSeconds) {
+  if (enemy) {
+    setIdealYawTowards(self, enemy);
   }
-  get(classname) {
-    return this.registry.get(classname);
+  changeYaw(self, deltaSeconds);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
-};
-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;
+function ai_charge(self, distance2, deltaSeconds) {
+  setIdealYawTowards(self, self.enemy);
+  changeYaw(self, deltaSeconds);
+  if (distance2 !== 0) {
+    walkMove(self, self.angles.y, distance2);
   }
-  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);
+}
+
+// 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
     }
   };
-  const spawnFunc = options.registry.get(classname);
-  if (!spawnFunc) {
-    warn(`${classname} does not have a spawn function`);
-    if (!isWorld) {
-      options.entities.freeImmediate(entity);
-    }
-    return null;
+}
+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(distance2) {
+  if (distance2 <= RANGE_MELEE) {
+    return "melee" /* Melee */;
   }
-  spawnFunc(entity, context);
-  if (!entity.inUse) {
-    return null;
+  if (distance2 <= RANGE_NEAR) {
+    return "near" /* Near */;
   }
-  options.entities.finalizeSpawn(entity);
-  return entity;
+  if (distance2 <= RANGE_MID) {
+    return "mid" /* Mid */;
+  }
+  return "far" /* Far */;
 }
-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);
-    }
+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 spawned;
+  return dot > -0.3;
 }
-function findPlayerStart(entities) {
-  return entities.find(
-    (entity) => entity.classname === "info_player_start"
-  );
+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;
 }
-function registerDefaultSpawns(game, 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);
-  registerTargetSpawns(registry);
-  registerMiscSpawns(registry);
-  registerItemSpawns(game, registry);
-  registerFuncSpawns(registry);
-  registerPathSpawns(registry);
-  registerLightSpawns(registry);
+
+// src/ai/targeting.ts
+function setIdealYawTowards2(self, other) {
+  const delta = {
+    x: other.origin.x - self.origin.x,
+    y: other.origin.y - self.origin.y,
+    z: other.origin.z - self.origin.z
+  };
+  self.ideal_yaw = vectorToYaw(delta);
 }
-function createDefaultSpawnRegistry(game) {
-  const registry = new SpawnRegistry();
-  registerDefaultSpawns(game, registry);
-  return registry;
+function faceYawInstantly(self) {
+  self.angles.y = angleMod(self.ideal_yaw);
 }
-
-// src/entities/callbacks.ts
-function createCallbackRegistry() {
-  return /* @__PURE__ */ new Map();
+function huntTarget(self, level) {
+  if (!self.enemy) return;
+  self.goalentity = self.enemy;
+  setIdealYawTowards2(self, self.enemy);
+  faceYawInstantly(self);
+  if ((self.monsterinfo.aiflags & 1 /* StandGround */) !== 0) {
+    self.monsterinfo.stand?.(self);
+  } else {
+    self.monsterinfo.run?.(self);
+    self.attack_finished_time = level.timeSeconds + 1;
+  }
 }
-function registerCallback(registry, name, fn) {
-  if (registry.has(name)) {
+function foundTarget(self, level, options) {
+  if (!self.enemy) return;
+  if ((self.enemy.svflags & 8 /* Player */) !== 0) {
+    level.sightEntity = self;
+    level.sightEntityFrame = level.frameNumber;
+    self.light_level = 128;
+  }
+  self.show_hostile = level.timeSeconds + 1;
+  const lastSighting = self.monsterinfo.last_sighting;
+  lastSighting.x = self.enemy.origin.x;
+  lastSighting.y = self.enemy.origin.y;
+  lastSighting.z = self.enemy.origin.z;
+  self.trail_time = level.timeSeconds;
+  self.monsterinfo.trail_time = level.timeSeconds;
+  if (!self.combattarget) {
+    huntTarget(self, level);
     return;
   }
-  registry.set(name, fn);
+  const pickTarget = options?.pickTarget;
+  const movetarget = pickTarget?.(self.combattarget) ?? self.enemy;
+  self.goalentity = movetarget;
+  self.movetarget = movetarget;
+  self.combattarget = void 0;
+  self.monsterinfo.aiflags |= 4096 /* CombatPoint */;
+  if (self.movetarget) {
+    self.movetarget.targetname = void 0;
+  }
+  self.monsterinfo.pausetime = 0;
+  self.monsterinfo.run?.(self);
 }
-
-// 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);
-        }
-      }
+function classifyClientVisibility(self, other, level, trace) {
+  const distance2 = rangeTo(self, other);
+  const range = classifyRange(distance2);
+  if (range === "far" /* Far */) return false;
+  if (other.light_level <= 5) return false;
+  if (!visible(self, other, trace, { throughGlass: false })) return false;
+  if (range === "near" /* Near */) {
+    return level.timeSeconds <= other.show_hostile || infront(self, other);
+  }
+  if (range === "mid" /* Mid */) {
+    return infront(self, other);
+  }
+  return true;
+}
+function updateSoundChase(self, client, level, hearability, trace) {
+  if ((self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) !== 0) {
+    if (!visible(self, client, trace)) return false;
+  } else if (hearability.canHear && !hearability.canHear(self, client)) {
+    return false;
+  }
+  const delta = subtractVec3(client.origin, self.origin);
+  if (lengthVec3(delta) > 1e3) return false;
+  if (hearability.areasConnected && !hearability.areasConnected(self, client)) return false;
+  self.ideal_yaw = vectorToYaw(delta);
+  faceYawInstantly(self);
+  self.monsterinfo.aiflags |= 4 /* SoundTarget */;
+  self.enemy = client;
+  return true;
+}
+function chooseCandidate(self, level) {
+  if (level.sightEntity && level.sightEntityFrame >= level.frameNumber - 1 && (self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) === 0) {
+    if (level.sightEntity.enemy !== self.enemy) {
+      return { candidate: level.sightEntity, heardit: false };
     }
+    return { candidate: null, heardit: false };
   }
-  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;
-      }
-    };
+  if (level.soundEntity && level.soundEntityFrame >= level.frameNumber - 1) {
+    return { candidate: level.soundEntity, heardit: true };
   }
-  reset(startTimeMs) {
-    this.timeMs = startTimeMs;
-    this.frame = 0;
+  if (!self.enemy && level.sound2Entity && level.sound2EntityFrame >= level.frameNumber - 1 && (self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) === 0) {
+    return { candidate: level.sound2Entity, heardit: true };
   }
-  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;
+  if (level.sightClient) {
+    return { candidate: level.sightClient, heardit: false };
   }
-  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);
-    }
+  return { candidate: null, heardit: false };
+}
+function rejectNotargetEntity(client) {
+  if ((client.flags & FL_NOTARGET) !== 0) return true;
+  if ((client.svflags & 4 /* Monster */) !== 0 && client.enemy) {
+    return (client.enemy.flags & FL_NOTARGET) !== 0;
   }
-  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;
-      }
+  if (client.enemy && (client.enemy.flags & FL_NOTARGET) !== 0) return true;
+  return false;
+}
+function findTarget(self, level, trace, hearability = {}) {
+  if ((self.monsterinfo.aiflags & 256 /* GoodGuy */) !== 0) {
+    if (self.goalentity?.classname === "target_actor") {
+      return false;
     }
-    handlers.length = writeIndex;
-    this.stageCompactionNeeded[stage] = false;
+    return false;
   }
-  get time() {
-    return this.timeMs;
+  if ((self.monsterinfo.aiflags & 4096 /* CombatPoint */) !== 0) {
+    return false;
   }
-  get frameNumber() {
-    return this.frame;
+  const { candidate, heardit } = chooseCandidate(self, level);
+  if (!candidate || !candidate.inUse) return false;
+  if (candidate === self.enemy) return true;
+  if (rejectNotargetEntity(candidate)) return false;
+  if (!heardit) {
+    if (!classifyClientVisibility(self, candidate, level, trace)) return false;
+    self.monsterinfo.aiflags &= ~4 /* SoundTarget */;
+    self.enemy = candidate;
+  } else if (!updateSoundChase(self, candidate, level, hearability, trace)) {
+    return false;
   }
-};
+  foundTarget(self, level);
+  if ((self.monsterinfo.aiflags & 4 /* SoundTarget */) === 0) {
+    self.monsterinfo.sight?.(self, self.enemy);
+  }
+  return true;
+}
 
-// src/level.ts
-var ZERO_STATE = {
-  frameNumber: 0,
-  timeSeconds: 0,
-  previousTimeSeconds: 0,
-  deltaSeconds: 0
-};
-var LevelClock = class {
-  constructor() {
-    this.state = ZERO_STATE;
+// src/ai/monster.ts
+function M_MoveFrame(self) {
+  const move = self.monsterinfo.current_move;
+  if (!move) {
+    return;
   }
-  start(startTimeMs) {
-    const startSeconds = startTimeMs / 1e3;
-    this.state = {
-      frameNumber: 0,
-      timeSeconds: startSeconds,
-      previousTimeSeconds: startSeconds,
-      deltaSeconds: 0
-    };
+  if (self.frame < move.firstframe || self.frame > move.lastframe) {
+    self.monsterinfo.aiflags &= ~128 /* HoldFrame */;
+    self.frame = move.firstframe;
   }
-  tick(context) {
-    this.state = {
-      frameNumber: context.frame,
-      timeSeconds: context.timeMs / 1e3,
-      previousTimeSeconds: context.previousTimeMs / 1e3,
-      deltaSeconds: context.deltaSeconds
-    };
-    return this.state;
+  if ((self.monsterinfo.aiflags & 128 /* HoldFrame */) !== 0) {
+    return;
   }
-  get current() {
-    return this.state;
+  const index = self.frame - move.firstframe;
+  const frame = move.frames[index];
+  if (frame.ai) {
+    frame.ai(self, frame.dist);
   }
-  restore(state) {
-    this.state = { ...state };
+  if (frame.think) {
+    frame.think(self);
   }
-};
-
-// src/ai/constants.ts
-var RANGE_MELEE = 20;
-var RANGE_NEAR = 440;
-var RANGE_MID = 940;
-var FL_NOTARGET = 1 << 5;
-var FL_NOVISIBLE = 1 << 24;
-var SPAWNFLAG_MONSTER_AMBUSH = 1 << 0;
-var AIFlags = /* @__PURE__ */ ((AIFlags2) => {
-  AIFlags2[AIFlags2["StandGround"] = 1] = "StandGround";
-  AIFlags2[AIFlags2["TempStandGround"] = 2] = "TempStandGround";
-  AIFlags2[AIFlags2["SoundTarget"] = 4] = "SoundTarget";
-  AIFlags2[AIFlags2["LostSight"] = 8] = "LostSight";
-  AIFlags2[AIFlags2["PursuitLastSeen"] = 16] = "PursuitLastSeen";
-  AIFlags2[AIFlags2["PursueNext"] = 32] = "PursueNext";
-  AIFlags2[AIFlags2["PursueTemp"] = 64] = "PursueTemp";
-  AIFlags2[AIFlags2["HoldFrame"] = 128] = "HoldFrame";
-  AIFlags2[AIFlags2["GoodGuy"] = 256] = "GoodGuy";
-  AIFlags2[AIFlags2["Brutal"] = 512] = "Brutal";
-  AIFlags2[AIFlags2["NoStep"] = 1024] = "NoStep";
-  AIFlags2[AIFlags2["Ducked"] = 2048] = "Ducked";
-  AIFlags2[AIFlags2["CombatPoint"] = 4096] = "CombatPoint";
-  AIFlags2[AIFlags2["Medic"] = 8192] = "Medic";
-  AIFlags2[AIFlags2["Resurrecting"] = 16384] = "Resurrecting";
-  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 || {});
+  if (!self.inUse) {
+    return;
+  }
+  self.frame++;
+  if (self.frame > move.lastframe) {
+    if (move.endfunc) {
+      move.endfunc(self);
+      if (self.monsterinfo.current_move !== move) {
+        return;
+      }
+    }
+  }
+}
+function monster_think(self, context) {
+  M_MoveFrame(self);
+  const time = context && typeof context.timeSeconds === "number" ? context.timeSeconds : self.nextthink;
+  self.nextthink = time + 0.1;
+}
 
-// src/ai/movement.ts
-function yawVector(yawDegrees, distance2) {
-  if (distance2 === 0) {
-    return { x: 0, y: 0, z: 0 };
+// src/entities/monsters/soldier.ts
+var MONSTER_TICK = 0.1;
+function monster_ai_stand(self, dist) {
+  ai_stand(self, MONSTER_TICK);
+}
+function monster_ai_walk(self, dist) {
+  ai_walk(self, dist, MONSTER_TICK);
+}
+function monster_ai_run(self, dist) {
+  ai_run(self, dist, MONSTER_TICK);
+}
+function monster_ai_charge(self, dist) {
+  ai_charge(self, dist, MONSTER_TICK);
+}
+var stand_move;
+var walk_move;
+var run_move;
+var attack_move;
+function soldier_stand(self) {
+  self.monsterinfo.current_move = stand_move;
+}
+function soldier_walk(self) {
+  self.monsterinfo.current_move = walk_move;
+}
+function soldier_run(self) {
+  if (self.enemy && self.enemy.health > 0) {
+    self.monsterinfo.current_move = run_move;
+  } else {
+    self.monsterinfo.current_move = stand_move;
   }
-  const radians = degToRad(yawDegrees);
-  return {
-    x: Math.cos(radians) * distance2,
-    y: Math.sin(radians) * distance2,
-    z: 0
+}
+function soldier_attack(self) {
+  self.monsterinfo.current_move = attack_move;
+}
+function soldier_fire(self) {
+}
+var stand_frames = Array.from({ length: 30 }, () => ({
+  ai: monster_ai_stand,
+  dist: 0
+}));
+stand_move = {
+  firstframe: 0,
+  lastframe: 29,
+  frames: stand_frames,
+  endfunc: soldier_stand
+};
+var walk_frames = Array.from({ length: 40 }, () => ({
+  ai: monster_ai_walk,
+  dist: 2
+}));
+walk_move = {
+  firstframe: 30,
+  lastframe: 69,
+  frames: walk_frames,
+  endfunc: soldier_walk
+};
+var run_frames = Array.from({ length: 20 }, () => ({
+  ai: monster_ai_run,
+  dist: 10
+}));
+run_move = {
+  firstframe: 70,
+  lastframe: 89,
+  frames: run_frames,
+  endfunc: soldier_run
+};
+var attack_frames = Array.from({ length: 10 }, (_, i) => ({
+  ai: monster_ai_charge,
+  dist: 0,
+  think: i === 5 ? soldier_fire : null
+}));
+attack_move = {
+  firstframe: 90,
+  lastframe: 99,
+  frames: attack_frames,
+  endfunc: soldier_run
+};
+function SP_monster_soldier(self, context) {
+  self.model = "models/monsters/soldier/tris.md2";
+  self.mins = { x: -16, y: -16, z: -24 };
+  self.maxs = { x: 16, y: 16, z: 32 };
+  self.movetype = 5 /* Step */;
+  self.solid = 2 /* BoundingBox */;
+  self.health = 20;
+  self.max_health = 20;
+  self.mass = 100;
+  self.pain = (self2, other, kick, damage) => {
   };
+  self.die = (self2, inflictor, attacker, damage, point) => {
+    self2.deadflag = 2 /* Dead */;
+    self2.solid = 0 /* Not */;
+  };
+  self.monsterinfo.stand = soldier_stand;
+  self.monsterinfo.walk = soldier_walk;
+  self.monsterinfo.run = soldier_run;
+  self.monsterinfo.attack = soldier_attack;
+  self.think = monster_think;
+  soldier_stand(self);
+  self.nextthink = self.timestamp + MONSTER_TICK;
 }
-function walkMove(self, yawDegrees, distance2) {
-  const delta = yawVector(yawDegrees, distance2);
-  const origin = self.origin;
-  origin.x += delta.x;
-  origin.y += delta.y;
-  origin.z += delta.z;
-  return true;
+function registerMonsterSpawns(registry) {
+  registry.register("monster_soldier", SP_monster_soldier);
 }
-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);
+
+// 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 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);
+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;
   }
-  return !(delta > 45 && delta < 315);
-}
-function ai_move(self, distance2) {
-  walkMove(self, self.angles.y, distance2);
 }
-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
+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
   };
-  self.ideal_yaw = vectorToYaw(toTarget);
 }
-function ai_stand(self, deltaSeconds) {
-  changeYaw(self, deltaSeconds);
+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 ai_walk(self, distance2, deltaSeconds) {
-  setIdealYawTowards(self, self.goalentity);
-  changeYaw(self, deltaSeconds);
-  if (distance2 !== 0) {
-    walkMove(self, self.angles.y, distance2);
+function consumeWhitespace(text, start) {
+  let index = start;
+  while (index < text.length && /\s/.test(text[index] ?? "")) {
+    index += 1;
   }
+  return index;
 }
-function ai_turn(self, distance2, deltaSeconds) {
-  if (distance2 !== 0) {
-    walkMove(self, self.angles.y, distance2);
+function parseToken(text, start) {
+  const index = consumeWhitespace(text, start);
+  if (index >= text.length) {
+    return { token: null, nextIndex: index };
   }
-  changeYaw(self, deltaSeconds);
+  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 ai_run(self, distance2, deltaSeconds) {
-  setIdealYawTowards(self, self.enemy ?? self.goalentity);
-  changeYaw(self, deltaSeconds);
-  if (distance2 !== 0) {
-    walkMove(self, self.angles.y, distance2);
+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;
 }
-function ai_face(self, enemy, distance2, deltaSeconds) {
-  if (enemy) {
-    setIdealYawTowards(self, enemy);
+var SpawnRegistry = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
   }
-  changeYaw(self, deltaSeconds);
-  if (distance2 !== 0) {
-    walkMove(self, self.angles.y, distance2);
+  register(classname, spawn) {
+    this.registry.set(classname, spawn);
   }
-}
-function ai_charge(self, distance2, deltaSeconds) {
-  setIdealYawTowards(self, self.enemy);
-  changeYaw(self, deltaSeconds);
-  if (distance2 !== 0) {
-    walkMove(self, self.angles.y, distance2);
+  get(classname) {
+    return this.registry.get(classname);
   }
+};
+function defaultWarn(message) {
+  void message;
 }
-
-// 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 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);
     }
   };
-}
-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(distance2) {
-  if (distance2 <= RANGE_MELEE) {
-    return "melee" /* Melee */;
-  }
-  if (distance2 <= RANGE_NEAR) {
-    return "near" /* Near */;
+  const spawnFunc = options.registry.get(classname);
+  if (!spawnFunc) {
+    warn(`${classname} does not have a spawn function`);
+    if (!isWorld) {
+      options.entities.freeImmediate(entity);
+    }
+    return null;
   }
-  if (distance2 <= RANGE_MID) {
-    return "mid" /* Mid */;
+  spawnFunc(entity, context);
+  if (!entity.inUse) {
+    return null;
   }
-  return "far" /* Far */;
+  options.entities.finalizeSpawn(entity);
+  return entity;
 }
-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;
+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 dot > -0.3;
+  return spawned;
 }
-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;
+function findPlayerStart(entities) {
+  return entities.find(
+    (entity) => entity.classname === "info_player_start"
+  );
 }
-
-// src/ai/targeting.ts
-function setIdealYawTowards2(self, other) {
-  const delta = {
-    x: other.origin.x - self.origin.x,
-    y: other.origin.y - self.origin.y,
-    z: other.origin.z - self.origin.z
-  };
-  self.ideal_yaw = vectorToYaw(delta);
+function registerDefaultSpawns(game, 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);
+  registerTargetSpawns(registry);
+  registerMiscSpawns(registry);
+  registerItemSpawns(game, registry);
+  registerFuncSpawns(registry);
+  registerPathSpawns(registry);
+  registerLightSpawns(registry);
+  registerMonsterSpawns(registry);
 }
-function faceYawInstantly(self) {
-  self.angles.y = angleMod(self.ideal_yaw);
+function createDefaultSpawnRegistry(game) {
+  const registry = new SpawnRegistry();
+  registerDefaultSpawns(game, registry);
+  return registry;
 }
-function huntTarget(self, level) {
-  if (!self.enemy) return;
-  self.goalentity = self.enemy;
-  setIdealYawTowards2(self, self.enemy);
-  faceYawInstantly(self);
-  if ((self.monsterinfo.aiflags & 1 /* StandGround */) !== 0) {
-    self.monsterinfo.stand?.(self);
-  } else {
-    self.monsterinfo.run?.(self);
-    self.attack_finished_time = level.timeSeconds + 1;
-  }
+
+// src/entities/callbacks.ts
+function createCallbackRegistry() {
+  return /* @__PURE__ */ new Map();
 }
-function foundTarget(self, level, options) {
-  if (!self.enemy) return;
-  if ((self.enemy.svflags & 8 /* Player */) !== 0) {
-    level.sightEntity = self;
-    level.sightEntityFrame = level.frameNumber;
-    self.light_level = 128;
-  }
-  self.show_hostile = level.timeSeconds + 1;
-  const lastSighting = self.monsterinfo.last_sighting;
-  lastSighting.x = self.enemy.origin.x;
-  lastSighting.y = self.enemy.origin.y;
-  lastSighting.z = self.enemy.origin.z;
-  self.trail_time = level.timeSeconds;
-  self.monsterinfo.trail_time = level.timeSeconds;
-  if (!self.combattarget) {
-    huntTarget(self, level);
+function registerCallback(registry, name, fn) {
+  if (registry.has(name)) {
     return;
   }
-  const pickTarget = options?.pickTarget;
-  const movetarget = pickTarget?.(self.combattarget) ?? self.enemy;
-  self.goalentity = movetarget;
-  self.movetarget = movetarget;
-  self.combattarget = void 0;
-  self.monsterinfo.aiflags |= 4096 /* CombatPoint */;
-  if (self.movetarget) {
-    self.movetarget.targetname = void 0;
-  }
-  self.monsterinfo.pausetime = 0;
-  self.monsterinfo.run?.(self);
+  registry.set(name, fn);
 }
-function classifyClientVisibility(self, other, level, trace) {
-  const distance2 = rangeTo(self, other);
-  const range = classifyRange(distance2);
-  if (range === "far" /* Far */) return false;
-  if (other.light_level <= 5) return false;
-  if (!visible(self, other, trace, { throughGlass: false })) return false;
-  if (range === "near" /* Near */) {
-    return level.timeSeconds <= other.show_hostile || infront(self, other);
+
+// 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);
+        }
+      }
+    }
   }
-  if (range === "mid" /* Mid */) {
-    return infront(self, other);
+  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;
+      }
+    };
   }
-  return true;
-}
-function updateSoundChase(self, client, level, hearability, trace) {
-  if ((self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) !== 0) {
-    if (!visible(self, client, trace)) return false;
-  } else if (hearability.canHear && !hearability.canHear(self, client)) {
-    return false;
+  reset(startTimeMs) {
+    this.timeMs = startTimeMs;
+    this.frame = 0;
   }
-  const delta = subtractVec3(client.origin, self.origin);
-  if (lengthVec3(delta) > 1e3) return false;
-  if (hearability.areasConnected && !hearability.areasConnected(self, client)) return false;
-  self.ideal_yaw = vectorToYaw(delta);
-  faceYawInstantly(self);
-  self.monsterinfo.aiflags |= 4 /* SoundTarget */;
-  self.enemy = client;
-  return true;
-}
-function chooseCandidate(self, level) {
-  if (level.sightEntity && level.sightEntityFrame >= level.frameNumber - 1 && (self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) === 0) {
-    if (level.sightEntity.enemy !== self.enemy) {
-      return { candidate: level.sightEntity, heardit: false };
+  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");
     }
-    return { candidate: null, heardit: false };
+    this.runStage("simulate", context);
+    this.runStage("finish", context);
+    return context;
   }
-  if (level.soundEntity && level.soundEntityFrame >= level.frameNumber - 1) {
-    return { candidate: level.soundEntity, heardit: true };
+  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);
+    }
   }
-  if (!self.enemy && level.sound2Entity && level.sound2EntityFrame >= level.frameNumber - 1 && (self.spawnflags & SPAWNFLAG_MONSTER_AMBUSH) === 0) {
-    return { candidate: level.sound2Entity, heardit: true };
+  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;
   }
-  if (level.sightClient) {
-    return { candidate: level.sightClient, heardit: false };
+  get time() {
+    return this.timeMs;
   }
-  return { candidate: null, heardit: false };
-}
-function rejectNotargetEntity(client) {
-  if ((client.flags & FL_NOTARGET) !== 0) return true;
-  if ((client.svflags & 4 /* Monster */) !== 0 && client.enemy) {
-    return (client.enemy.flags & FL_NOTARGET) !== 0;
+  get frameNumber() {
+    return this.frame;
   }
-  if (client.enemy && (client.enemy.flags & FL_NOTARGET) !== 0) return true;
-  return false;
-}
-function findTarget(self, level, trace, hearability = {}) {
-  if ((self.monsterinfo.aiflags & 256 /* GoodGuy */) !== 0) {
-    if (self.goalentity?.classname === "target_actor") {
-      return false;
-    }
-    return false;
+};
+
+// src/level.ts
+var ZERO_STATE = {
+  frameNumber: 0,
+  timeSeconds: 0,
+  previousTimeSeconds: 0,
+  deltaSeconds: 0
+};
+var LevelClock = class {
+  constructor() {
+    this.state = ZERO_STATE;
   }
-  if ((self.monsterinfo.aiflags & 4096 /* CombatPoint */) !== 0) {
-    return false;
+  start(startTimeMs) {
+    const startSeconds = startTimeMs / 1e3;
+    this.state = {
+      frameNumber: 0,
+      timeSeconds: startSeconds,
+      previousTimeSeconds: startSeconds,
+      deltaSeconds: 0
+    };
   }
-  const { candidate, heardit } = chooseCandidate(self, level);
-  if (!candidate || !candidate.inUse) return false;
-  if (candidate === self.enemy) return true;
-  if (rejectNotargetEntity(candidate)) return false;
-  if (!heardit) {
-    if (!classifyClientVisibility(self, candidate, level, trace)) return false;
-    self.monsterinfo.aiflags &= ~4 /* SoundTarget */;
-    self.enemy = candidate;
-  } else if (!updateSoundChase(self, candidate, level, hearability, trace)) {
-    return false;
+  tick(context) {
+    this.state = {
+      frameNumber: context.frame,
+      timeSeconds: context.timeMs / 1e3,
+      previousTimeSeconds: context.previousTimeMs / 1e3,
+      deltaSeconds: context.deltaSeconds
+    };
+    return this.state;
   }
-  foundTarget(self, level);
-  if ((self.monsterinfo.aiflags & 4 /* SoundTarget */) === 0) {
-    self.monsterinfo.sight?.(self, self.enemy);
+  get current() {
+    return this.state;
   }
-  return true;
-}
+  restore(state) {
+    this.state = { ...state };
+  }
+};
 
 // src/checksum.ts
 var FNV_OFFSET_BASIS = 2166136261;
@@ -5552,6 +5699,7 @@ function createGame({ trace, pointcontents }, engine, options) {
   HEALTH_ITEMS,
   KEY_ITEMS,
   KeyId,
+  M_MoveFrame,
   MoveType,
   ORDERED_DAMAGE_MODS,
   POWERUP_ITEMS,
@@ -5628,6 +5776,7 @@ function createGame({ trace, pointcontents }, engine, options) {
   infront,
   isZeroVector,
   killBox,
+  monster_think,
   parseEntityLump,
   parseRereleaseSave,
   parseSaveFile,