quake2ts 0.0.7

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

@@ -0,0 +1,758 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DeadFlag: () => DeadFlag,
+  ENTITY_FIELD_METADATA: () => ENTITY_FIELD_METADATA,
+  Entity: () => Entity,
+  EntitySystem: () => EntitySystem,
+  MoveType: () => MoveType,
+  Solid: () => Solid,
+  createGame: () => createGame
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../shared/dist/esm/index.js
+var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD = Math.PI / 180;
+var DEG2RAD_FACTOR = Math.PI / 180;
+var RAD2DEG_FACTOR = 180 / Math.PI;
+var CONTENTS_SOLID = 1 << 0;
+var CONTENTS_WINDOW = 1 << 1;
+var CONTENTS_AUX = 1 << 2;
+var CONTENTS_LAVA = 1 << 3;
+var CONTENTS_SLIME = 1 << 4;
+var CONTENTS_WATER = 1 << 5;
+var CONTENTS_MIST = 1 << 6;
+var CONTENTS_NO_WATERJUMP = 1 << 13;
+var CONTENTS_PROJECTILECLIP = 1 << 14;
+var CONTENTS_AREAPORTAL = 1 << 15;
+var CONTENTS_PLAYERCLIP = 1 << 16;
+var CONTENTS_MONSTERCLIP = 1 << 17;
+var CONTENTS_CURRENT_0 = 1 << 18;
+var CONTENTS_CURRENT_90 = 1 << 19;
+var CONTENTS_CURRENT_180 = 1 << 20;
+var CONTENTS_CURRENT_270 = 1 << 21;
+var CONTENTS_CURRENT_UP = 1 << 22;
+var CONTENTS_CURRENT_DOWN = 1 << 23;
+var CONTENTS_ORIGIN = 1 << 24;
+var CONTENTS_MONSTER = 1 << 25;
+var CONTENTS_DEADMONSTER = 1 << 26;
+var CONTENTS_DETAIL = 1 << 27;
+var CONTENTS_TRANSLUCENT = 1 << 28;
+var CONTENTS_LADDER = 1 << 29;
+var CONTENTS_PLAYER = 1 << 30;
+var CONTENTS_PROJECTILE = 1 << 31;
+var SURF_LIGHT = 1 << 0;
+var SURF_SLICK = 1 << 1;
+var SURF_SKY = 1 << 2;
+var SURF_WARP = 1 << 3;
+var SURF_TRANS33 = 1 << 4;
+var SURF_TRANS66 = 1 << 5;
+var SURF_FLOWING = 1 << 6;
+var SURF_NODRAW = 1 << 7;
+var SURF_ALPHATEST = 1 << 25;
+var SURF_N64_UV = 1 << 28;
+var SURF_N64_SCROLL_X = 1 << 29;
+var SURF_N64_SCROLL_Y = 1 << 30;
+var SURF_N64_SCROLL_FLIP = 1 << 31;
+var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
+var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+var MAX_CLIENTS = 256;
+var MAX_LIGHTSTYLES = 256;
+var MAX_MODELS = 8192;
+var MAX_SOUNDS = 2048;
+var MAX_IMAGES = 512;
+var MAX_ITEMS = 256;
+var MAX_GENERAL = MAX_CLIENTS * 2;
+var MAX_SHADOW_LIGHTS = 256;
+var MAX_WHEEL_ITEMS = 32;
+var ConfigStringIndex = ((ConfigStringIndex2) => {
+  ConfigStringIndex2[ConfigStringIndex2["Name"] = 0] = "Name";
+  ConfigStringIndex2[ConfigStringIndex2["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex2[ConfigStringIndex2["Sky"] = 2] = "Sky";
+  ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex2[ConfigStringIndex2["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex2[ConfigStringIndex2["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex2[ConfigStringIndex2["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex2[ConfigStringIndex2["Models"] = 62] = "Models";
+  ConfigStringIndex2[ConfigStringIndex2["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex2[ConfigStringIndex2["Images"] = ConfigStringIndex2.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex2[ConfigStringIndex2["Lights"] = ConfigStringIndex2.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex2[ConfigStringIndex2["ShadowLights"] = ConfigStringIndex2.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex2[ConfigStringIndex2["Items"] = ConfigStringIndex2.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex2[ConfigStringIndex2["PlayerSkins"] = ConfigStringIndex2.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex2[ConfigStringIndex2["General"] = ConfigStringIndex2.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex2[ConfigStringIndex2["WheelWeapons"] = ConfigStringIndex2.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex2[ConfigStringIndex2["WheelAmmo"] = ConfigStringIndex2.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex2[ConfigStringIndex2["WheelPowerups"] = ConfigStringIndex2.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex2[ConfigStringIndex2["CdLoopCount"] = ConfigStringIndex2.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex2[ConfigStringIndex2["GameStyle"] = ConfigStringIndex2.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex2[ConfigStringIndex2["MaxConfigStrings"] = ConfigStringIndex2.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex2;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+
+// src/entities/entity.ts
+var MoveType = /* @__PURE__ */ ((MoveType2) => {
+  MoveType2[MoveType2["None"] = 0] = "None";
+  MoveType2[MoveType2["Noclip"] = 1] = "Noclip";
+  MoveType2[MoveType2["Push"] = 2] = "Push";
+  MoveType2[MoveType2["Stop"] = 3] = "Stop";
+  MoveType2[MoveType2["Walk"] = 4] = "Walk";
+  MoveType2[MoveType2["Step"] = 5] = "Step";
+  MoveType2[MoveType2["Fly"] = 6] = "Fly";
+  MoveType2[MoveType2["Toss"] = 7] = "Toss";
+  MoveType2[MoveType2["FlyMissile"] = 8] = "FlyMissile";
+  MoveType2[MoveType2["Bounce"] = 9] = "Bounce";
+  return MoveType2;
+})(MoveType || {});
+var Solid = /* @__PURE__ */ ((Solid2) => {
+  Solid2[Solid2["Not"] = 0] = "Not";
+  Solid2[Solid2["Trigger"] = 1] = "Trigger";
+  Solid2[Solid2["BoundingBox"] = 2] = "BoundingBox";
+  Solid2[Solid2["Bsp"] = 3] = "Bsp";
+  return Solid2;
+})(Solid || {});
+var DeadFlag = /* @__PURE__ */ ((DeadFlag2) => {
+  DeadFlag2[DeadFlag2["Alive"] = 0] = "Alive";
+  DeadFlag2[DeadFlag2["Dying"] = 1] = "Dying";
+  DeadFlag2[DeadFlag2["Dead"] = 2] = "Dead";
+  DeadFlag2[DeadFlag2["Respawnable"] = 3] = "Respawnable";
+  return DeadFlag2;
+})(DeadFlag || {});
+var ZERO = { ...ZERO_VEC3 };
+function copyVec3() {
+  return { ...ZERO };
+}
+var Entity = class {
+  constructor(index) {
+    this.inUse = false;
+    this.freePending = false;
+    this.linkPrevious = null;
+    this.linkNext = null;
+    this.classname = "";
+    this.spawnflags = 0;
+    this.origin = copyVec3();
+    this.old_origin = copyVec3();
+    this.velocity = copyVec3();
+    this.avelocity = copyVec3();
+    this.angles = copyVec3();
+    this.mins = copyVec3();
+    this.maxs = copyVec3();
+    this.size = copyVec3();
+    this.mass = 0;
+    this.gravity = 1;
+    this.movetype = 0 /* None */;
+    this.modelindex = 0;
+    this.frame = 0;
+    this.skin = 0;
+    this.effects = 0;
+    this.renderfx = 0;
+    this.health = 0;
+    this.max_health = 0;
+    this.takedamage = false;
+    this.dmg = 0;
+    this.deadflag = 0 /* Alive */;
+    this.enemy = null;
+    this.movetarget = null;
+    this.goalentity = null;
+    this.ideal_yaw = 0;
+    this.yaw_speed = 0;
+    this.groundentity = null;
+    this.groundentity_linkcount = 0;
+    this.waterlevel = 0;
+    this.watertype = 0;
+    this.nextthink = 0;
+    this.solid = 0 /* Not */;
+    this.flags = 0;
+    this.svflags = 0;
+    this.index = index;
+  }
+  reset() {
+    this.inUse = false;
+    this.freePending = false;
+    this.linkPrevious = null;
+    this.linkNext = null;
+    this.classname = "";
+    this.spawnflags = 0;
+    this.target = void 0;
+    this.targetname = void 0;
+    this.team = void 0;
+    this.message = void 0;
+    this.origin = copyVec3();
+    this.old_origin = copyVec3();
+    this.velocity = copyVec3();
+    this.avelocity = copyVec3();
+    this.angles = copyVec3();
+    this.mins = copyVec3();
+    this.maxs = copyVec3();
+    this.size = copyVec3();
+    this.mass = 0;
+    this.gravity = 1;
+    this.movetype = 0 /* None */;
+    this.modelindex = 0;
+    this.frame = 0;
+    this.skin = 0;
+    this.effects = 0;
+    this.renderfx = 0;
+    this.health = 0;
+    this.max_health = 0;
+    this.takedamage = false;
+    this.dmg = 0;
+    this.deadflag = 0 /* Alive */;
+    this.enemy = null;
+    this.movetarget = null;
+    this.goalentity = null;
+    this.ideal_yaw = 0;
+    this.yaw_speed = 0;
+    this.groundentity = null;
+    this.groundentity_linkcount = 0;
+    this.waterlevel = 0;
+    this.watertype = 0;
+    this.nextthink = 0;
+    this.think = void 0;
+    this.touch = void 0;
+    this.use = void 0;
+    this.pain = void 0;
+    this.die = void 0;
+    this.solid = 0 /* Not */;
+    this.flags = 0;
+    this.svflags = 0;
+  }
+};
+var ENTITY_FIELD_METADATA = [
+  { name: "classname", type: "string", save: true },
+  { name: "spawnflags", type: "int", save: true },
+  { name: "target", type: "string", save: true },
+  { name: "targetname", type: "string", save: true },
+  { name: "team", type: "string", save: true },
+  { name: "message", type: "string", 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: "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: "modelindex", type: "int", save: true },
+  { name: "frame", type: "int", save: true },
+  { name: "skin", type: "int", save: true },
+  { name: "effects", type: "int", save: true },
+  { name: "renderfx", type: "int", save: true },
+  { name: "health", type: "int", save: true },
+  { name: "max_health", type: "int", save: true },
+  { name: "takedamage", type: "boolean", save: true },
+  { name: "dmg", type: "int", save: true },
+  { name: "deadflag", type: "int", save: true },
+  { name: "enemy", type: "entity", save: true },
+  { name: "movetarget", 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: "groundentity", type: "entity", save: true },
+  { name: "groundentity_linkcount", type: "int", save: true },
+  { name: "waterlevel", type: "int", save: true },
+  { name: "watertype", type: "int", save: true },
+  { name: "nextthink", type: "float", save: true },
+  { name: "solid", type: "int", save: true },
+  { name: "flags", type: "int", save: true },
+  { name: "svflags", type: "int", save: true },
+  { name: "think", type: "callback", save: false },
+  { name: "touch", type: "callback", save: false },
+  { name: "use", type: "callback", save: false },
+  { name: "pain", type: "callback", save: false },
+  { name: "die", type: "callback", save: false }
+];
+
+// src/entities/pool.ts
+var MAX_EDICTS = 2048;
+var WORLD_INDEX = 0;
+var EntityPool = class {
+  constructor(maxEntities = MAX_EDICTS) {
+    this.freeList = [];
+    this.pendingFree = [];
+    this.activeHead = null;
+    if (maxEntities < 1 || !Number.isInteger(maxEntities)) {
+      throw new Error("EntityPool requires a positive integer size");
+    }
+    this.entities = new Array(maxEntities);
+    for (let i = 0; i < maxEntities; i += 1) {
+      this.entities[i] = new Entity(i);
+      if (i !== WORLD_INDEX) {
+        this.freeList.push(i);
+      }
+    }
+    const world = this.entities[WORLD_INDEX];
+    world.inUse = true;
+    world.classname = "worldspawn";
+    this.activeHead = world;
+  }
+  get world() {
+    return this.entities[WORLD_INDEX];
+  }
+  get capacity() {
+    return this.entities.length;
+  }
+  get activeCount() {
+    let count = 0;
+    for (const _ of this) {
+      count += 1;
+    }
+    return count;
+  }
+  [Symbol.iterator]() {
+    let current = this.activeHead;
+    return {
+      next: () => {
+        if (!current) {
+          return { done: true, value: void 0 };
+        }
+        const value = current;
+        current = current.linkNext;
+        return { done: false, value };
+      }
+    };
+  }
+  spawn() {
+    const index = this.freeList.pop();
+    if (index === void 0) {
+      throw new Error("No free entities available");
+    }
+    const entity = this.entities[index];
+    entity.reset();
+    entity.inUse = true;
+    this.link(entity);
+    return entity;
+  }
+  deferFree(entity) {
+    if (entity.index === WORLD_INDEX) {
+      throw new Error("Cannot free world entity");
+    }
+    if (!entity.inUse || entity.freePending) {
+      return;
+    }
+    this.unlink(entity);
+    entity.inUse = false;
+    entity.freePending = true;
+    this.pendingFree.push(entity.index);
+  }
+  flushFreeList() {
+    if (this.pendingFree.length === 0) {
+      return;
+    }
+    for (const index of this.pendingFree) {
+      const entity = this.entities[index];
+      entity.reset();
+      this.freeList.push(index);
+    }
+    this.pendingFree.length = 0;
+  }
+  link(entity) {
+    entity.linkNext = this.activeHead;
+    if (this.activeHead) {
+      this.activeHead.linkPrevious = entity;
+    }
+    this.activeHead = entity;
+    entity.linkPrevious = null;
+  }
+  unlink(entity) {
+    if (entity.linkPrevious) {
+      entity.linkPrevious.linkNext = entity.linkNext;
+    }
+    if (entity.linkNext) {
+      entity.linkNext.linkPrevious = entity.linkPrevious;
+    }
+    if (this.activeHead === entity) {
+      this.activeHead = entity.linkNext;
+    }
+    entity.linkPrevious = null;
+    entity.linkNext = null;
+  }
+};
+
+// src/entities/thinkScheduler.ts
+var ThinkScheduler = class {
+  constructor() {
+    this.queue = [];
+  }
+  schedule(entity, timeSeconds) {
+    entity.nextthink = timeSeconds;
+    this.queue.push({ entity, time: timeSeconds });
+    this.queue.sort((a, b) => a.time === b.time ? a.entity.index - b.entity.index : a.time - b.time);
+  }
+  cancel(entity) {
+    if (this.queue.length === 0) {
+      return;
+    }
+    for (let i = this.queue.length - 1; i >= 0; i -= 1) {
+      if (this.queue[i].entity === entity) {
+        this.queue.splice(i, 1);
+      }
+    }
+  }
+  runDueThinks(currentTimeSeconds) {
+    while (this.queue.length > 0) {
+      const next = this.queue[0];
+      if (next.time > currentTimeSeconds) {
+        break;
+      }
+      this.queue.shift();
+      const { entity, time } = next;
+      if (!entity.inUse || entity.freePending) {
+        continue;
+      }
+      if (!entity.think) {
+        continue;
+      }
+      if (entity.nextthink !== time) {
+        continue;
+      }
+      entity.think(entity);
+    }
+  }
+};
+
+// src/entities/system.ts
+function computeBounds(entity) {
+  return {
+    min: {
+      x: entity.origin.x + entity.mins.x,
+      y: entity.origin.y + entity.mins.y,
+      z: entity.origin.z + entity.mins.z
+    },
+    max: {
+      x: entity.origin.x + entity.maxs.x,
+      y: entity.origin.y + entity.maxs.y,
+      z: entity.origin.z + entity.maxs.z
+    }
+  };
+}
+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 EntitySystem = class {
+  constructor(maxEntities) {
+    this.currentTimeSeconds = 0;
+    this.pool = new EntityPool(maxEntities);
+    this.thinkScheduler = new ThinkScheduler();
+  }
+  get world() {
+    return this.pool.world;
+  }
+  get activeCount() {
+    return this.pool.activeCount;
+  }
+  get timeSeconds() {
+    return this.currentTimeSeconds;
+  }
+  forEachEntity(callback) {
+    for (const entity of this.pool) {
+      callback(entity);
+    }
+  }
+  spawn() {
+    return this.pool.spawn();
+  }
+  free(entity) {
+    this.thinkScheduler.cancel(entity);
+    this.pool.deferFree(entity);
+  }
+  scheduleThink(entity, nextThinkSeconds) {
+    this.thinkScheduler.schedule(entity, nextThinkSeconds);
+  }
+  beginFrame(timeSeconds) {
+    this.currentTimeSeconds = timeSeconds;
+  }
+  runFrame() {
+    this.thinkScheduler.runDueThinks(this.currentTimeSeconds);
+    this.runTouches();
+    this.pool.flushFreeList();
+  }
+  runTouches() {
+    const world = this.pool.world;
+    const activeEntities = [];
+    for (const entity of this.pool) {
+      if (entity === world) {
+        continue;
+      }
+      if (!entity.inUse || entity.freePending) {
+        continue;
+      }
+      activeEntities.push(entity);
+    }
+    for (let i = 0; i < activeEntities.length; i += 1) {
+      const first = activeEntities[i];
+      let firstBounds = null;
+      for (let j = i + 1; j < activeEntities.length; j += 1) {
+        const second = activeEntities[j];
+        if (!first.touch && !second.touch) {
+          continue;
+        }
+        if (!firstBounds) {
+          firstBounds = computeBounds(first);
+        }
+        const secondBounds = computeBounds(second);
+        if (!boundsIntersect(firstBounds, secondBounds)) {
+          continue;
+        }
+        if (first.touch) {
+          first.touch(first, second);
+        }
+        if (second.touch) {
+          second.touch(second, first);
+        }
+      }
+    }
+  }
+};
+
+// 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,
+  deltaSeconds: 0
+};
+var LevelClock = class {
+  constructor() {
+    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;
+  }
+};
+
+// src/index.ts
+var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+function createGame(engine, options) {
+  const gravity = options.gravity;
+  const levelClock = new LevelClock();
+  const frameLoop = new GameFrameLoop();
+  const entities = new EntitySystem();
+  frameLoop.addStage("prep", (context) => {
+    levelClock.tick(context);
+    entities.beginFrame(levelClock.current.timeSeconds);
+  });
+  frameLoop.addStage("simulate", ({ deltaSeconds }) => {
+    velocity = {
+      x: velocity.x + gravity.x * deltaSeconds,
+      y: velocity.y + gravity.y * deltaSeconds,
+      z: velocity.z + gravity.z * deltaSeconds
+    };
+    origin = {
+      x: origin.x + velocity.x * deltaSeconds,
+      y: origin.y + velocity.y * deltaSeconds,
+      z: origin.z + velocity.z * deltaSeconds
+    };
+    entities.runFrame();
+  });
+  let origin = { ...ZERO_VEC32 };
+  let velocity = { ...ZERO_VEC32 };
+  const snapshot = (frame) => ({
+    frame,
+    timeMs: frameLoop.time,
+    state: {
+      gravity: { ...gravity },
+      origin: { ...origin },
+      velocity: { ...velocity },
+      level: { ...levelClock.current },
+      entities: {
+        activeCount: entities.activeCount,
+        worldClassname: entities.world.classname
+      }
+    }
+  });
+  const resetState = (startTimeMs) => {
+    frameLoop.reset(startTimeMs);
+    levelClock.start(startTimeMs);
+    origin = { ...ZERO_VEC32 };
+    velocity = { ...ZERO_VEC32 };
+    entities.beginFrame(startTimeMs / 1e3);
+    entities.runFrame();
+  };
+  return {
+    init(startTimeMs) {
+      resetState(startTimeMs);
+      void engine.trace({ x: 0, y: 0, z: 0 }, gravity);
+      return snapshot(0);
+    },
+    shutdown() {
+    },
+    spawnWorld() {
+    },
+    frame(step) {
+      const context = frameLoop.advance(step);
+      return snapshot(context.frame);
+    },
+    entities
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeadFlag,
+  ENTITY_FIELD_METADATA,
+  Entity,
+  EntitySystem,
+  MoveType,
+  Solid,
+  createGame
+});
+//# sourceMappingURL=index.cjs.map