1681-engine 0.0.0-stage → 0.5.8

package/dist/ecs/SparseSet.js

@@ -0,0 +1,55 @@
+class n {
+  sparse = new Int32Array(64).fill(-1);
+  /** Packed entity ids, in the same order as `values`. */
+  entities = [];
+  values = [];
+  /** Bumped whenever an entity joins or leaves the set (not when a value changes): query caches key on it. */
+  version = 0;
+  get size() {
+    return this.entities.length;
+  }
+  has(s) {
+    return s < this.sparse.length && this.sparse[s] >= 0;
+  }
+  /** The value at slot `index`, or undefined. */
+  get(s) {
+    if (s >= this.sparse.length) return;
+    const t = this.sparse[s];
+    return t >= 0 ? this.values[t] : void 0;
+  }
+  set(s, t, e) {
+    this.grow(s);
+    const i = this.sparse[s];
+    if (i >= 0) {
+      this.values[i] = e, this.entities[i] = t;
+      return;
+    }
+    this.sparse[s] = this.entities.length, this.version++, this.entities.push(t), this.values.push(e);
+  }
+  /** Removes slot `index`; true if it was there. */
+  delete(s, t) {
+    if (s >= this.sparse.length) return !1;
+    const e = this.sparse[s];
+    if (e < 0) return !1;
+    const i = this.entities.length - 1;
+    if (e !== i) {
+      const h = this.entities[i];
+      this.entities[e] = h, this.values[e] = this.values[i], this.sparse[t(h)] = e;
+    }
+    return this.entities.pop(), this.values.pop(), this.sparse[s] = -1, this.version++, !0;
+  }
+  clear() {
+    this.version++, this.sparse.fill(-1), this.entities.length = 0, this.values.length = 0;
+  }
+  grow(s) {
+    if (s < this.sparse.length) return;
+    let t = this.sparse.length;
+    for (; t <= s; ) t *= 2;
+    const e = new Int32Array(t).fill(-1);
+    e.set(this.sparse), this.sparse = e;
+  }
+}
+export {
+  n as SparseSet
+};
+//# sourceMappingURL=SparseSet.js.map

package/dist/ecs/SparseSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparseSet.js","sources":["../../src/ecs/SparseSet.ts"],"sourcesContent":["/**\n * One component type's storage: a sparse set. `sparse[index]` is where the entity's value sits in the dense arrays\n * (or -1), and `entities`/`values` are packed with no holes, so walking a component is a walk over two flat arrays\n * and finding one is two array reads. Removing swaps the last entry into the hole.\n *\n * Indexed by the entity's slot index (`entityIndex`), not the whole id: the generation is checked by the world.\n */\nexport class SparseSet<T> {\n  private sparse: Int32Array = new Int32Array(64).fill(-1);\n  /** Packed entity ids, in the same order as `values`. */\n  readonly entities: number[] = [];\n  readonly values: T[] = [];\n  /** Bumped whenever an entity joins or leaves the set (not when a value changes): query caches key on it. */\n  version = 0;\n\n  get size(): number {\n    return this.entities.length;\n  }\n\n  has(index: number): boolean {\n    return index < this.sparse.length && this.sparse[index]! >= 0;\n  }\n\n  /** The value at slot `index`, or undefined. */\n  get(index: number): T | undefined {\n    if (index >= this.sparse.length) return undefined;\n    const d = this.sparse[index]!;\n    return d >= 0 ? this.values[d] : undefined;\n  }\n\n  set(index: number, entity: number, value: T): void {\n    this.grow(index);\n    const d = this.sparse[index]!;\n    if (d >= 0) {\n      this.values[d] = value;\n      this.entities[d] = entity;\n      return;\n    }\n    this.sparse[index] = this.entities.length;\n    this.version++;\n    this.entities.push(entity);\n    this.values.push(value);\n  }\n\n  /** Removes slot `index`; true if it was there. */\n  delete(index: number, indexOf: (entity: number) => number): boolean {\n    if (index >= this.sparse.length) return false;\n    const d = this.sparse[index]!;\n    if (d < 0) return false;\n    const last = this.entities.length - 1;\n    if (d !== last) {\n      const moved = this.entities[last]!;\n      this.entities[d] = moved;\n      this.values[d] = this.values[last]!;\n      this.sparse[indexOf(moved)] = d;\n    }\n    this.entities.pop();\n    this.values.pop();\n    this.sparse[index] = -1;\n    this.version++;\n    return true;\n  }\n\n  clear(): void {\n    this.version++;\n    this.sparse.fill(-1);\n    this.entities.length = 0;\n    this.values.length = 0;\n  }\n\n  private grow(index: number): void {\n    if (index < this.sparse.length) return;\n    let n = this.sparse.length;\n    while (n <= index) n *= 2;\n    const next = new Int32Array(n).fill(-1);\n    next.set(this.sparse);\n    this.sparse = next;\n  }\n}\n"],"names":["SparseSet","index","d","entity","value","indexOf","last","moved","n","next"],"mappings":"AAOO,MAAMA,EAAa;AAAA,EAChB,SAAqB,IAAI,WAAW,EAAE,EAAE,KAAK,EAAE;AAAA;AAAA,EAE9C,WAAqB,CAAA;AAAA,EACrB,SAAc,CAAA;AAAA;AAAA,EAEvB,UAAU;AAAA,EAEV,IAAI,OAAe;AACjB,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA,EAEA,IAAIC,GAAwB;AAC1B,WAAOA,IAAQ,KAAK,OAAO,UAAU,KAAK,OAAOA,CAAK,KAAM;AAAA,EAC9D;AAAA;AAAA,EAGA,IAAIA,GAA8B;AAChC,QAAIA,KAAS,KAAK,OAAO,OAAQ;AACjC,UAAMC,IAAI,KAAK,OAAOD,CAAK;AAC3B,WAAOC,KAAK,IAAI,KAAK,OAAOA,CAAC,IAAI;AAAA,EACnC;AAAA,EAEA,IAAID,GAAeE,GAAgBC,GAAgB;AACjD,SAAK,KAAKH,CAAK;AACf,UAAMC,IAAI,KAAK,OAAOD,CAAK;AAC3B,QAAIC,KAAK,GAAG;AACV,WAAK,OAAOA,CAAC,IAAIE,GACjB,KAAK,SAASF,CAAC,IAAIC;AACnB;AAAA,IACF;AACA,SAAK,OAAOF,CAAK,IAAI,KAAK,SAAS,QACnC,KAAK,WACL,KAAK,SAAS,KAAKE,CAAM,GACzB,KAAK,OAAO,KAAKC,CAAK;AAAA,EACxB;AAAA;AAAA,EAGA,OAAOH,GAAeI,GAA8C;AAClE,QAAIJ,KAAS,KAAK,OAAO,OAAQ,QAAO;AACxC,UAAMC,IAAI,KAAK,OAAOD,CAAK;AAC3B,QAAIC,IAAI,EAAG,QAAO;AAClB,UAAMI,IAAO,KAAK,SAAS,SAAS;AACpC,QAAIJ,MAAMI,GAAM;AACd,YAAMC,IAAQ,KAAK,SAASD,CAAI;AAChC,WAAK,SAASJ,CAAC,IAAIK,GACnB,KAAK,OAAOL,CAAC,IAAI,KAAK,OAAOI,CAAI,GACjC,KAAK,OAAOD,EAAQE,CAAK,CAAC,IAAIL;AAAA,IAChC;AACA,gBAAK,SAAS,IAAA,GACd,KAAK,OAAO,IAAA,GACZ,KAAK,OAAOD,CAAK,IAAI,IACrB,KAAK,WACE;AAAA,EACT;AAAA,EAEA,QAAc;AACZ,SAAK,WACL,KAAK,OAAO,KAAK,EAAE,GACnB,KAAK,SAAS,SAAS,GACvB,KAAK,OAAO,SAAS;AAAA,EACvB;AAAA,EAEQ,KAAKA,GAAqB;AAChC,QAAIA,IAAQ,KAAK,OAAO,OAAQ;AAChC,QAAIO,IAAI,KAAK,OAAO;AACpB,WAAOA,KAAKP,IAAO,CAAAO,KAAK;AACxB,UAAMC,IAAO,IAAI,WAAWD,CAAC,EAAE,KAAK,EAAE;AACtC,IAAAC,EAAK,IAAI,KAAK,MAAM,GACpB,KAAK,SAASA;AAAA,EAChB;AACF;"}

package/dist/ecs/World.js

@@ -0,0 +1,307 @@
+import { SparseSet as k } from "./SparseSet.js";
+import { isFields as A, growColumns as x } from "./fields.js";
+let y = 0;
+const p = [];
+function O(f) {
+  const t = { id: y++, name: f };
+  return p[t.id] = t, t;
+}
+function U(f, t) {
+  const s = { id: y++, name: f, fields: t };
+  return p[s.id] = s, s;
+}
+function b(f, t, s) {
+  return { name: f, phase: t, run: s };
+}
+const E = 22, u = (1 << E) - 1, v = 2 ** 31, h = (f) => f & u;
+class z {
+  /** Current generation per slot; an id is alive when its generation matches and the slot is in use. */
+  generations = [];
+  inUse = [];
+  free = [];
+  live = 0;
+  stores = [];
+  /** Typed-array columns of the field components, by component id. */
+  cols = [];
+  systems = [];
+  pending = [];
+  /** `slots` results by the component ids asked for, rebuilt only when one of those sets changed membership. */
+  slotCache = /* @__PURE__ */ new Map();
+  /** Walks (`query`, `each`, system runs) in progress: structure changes wait until it is 0. */
+  walking = 0;
+  /** A new entity with no components. */
+  create() {
+    let t;
+    if (this.free.length)
+      t = this.free.pop();
+    else {
+      if (t = this.generations.length, t > u) throw new Error("World: too many live entities");
+      this.generations.push(0), this.inUse.push(!1);
+    }
+    return this.inUse[t] = !0, this.live++, this.generations[t] * (u + 1) + t;
+  }
+  /** A new entity with these components. */
+  spawn(...t) {
+    const s = this.create();
+    for (const [i, e] of t) this.add(s, i, e);
+    return s;
+  }
+  isAlive(t) {
+    const s = h(t);
+    return this.inUse[s] === !0 && this.generations[s] === Math.floor(t / (u + 1));
+  }
+  /** Every live entity, for tools (a debugger, a save); allocates, so not for a per-frame path. */
+  entities() {
+    const t = [];
+    for (let s = 0; s < this.inUse.length; s++) this.inUse[s] && t.push(this.generations[s] * (u + 1) + s);
+    return t;
+  }
+  /** The component types `e` holds, for tools; allocates. */
+  componentsOf(t) {
+    if (!this.isAlive(t)) return [];
+    const s = h(t), i = [];
+    return this.stores.forEach((e, n) => {
+      e?.has(s) && i.push(p[n]);
+    }), i;
+  }
+  /** Live entities. */
+  get size() {
+    return this.live;
+  }
+  /** Removes an entity and every component it had (deferred while a walk is in progress). */
+  destroy(t) {
+    if (!this.isAlive(t)) return;
+    if (this.walking > 0) {
+      this.pending.push({ kind: "destroy", e: t });
+      return;
+    }
+    const s = h(t);
+    for (const i of this.stores) i?.delete(s, h);
+    this.inUse[s] = !1, this.generations[s] = (this.generations[s] + 1) % v, this.free.push(s), this.live--;
+  }
+  add(t, s, i) {
+    if (!this.isAlive(t)) throw new Error(`World.add: entity ${t} is not alive`);
+    const e = h(t);
+    if (A(s)) {
+      const n = this.columnsOf(s, e + 1), l = i ?? {};
+      for (const r of Object.keys(s.fields)) n[r][e] = l[r] ?? 0;
+      return this.store(s).set(e, t, e), e;
+    }
+    return this.store(s).set(e, t, i), i;
+  }
+  /**
+   * The typed-array columns of a field component, indexed by slot. Fetch them per system run: adding entities may
+   * grow them into new arrays.
+   */
+  columns(t) {
+    return this.columnsOf(t, this.generations.length);
+  }
+  get(t, s) {
+    if (this.isAlive(t))
+      return this.stores[s.id]?.get(h(t));
+  }
+  /** The component, or an error naming what is missing: for code that knows the entity has it. */
+  require(t, s) {
+    const i = this.stores[s.id];
+    if (!this.isAlive(t) || !i?.has(h(t))) throw new Error(`World.require: entity ${t} has no ${s.name}`);
+    return i.get(h(t));
+  }
+  has(t, s) {
+    return this.isAlive(t) && (this.stores[s.id]?.has(h(t)) ?? !1);
+  }
+  /** Takes one component off an entity (deferred while a walk is in progress). */
+  remove(t, s) {
+    if (this.isAlive(t)) {
+      if (this.walking > 0) {
+        this.pending.push({ kind: "remove", e: t, type: s });
+        return;
+      }
+      this.stores[s.id]?.delete(h(t), h);
+    }
+  }
+  /** How many entities hold `type`. */
+  count(t) {
+    return this.stores[t.id]?.size ?? 0;
+  }
+  /**
+   * Calls `fn(entity, ...components)` for every live entity holding all of `types`. Allocates nothing per entity:
+   * the form for systems that walk thousands of bodies every step.
+   */
+  each(...t) {
+    const s = t[t.length - 1], i = t.slice(0, -1), e = this.setsFor(i);
+    if (!e) return;
+    const n = m(e), l = n.entities.length;
+    this.walking++;
+    try {
+      if (e.length === 1)
+        for (let r = l - 1; r >= 0; r--) s(n.entities[r], n.values[r]);
+      else if (e.length === 2) {
+        const [r, o] = e;
+        for (let a = l - 1; a >= 0; a--) {
+          const d = n.entities[a], c = h(d);
+          !r.has(c) || !o.has(c) || s(d, r.get(c), o.get(c));
+        }
+      } else {
+        const r = new Array(e.length);
+        for (let o = l - 1; o >= 0; o--) {
+          const a = n.entities[o], d = h(a);
+          let c = !0;
+          for (let g = 0; g < e.length; g++) {
+            const w = e[g];
+            if (!w.has(d)) {
+              c = !1;
+              break;
+            }
+            r[g] = w.get(d);
+          }
+          c && s(a, ...r);
+        }
+      }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /**
+   * The slot index of every entity holding all of `types`, as a typed array: the fastest walk there is, made for
+   * field components (`defineFields`), whose columns are indexed by slot.
+   *
+   * ```ts
+   * const p = world.columns(Position), v = world.columns(Velocity);
+   * const slots = world.slots(Position, Velocity);
+   * for (let k = 0; k < slots.length; k++) { const i = slots[k]!; p.x[i]! += v.x[i]! * dt; }
+   * ```
+   *
+   * The result is cached and rebuilt only when an entity joins or leaves one of those components, so asking every
+   * step is cheap. It is a view the world owns: read it, don't keep it past the step, and fetch it again after
+   * adding or removing components.
+   */
+  slots(...t) {
+    const s = t.map((o) => o.id).join(","), i = this.setsFor(t);
+    if (!i) return S;
+    let e = this.slotCache.get(s);
+    if (e && e.versions.every((o, a) => o === i[a].version)) return e.view;
+    const n = m(i), l = e && e.slots.length >= n.size ? e.slots : new Int32Array(Math.max(16, n.size));
+    let r = 0;
+    for (let o = 0; o < n.entities.length; o++) {
+      const a = h(n.entities[o]);
+      let d = !0;
+      for (const c of i)
+        if (c !== n && !c.has(a)) {
+          d = !1;
+          break;
+        }
+      d && (l[r++] = a);
+    }
+    return e = { versions: i.map((o) => o.version), slots: l, view: l.subarray(0, r) }, this.slotCache.set(s, e), e.view;
+  }
+  /**
+   * Every live entity holding all of `types`, with those components in the same order. Yields a fresh row per
+   * entity: convenient, but `each` is the form for hot loops.
+   */
+  *query(...t) {
+    const s = this.setsFor(t);
+    if (!s) return;
+    const i = m(s);
+    this.walking++;
+    try {
+      for (let e = i.entities.length - 1; e >= 0; e--) {
+        const n = i.entities[e], l = h(n), r = [n];
+        let o = !0;
+        for (const a of s) {
+          if (!a.has(l)) {
+            o = !1;
+            break;
+          }
+          r.push(a.get(l));
+        }
+        o && (yield r);
+      }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /** The first entity matching the query, or undefined: for singletons (the player, the camera target). */
+  first(...t) {
+    for (const s of this.query(...t)) return s;
+  }
+  addSystem(t) {
+    if (this.systems.some((s) => s.name === t.name)) throw new Error(`World.addSystem: a system named "${t.name}" is already added`);
+    return this.systems.push(t), this;
+  }
+  removeSystem(t) {
+    const s = this.systems.findIndex((e) => e.name === t);
+    if (s < 0) return;
+    const [i] = this.systems.splice(s, 1);
+    i.dispose?.();
+  }
+  /** Runs every system of `phase` in the order added. A system that throws is reported and the rest still run. */
+  run(t, s, i) {
+    const e = { dt: s.dt, now: s.now, alpha: s.alpha, world: this };
+    this.walking++;
+    try {
+      for (const n of this.systems)
+        if (n.phase === t)
+          try {
+            n.run(e);
+          } catch (l) {
+            if (i) i(n, l);
+            else throw l;
+          }
+    } finally {
+      this.endWalk();
+    }
+  }
+  /** Every entity, component and system gone. */
+  clear() {
+    for (const t of this.systems.splice(0)) t.dispose?.();
+    for (const t of this.stores) t?.clear();
+    this.generations = this.generations.map((t) => (t + 1) % v), this.inUse.fill(!1), this.free.length = 0;
+    for (let t = this.generations.length - 1; t >= 0; t--) this.free.push(t);
+    this.live = 0, this.pending.length = 0, this.slotCache.clear();
+  }
+  columnsOf(t, s) {
+    let i = this.cols[t.id];
+    const e = i ? Object.values(i)[0]?.length ?? 0 : 0;
+    if (!i || e < s) {
+      let n = Math.max(64, e);
+      for (; n < s; ) n *= 2;
+      i = x(t.fields, n, i), this.cols[t.id] = i;
+    }
+    return i;
+  }
+  store(t) {
+    let s = this.stores[t.id];
+    return s || (s = new k(), this.stores[t.id] = s), s;
+  }
+  /** The stores for `types`, or null when one has never been used (so nothing can match). */
+  setsFor(t) {
+    if (t.length === 0) return null;
+    const s = [];
+    for (const i of t) {
+      const e = this.stores[i.id];
+      if (!e || e.size === 0) return null;
+      s.push(e);
+    }
+    return s;
+  }
+  endWalk() {
+    if (this.walking--, this.walking > 0 || this.pending.length === 0) return;
+    const t = this.pending.splice(0);
+    for (const s of t)
+      s.kind === "destroy" ? this.destroy(s.e) : this.remove(s.e, s.type);
+  }
+}
+const S = new Int32Array(0);
+function m(f) {
+  let t = f[0];
+  for (const s of f) s.size < t.size && (t = s);
+  return t;
+}
+export {
+  z as World,
+  O as defineComponent,
+  U as defineFields,
+  h as entityIndex,
+  b as system
+};
+//# sourceMappingURL=World.js.map

package/dist/ecs/World.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"World.js","sources":["../../src/ecs/World.ts"],"sourcesContent":["import { SparseSet } from './SparseSet';\nimport { growColumns, isFields, type Columns, type FieldSpec, type FieldValues, type FieldsType } from './fields';\n\n/**\n * An entity–component–system store. Entities are numbers; components are data kept in one sparse set per component\n * type; systems are functions run in the order they were added, each in a phase:\n *\n * - `fixed` runs once per simulation step (`FixedLoop`), for movement and rules;\n * - `frame` runs once per rendered frame, for drawing and anything purely visual.\n *\n * Storage is a sparse set per component (packed arrays, O(1) lookups), the layout fast ECS libraries use. For hot\n * loops prefer `each` (a callback, no allocation per entity) over `query` (an iterator yielding a fresh row).\n *\n * Entity ids are recycled: an id carries its slot index and a generation, so an id kept after its entity was\n * destroyed never matches the entity that later reuses the slot.\n *\n * Changing structure while walking: adding components is always safe (new entries are not visited this walk).\n * Removing a component or destroying an entity while a `query`, an `each` or a system run is in progress is deferred\n * until it ends, so nothing is skipped or visited twice.\n */\n\nexport type Entity = number;\n\n/** A component type: a typed key. Make one per kind of data with `defineComponent`. */\nexport interface ComponentType<T> {\n  readonly id: number;\n  readonly name: string;\n  /** Phantom field carrying `T`; never set. */\n  readonly __type?: T;\n}\n\nlet nextComponentId = 0;\n/** Every component type made, by id: what a debugger names a store by. */\nconst TYPES: ComponentType<unknown>[] = [];\n\nexport function defineComponent<T>(name: string): ComponentType<T> {\n  const type = { id: nextComponentId++, name };\n  TYPES[type.id] = type;\n  return type;\n}\n\n/** A component of numeric fields kept in typed-array columns (`fields.ts`): the fast form for data every body has. */\nexport function defineFields<const S extends FieldSpec>(name: string, fields: S): FieldsType<S> {\n  const type = { id: nextComponentId++, name, fields };\n  TYPES[type.id] = type;\n  return type;\n}\n\nexport type SystemPhase = 'fixed' | 'frame';\n\nexport interface SystemContext {\n  world: World;\n  /** Seconds this run covers: one step in `fixed`, the frame's length in `frame`. */\n  dt: number;\n  /** `performance.now()` of the frame. */\n  now: number;\n  /** In `frame`: the share of a step since the last fixed step (0–1), for interpolation. 0 in `fixed`. */\n  alpha: number;\n}\n\nexport interface System {\n  readonly name: string;\n  readonly phase: SystemPhase;\n  run(ctx: SystemContext): void;\n  /** Called when the system is taken out of its world (or the world is cleared). */\n  dispose?(): void;\n}\n\n/** A system from a function. */\nexport function system(name: string, phase: SystemPhase, run: (ctx: SystemContext) => void): System {\n  return { name, phase, run };\n}\n\nexport type ComponentValues<T extends readonly ComponentType<unknown>[]> = { [K in keyof T]: T[K] extends ComponentType<infer V> ? V : never };\n\n/** Slot index in the low 22 bits (4 million live entities), generation above. */\nconst INDEX_BITS = 22;\nconst INDEX_MASK = (1 << INDEX_BITS) - 1;\nconst MAX_GENERATION = 2 ** 31;\n\n/** The slot an entity id sits in. */\nexport const entityIndex = (e: Entity): number => e & INDEX_MASK;\n\ntype Pending = { kind: 'destroy'; e: Entity } | { kind: 'remove'; e: Entity; type: ComponentType<unknown> };\n\nexport class World {\n  /** Current generation per slot; an id is alive when its generation matches and the slot is in use. */\n  private generations: number[] = [];\n  private readonly inUse: boolean[] = [];\n  private readonly free: number[] = [];\n  private live = 0;\n  private readonly stores: (SparseSet<unknown> | undefined)[] = [];\n  /** Typed-array columns of the field components, by component id. */\n  private readonly cols: (Record<string, ArrayLike<number>> | undefined)[] = [];\n  private readonly systems: System[] = [];\n  private readonly pending: Pending[] = [];\n  /** `slots` results by the component ids asked for, rebuilt only when one of those sets changed membership. */\n  private readonly slotCache = new Map<string, { versions: number[]; slots: Int32Array; view: Int32Array }>();\n  /** Walks (`query`, `each`, system runs) in progress: structure changes wait until it is 0. */\n  private walking = 0;\n\n  /** A new entity with no components. */\n  create(): Entity {\n    let index: number;\n    if (this.free.length) {\n      index = this.free.pop()!;\n    } else {\n      index = this.generations.length;\n      if (index > INDEX_MASK) throw new Error('World: too many live entities');\n      this.generations.push(0);\n      this.inUse.push(false);\n    }\n    this.inUse[index] = true;\n    this.live++;\n    return this.generations[index]! * (INDEX_MASK + 1) + index;\n  }\n\n  /** A new entity with these components. */\n  spawn(...components: [ComponentType<unknown>, unknown][]): Entity {\n    const e = this.create();\n    for (const [type, value] of components) this.add(e, type, value);\n    return e;\n  }\n\n  isAlive(e: Entity): boolean {\n    const index = entityIndex(e);\n    return this.inUse[index] === true && this.generations[index] === Math.floor(e / (INDEX_MASK + 1));\n  }\n\n  /** Every live entity, for tools (a debugger, a save); allocates, so not for a per-frame path. */\n  entities(): Entity[] {\n    const out: Entity[] = [];\n    for (let i = 0; i < this.inUse.length; i++) if (this.inUse[i]) out.push(this.generations[i]! * (INDEX_MASK + 1) + i);\n    return out;\n  }\n\n  /** The component types `e` holds, for tools; allocates. */\n  componentsOf(e: Entity): ComponentType<unknown>[] {\n    if (!this.isAlive(e)) return [];\n    const index = entityIndex(e);\n    const out: ComponentType<unknown>[] = [];\n    this.stores.forEach((store, id) => {\n      if (store?.has(index)) out.push(TYPES[id]!);\n    });\n    return out;\n  }\n\n  /** Live entities. */\n  get size(): number {\n    return this.live;\n  }\n\n  /** Removes an entity and every component it had (deferred while a walk is in progress). */\n  destroy(e: Entity): void {\n    if (!this.isAlive(e)) return;\n    if (this.walking > 0) {\n      this.pending.push({ kind: 'destroy', e });\n      return;\n    }\n    const index = entityIndex(e);\n    for (const store of this.stores) store?.delete(index, entityIndex);\n    this.inUse[index] = false;\n    this.generations[index] = (this.generations[index]! + 1) % MAX_GENERATION;\n    this.free.push(index);\n    this.live--;\n  }\n\n  /** Gives an entity a field component; fields left out start at 0. Returns the slot index into its columns. */\n  add<S extends FieldSpec>(e: Entity, type: FieldsType<S>, values?: FieldValues<S>): number;\n  add<T>(e: Entity, type: ComponentType<T>, value: T): T;\n  add(e: Entity, type: ComponentType<unknown>, value?: unknown): unknown {\n    if (!this.isAlive(e)) throw new Error(`World.add: entity ${e} is not alive`);\n    const index = entityIndex(e);\n    if (isFields(type)) {\n      const cols = this.columnsOf(type, index + 1) as Record<string, { [i: number]: number }>;\n      const values = (value ?? {}) as Record<string, number>;\n      for (const name of Object.keys(type.fields)) cols[name]![index] = values[name] ?? 0;\n      this.store(type).set(index, e, index);\n      return index;\n    }\n    this.store(type).set(index, e, value);\n    return value;\n  }\n\n  /**\n   * The typed-array columns of a field component, indexed by slot. Fetch them per system run: adding entities may\n   * grow them into new arrays.\n   */\n  columns<S extends FieldSpec>(type: FieldsType<S>): Columns<S> {\n    return this.columnsOf(type, this.generations.length) as unknown as Columns<S>;\n  }\n\n  get<T>(e: Entity, type: ComponentType<T>): T | undefined {\n    if (!this.isAlive(e)) return undefined;\n    return this.stores[type.id]?.get(entityIndex(e)) as T | undefined;\n  }\n\n  /** The component, or an error naming what is missing: for code that knows the entity has it. */\n  require<T>(e: Entity, type: ComponentType<T>): T {\n    const store = this.stores[type.id];\n    if (!this.isAlive(e) || !store?.has(entityIndex(e))) throw new Error(`World.require: entity ${e} has no ${type.name}`);\n    return store.get(entityIndex(e)) as T;\n  }\n\n  has(e: Entity, type: ComponentType<unknown>): boolean {\n    return this.isAlive(e) && (this.stores[type.id]?.has(entityIndex(e)) ?? false);\n  }\n\n  /** Takes one component off an entity (deferred while a walk is in progress). */\n  remove(e: Entity, type: ComponentType<unknown>): void {\n    if (!this.isAlive(e)) return;\n    if (this.walking > 0) {\n      this.pending.push({ kind: 'remove', e, type });\n      return;\n    }\n    this.stores[type.id]?.delete(entityIndex(e), entityIndex);\n  }\n\n  /** How many entities hold `type`. */\n  count(type: ComponentType<unknown>): number {\n    return this.stores[type.id]?.size ?? 0;\n  }\n\n  /**\n   * Calls `fn(entity, ...components)` for every live entity holding all of `types`. Allocates nothing per entity:\n   * the form for systems that walk thousands of bodies every step.\n   */\n  each<const T extends readonly ComponentType<unknown>[]>(...args: [...types: T, fn: (e: Entity, ...values: ComponentValues<T>) => void]): void {\n    const fn = args[args.length - 1] as (e: Entity, ...values: unknown[]) => void;\n    const types = args.slice(0, -1) as unknown as T;\n    const sets = this.setsFor(types);\n    if (!sets) return;\n    const lead = smallest(sets);\n    const n = lead.entities.length;\n    this.walking++;\n    try {\n      if (sets.length === 1) {\n        for (let i = n - 1; i >= 0; i--) fn(lead.entities[i]!, lead.values[i]);\n      } else if (sets.length === 2) {\n        const [a, b] = sets as [SparseSet<unknown>, SparseSet<unknown>];\n        for (let i = n - 1; i >= 0; i--) {\n          const e = lead.entities[i]!;\n          const index = entityIndex(e);\n          if (!a.has(index) || !b.has(index)) continue;\n          fn(e, a.get(index), b.get(index));\n        }\n      } else {\n        const row: unknown[] = new Array(sets.length);\n        for (let i = n - 1; i >= 0; i--) {\n          const e = lead.entities[i]!;\n          const index = entityIndex(e);\n          let all = true;\n          for (let s = 0; s < sets.length; s++) {\n            const set = sets[s]!;\n            if (!set.has(index)) {\n              all = false;\n              break;\n            }\n            row[s] = set.get(index);\n          }\n          if (all) fn(e, ...row);\n        }\n      }\n    } finally {\n      this.endWalk();\n    }\n  }\n\n  /**\n   * The slot index of every entity holding all of `types`, as a typed array: the fastest walk there is, made for\n   * field components (`defineFields`), whose columns are indexed by slot.\n   *\n   * ```ts\n   * const p = world.columns(Position), v = world.columns(Velocity);\n   * const slots = world.slots(Position, Velocity);\n   * for (let k = 0; k < slots.length; k++) { const i = slots[k]!; p.x[i]! += v.x[i]! * dt; }\n   * ```\n   *\n   * The result is cached and rebuilt only when an entity joins or leaves one of those components, so asking every\n   * step is cheap. It is a view the world owns: read it, don't keep it past the step, and fetch it again after\n   * adding or removing components.\n   */\n  slots(...types: ComponentType<unknown>[]): Int32Array {\n    const key = types.map((t) => t.id).join(',');\n    const sets = this.setsFor(types);\n    if (!sets) return EMPTY_SLOTS;\n    let cached = this.slotCache.get(key);\n    if (cached && cached.versions.every((v, k) => v === sets[k]!.version)) return cached.view;\n    const lead = smallest(sets);\n    const out = cached && cached.slots.length >= lead.size ? cached.slots : new Int32Array(Math.max(16, lead.size));\n    let n = 0;\n    for (let d = 0; d < lead.entities.length; d++) {\n      const index = entityIndex(lead.entities[d]!);\n      let all = true;\n      for (const set of sets) {\n        if (set !== lead && !set.has(index)) {\n          all = false;\n          break;\n        }\n      }\n      if (all) out[n++] = index;\n    }\n    cached = { versions: sets.map((x) => x.version), slots: out, view: out.subarray(0, n) };\n    this.slotCache.set(key, cached);\n    return cached.view;\n  }\n\n  /**\n   * Every live entity holding all of `types`, with those components in the same order. Yields a fresh row per\n   * entity: convenient, but `each` is the form for hot loops.\n   */\n  *query<const T extends readonly ComponentType<unknown>[]>(...types: T): IterableIterator<[Entity, ...ComponentValues<T>]> {\n    const sets = this.setsFor(types);\n    if (!sets) return;\n    const lead = smallest(sets);\n    this.walking++;\n    try {\n      for (let i = lead.entities.length - 1; i >= 0; i--) {\n        const e = lead.entities[i]!;\n        const index = entityIndex(e);\n        const row: unknown[] = [e];\n        let all = true;\n        for (const set of sets) {\n          if (!set.has(index)) {\n            all = false;\n            break;\n          }\n          row.push(set.get(index));\n        }\n        if (all) yield row as [Entity, ...ComponentValues<T>];\n      }\n    } finally {\n      this.endWalk();\n    }\n  }\n\n  /** The first entity matching the query, or undefined: for singletons (the player, the camera target). */\n  first<const T extends readonly ComponentType<unknown>[]>(...types: T): [Entity, ...ComponentValues<T>] | undefined {\n    for (const row of this.query(...types)) return row;\n    return undefined;\n  }\n\n  addSystem(s: System): this {\n    if (this.systems.some((x) => x.name === s.name)) throw new Error(`World.addSystem: a system named \"${s.name}\" is already added`);\n    this.systems.push(s);\n    return this;\n  }\n\n  removeSystem(name: string): void {\n    const i = this.systems.findIndex((s) => s.name === name);\n    if (i < 0) return;\n    const [s] = this.systems.splice(i, 1);\n    s!.dispose?.();\n  }\n\n  /** Runs every system of `phase` in the order added. A system that throws is reported and the rest still run. */\n  run(phase: SystemPhase, ctx: Omit<SystemContext, 'world'>, onError?: (system: System, err: unknown) => void): void {\n    const full: SystemContext = { dt: ctx.dt, now: ctx.now, alpha: ctx.alpha, world: this };\n    this.walking++;\n    try {\n      for (const s of this.systems) {\n        if (s.phase !== phase) continue;\n        try {\n          s.run(full);\n        } catch (err) {\n          if (onError) onError(s, err);\n          else throw err;\n        }\n      }\n    } finally {\n      this.endWalk();\n    }\n  }\n\n  /** Every entity, component and system gone. */\n  clear(): void {\n    for (const s of this.systems.splice(0)) s.dispose?.();\n    for (const store of this.stores) store?.clear();\n    this.generations = this.generations.map((g) => (g + 1) % MAX_GENERATION);\n    this.inUse.fill(false);\n    this.free.length = 0;\n    for (let i = this.generations.length - 1; i >= 0; i--) this.free.push(i);\n    this.live = 0;\n    this.pending.length = 0;\n    this.slotCache.clear();\n  }\n\n  private columnsOf(type: FieldsType<FieldSpec>, slots: number): Record<string, ArrayLike<number>> {\n    let cols = this.cols[type.id];\n    const have = cols ? (Object.values(cols)[0]?.length ?? 0) : 0;\n    if (!cols || have < slots) {\n      let n = Math.max(64, have);\n      while (n < slots) n *= 2;\n      cols = growColumns(type.fields, n, cols);\n      this.cols[type.id] = cols;\n    }\n    return cols;\n  }\n\n  private store<T>(type: ComponentType<T>): SparseSet<unknown> {\n    let s = this.stores[type.id];\n    if (!s) {\n      s = new SparseSet<unknown>();\n      this.stores[type.id] = s;\n    }\n    return s;\n  }\n\n  /** The stores for `types`, or null when one has never been used (so nothing can match). */\n  private setsFor(types: readonly ComponentType<unknown>[]): SparseSet<unknown>[] | null {\n    if (types.length === 0) return null;\n    const sets: SparseSet<unknown>[] = [];\n    for (const t of types) {\n      const s = this.stores[t.id];\n      if (!s || s.size === 0) return null;\n      sets.push(s);\n    }\n    return sets;\n  }\n\n  private endWalk(): void {\n    this.walking--;\n    if (this.walking > 0 || this.pending.length === 0) return;\n    const pending = this.pending.splice(0);\n    for (const p of pending) {\n      if (p.kind === 'destroy') this.destroy(p.e);\n      else this.remove(p.e, p.type);\n    }\n  }\n}\n\nconst EMPTY_SLOTS = new Int32Array(0);\n\nfunction smallest(sets: SparseSet<unknown>[]): SparseSet<unknown> {\n  let lead = sets[0]!;\n  for (const s of sets) if (s.size < lead.size) lead = s;\n  return lead;\n}\n"],"names":["nextComponentId","TYPES","defineComponent","name","type","defineFields","fields","system","phase","run","INDEX_BITS","INDEX_MASK","MAX_GENERATION","entityIndex","e","World","index","components","value","out","i","store","id","isFields","cols","values","args","fn","types","sets","lead","smallest","n","a","b","row","all","s","set","key","t","EMPTY_SLOTS","cached","v","k","d","x","ctx","onError","full","err","g","slots","have","growColumns","SparseSet","pending","p"],"mappings":"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"}

package/dist/ecs/fields.js

@@ -0,0 +1,26 @@
+const c = {
+  f32: Float32Array,
+  f64: Float64Array,
+  i8: Int8Array,
+  i16: Int16Array,
+  i32: Int32Array,
+  u8: Uint8Array,
+  u16: Uint16Array,
+  u32: Uint32Array
+};
+function u(r) {
+  return r.fields !== void 0;
+}
+function f(r, e, a) {
+  const n = {};
+  for (const [t, s] of Object.entries(r)) {
+    const o = new c[s](e), i = a?.[t];
+    i && o.set(i), n[t] = o;
+  }
+  return n;
+}
+export {
+  f as growColumns,
+  u as isFields
+};
+//# sourceMappingURL=fields.js.map

package/dist/ecs/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sources":["../../src/ecs/fields.ts"],"sourcesContent":["import type { ComponentType } from './World';\n\n/**\n * Numeric components stored as columns of typed arrays instead of one object per entity: `Position.x` and\n * `Position.y` are two `Float32Array`s indexed by the entity's slot. A system walking thousands of bodies then reads\n * memory in order and makes no garbage, which is several times faster than objects at scale (see `bench/`).\n *\n * ```ts\n * const Position = defineFields('Position', { x: 'f32', y: 'f32' });\n * world.add(e, Position, { x: 10, y: 20 });\n * const p = world.columns(Position); // fetch per run: columns grow (and are replaced) as entities are added\n * world.each(Position, (e, i) => { p.x[i] += 1; });\n * ```\n *\n * In `each`/`query` a field component's value is the entity's slot index `i`, the index into every column.\n */\nexport type FieldKind = 'f32' | 'f64' | 'i8' | 'i16' | 'i32' | 'u8' | 'u16' | 'u32';\n\nexport type FieldSpec = Record<string, FieldKind>;\n\nexport type ArrayOf<K extends FieldKind> = K extends 'f32'\n  ? Float32Array\n  : K extends 'f64'\n    ? Float64Array\n    : K extends 'i8'\n      ? Int8Array\n      : K extends 'i16'\n        ? Int16Array\n        : K extends 'i32'\n          ? Int32Array\n          : K extends 'u8'\n            ? Uint8Array\n            : K extends 'u16'\n              ? Uint16Array\n              : Uint32Array;\n\n/** One typed array per field, indexed by slot. */\nexport type Columns<S extends FieldSpec> = { [K in keyof S]: ArrayOf<S[K]> };\n\n/** What `add` takes for a field component: any subset of its fields (the rest start at 0). */\nexport type FieldValues<S extends FieldSpec> = { [K in keyof S]?: number };\n\n/** A component of numeric fields. Its value in `each`/`query` is the slot index. */\nexport interface FieldsType<S extends FieldSpec> extends ComponentType<number> {\n  readonly fields: S;\n}\n\nconst CTORS: Record<FieldKind, new (n: number) => ArrayLike<number> & { set(a: ArrayLike<number>): void }> = {\n  f32: Float32Array,\n  f64: Float64Array,\n  i8: Int8Array,\n  i16: Int16Array,\n  i32: Int32Array,\n  u8: Uint8Array,\n  u16: Uint16Array,\n  u32: Uint32Array,\n};\n\nexport function isFields(type: ComponentType<unknown>): type is FieldsType<FieldSpec> {\n  return (type as { fields?: unknown }).fields !== undefined;\n}\n\n/** Fresh columns of at least `n` slots, keeping what `old` held. */\nexport function growColumns(spec: FieldSpec, n: number, old?: Record<string, ArrayLike<number>>): Record<string, ArrayLike<number>> {\n  const out: Record<string, ArrayLike<number>> = {};\n  for (const [name, kind] of Object.entries(spec)) {\n    const col = new CTORS[kind](n);\n    const prev = old?.[name];\n    if (prev) col.set(prev);\n    out[name] = col;\n  }\n  return out;\n}\n"],"names":["CTORS","isFields","type","growColumns","spec","n","old","out","name","kind","col","prev"],"mappings":"AA+CA,MAAMA,IAAuG;AAAA,EAC3G,KAAK;AAAA,EACL,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AACP;AAEO,SAASC,EAASC,GAA6D;AACpF,SAAQA,EAA8B,WAAW;AACnD;AAGO,SAASC,EAAYC,GAAiBC,GAAWC,GAA4E;AAClI,QAAMC,IAAyC,CAAA;AAC/C,aAAW,CAACC,GAAMC,CAAI,KAAK,OAAO,QAAQL,CAAI,GAAG;AAC/C,UAAMM,IAAM,IAAIV,EAAMS,CAAI,EAAEJ,CAAC,GACvBM,IAAOL,IAAME,CAAI;AACvB,IAAIG,KAAMD,EAAI,IAAIC,CAAI,GACtBJ,EAAIC,CAAI,IAAIE;AAAA,EACd;AACA,SAAOH;AACT;"}

package/dist/engine/Engine.js

@@ -0,0 +1,82 @@
+import { TextureSource as d, Application as l } from "pixi.js";
+import { Stage as o } from "../core/Stage.js";
+import { TextureRegistry as p } from "../core/TextureRegistry.js";
+import { patchPixi as m } from "../core/pixiPatches.js";
+import { EventBus as f } from "../events/EventBus.js";
+import { FixedLoop as g } from "./FixedLoop.js";
+import { SceneManager as v } from "./SceneManager.js";
+class x extends o {
+  constructor(e, t, r) {
+    super(e, t), this.tick = r;
+  }
+  tick;
+  update(e, t) {
+    this.tick(e, t);
+  }
+}
+class c {
+  constructor(e, t, r) {
+    this.app = e, this.loop = new g(r.hz === void 0 ? {} : { hz: r.hz }), this.stage = new x(e, t, (s, n) => this.tick(s, n));
+    const i = this.stage.cameras.main;
+    i.setZoom(r.zoom ?? 1), i.defaultZoom = i.zoom, i.roundPixels = r.pixelPerfect === !0, i.resolution = e.renderer.resolution, this.scenes = new v(this), o.onCaught = (s, n) => this.events.emit("error", { where: s, error: n }), e.ticker.add(this.onTick);
+  }
+  app;
+  stage;
+  loop;
+  scenes;
+  events = new f();
+  running = !0;
+  destroyed = !1;
+  onTick = (e) => this.stage.frame(e.deltaMS);
+  static async create(e) {
+    const t = e.pixelPerfect === !0;
+    d.defaultOptions.scaleMode = t ? "nearest" : "linear";
+    const r = t ? 1 : e.resolution ?? Math.min(2, typeof devicePixelRatio == "number" ? devicePixelRatio : 1);
+    m();
+    const i = new l(), s = e.width === void 0 && e.height === void 0;
+    return await i.init({
+      ...s ? { resizeTo: e.parent } : { width: e.width ?? 800, height: e.height ?? 600 },
+      background: e.background ?? "#000000",
+      antialias: !t,
+      resolution: r,
+      autoDensity: !0,
+      preference: e.preference ?? "webgl"
+    }), e.parent.appendChild(i.canvas), new c(i, e.textures ?? new p(), e);
+  }
+  /** The scene that updates now, if any. */
+  get scene() {
+    return this.scenes.current;
+  }
+  /** Stops simulating and drawing; the canvas keeps its last frame. */
+  pause() {
+    this.running && (this.running = !1, this.app.ticker.stop());
+  }
+  resume() {
+    this.running || this.destroyed || (this.running = !0, this.loop.reset(), this.app.ticker.start());
+  }
+  get paused() {
+    return !this.running;
+  }
+  /** Reports a fault to `events.error` (and the console when nobody listens). */
+  reportError(e, t) {
+    this.events.listenerCount("error") === 0 && console.error(`[engine] ${e}`, t), this.events.emit("error", { where: e, error: t });
+  }
+  /** Leaves every scene, removes the canvas and frees the renderer. */
+  async destroy() {
+    this.destroyed || (this.destroyed = !0, await this.scenes.clear(), this.app.ticker.remove(this.onTick), o.onCaught && (o.onCaught = null), this.stage.destroy(), this.events.clear(), this.app.destroy({ removeView: !0 }, { children: !0 }));
+  }
+  tick(e, t) {
+    const r = this.scenes.current;
+    if (r) {
+      const i = (h, u) => this.reportError(`system ${h.name}`, u), s = this.loop.stepSeconds, n = this.loop.advance(t, () => {
+        r.world.run("fixed", { dt: s, now: e, alpha: 0 }, i), r.fixedUpdate(s);
+      }), a = t / 1e3;
+      r.world.run("frame", { dt: a, now: e, alpha: n }, i), r.update(a, n);
+    }
+    this.events.emit("frame", { now: e, dt: t / 1e3 });
+  }
+}
+export {
+  c as Engine
+};
+//# sourceMappingURL=Engine.js.map

package/dist/engine/Engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Engine.js","sources":["../../src/engine/Engine.ts"],"sourcesContent":["import { Application, TextureSource } from 'pixi.js';\nimport { Stage } from '../core/Stage';\nimport { TextureRegistry } from '../core/TextureRegistry';\nimport { patchPixi } from '../core/pixiPatches';\nimport { EventBus } from '../events/EventBus';\nimport { FixedLoop } from './FixedLoop';\nimport { SceneManager } from './SceneManager';\nimport type { Scene } from './Scene';\n\nexport interface EngineOptions {\n  /** Where the canvas goes. */\n  parent: HTMLElement;\n  /** A fixed canvas size in CSS pixels. Leave both out to fill `parent` and follow its size. */\n  width?: number;\n  height?: number;\n  /** CSS colour behind the world (default black). */\n  background?: string;\n  /** World pixels are drawn this many screen pixels wide (default 1). Whole numbers keep pixel art crisp. */\n  zoom?: number;\n  /** Simulation steps per second (default 60). */\n  hz?: number;\n  /** Textures shared by the stage; a fresh registry by default. */\n  textures?: TextureRegistry;\n  /**\n   * Pixel art: nearest-neighbour textures, no antialiasing, one backing pixel per CSS pixel, and a camera that lands\n   * on whole pixels (default false: smooth textures drawn at the screen's own density, for any other art style).\n   */\n  pixelPerfect?: boolean;\n  /** Backing pixels per CSS pixel when not `pixelPerfect` (default `devicePixelRatio`, at most 2). */\n  resolution?: number;\n  /**\n   * Renderer preference (default 'webgl'). WebGL 2 runs everywhere the engine is tested. 'webgpu' is experimental:\n   * Pixi falls back to WebGL where WebGPU is missing, but the engine's own paths (pooled `PixelLayer` buffers, the\n   * `erase` blend `Darkness` cuts lights with, the fill filters) have only been profiled on WebGL.\n   */\n  preference?: 'webgl' | 'webgpu';\n}\n\nexport interface EngineEvents {\n  /** Something a guarded step or a system threw; the frame carried on. */\n  error: { where: string; error: unknown };\n  /** After every rendered frame's update, before Pixi renders. */\n  frame: { now: number; dt: number };\n}\n\n/** The stage the engine drives: its per-frame update is the engine's tick. */\nclass EngineStage extends Stage {\n  constructor(\n    app: Application,\n    textures: TextureRegistry,\n    private readonly tick: (now: number, delta: number) => void,\n  ) {\n    super(app, textures);\n  }\n\n  override update(now: number, delta: number): void {\n    this.tick(now, delta);\n  }\n}\n\n/**\n * The top of the engine: a Pixi application, the `Stage` (world and screen layers, camera, tweens, timers,\n * pointer), a fixed-step simulation loop and a stack of scenes.\n *\n * ```ts\n * const engine = await Engine.create({ parent: document.body, zoom: 3 });\n * await engine.scenes.replace(new MyLevel());\n * ```\n */\nexport class Engine {\n  readonly stage: Stage;\n  readonly loop: FixedLoop;\n  readonly scenes: SceneManager;\n  readonly events = new EventBus<EngineEvents>();\n  private running = true;\n  private destroyed = false;\n  private readonly onTick = (t: { deltaMS: number }) => this.stage.frame(t.deltaMS);\n\n  private constructor(\n    readonly app: Application,\n    textures: TextureRegistry,\n    options: EngineOptions,\n  ) {\n    this.loop = new FixedLoop(options.hz === undefined ? {} : { hz: options.hz });\n    this.stage = new EngineStage(app, textures, (now, delta) => this.tick(now, delta));\n    const cam = this.stage.cameras.main;\n    cam.setZoom(options.zoom ?? 1);\n    cam.defaultZoom = cam.zoom;\n    cam.roundPixels = options.pixelPerfect === true;\n    cam.resolution = app.renderer.resolution;\n    this.scenes = new SceneManager(this);\n    Stage.onCaught = (where, error) => this.events.emit('error', { where, error });\n    app.ticker.add(this.onTick);\n  }\n\n  static async create(options: EngineOptions): Promise<Engine> {\n    const pixel = options.pixelPerfect === true;\n    TextureSource.defaultOptions.scaleMode = pixel ? 'nearest' : 'linear';\n    const resolution = pixel ? 1 : (options.resolution ?? Math.min(2, typeof devicePixelRatio === 'number' ? devicePixelRatio : 1));\n    patchPixi();\n    const app = new Application();\n    const fill = options.width === undefined && options.height === undefined;\n    await app.init({\n      ...(fill ? { resizeTo: options.parent } : { width: options.width ?? 800, height: options.height ?? 600 }),\n      background: options.background ?? '#000000',\n      antialias: !pixel,\n      resolution,\n      autoDensity: true,\n      preference: options.preference ?? 'webgl',\n    });\n    options.parent.appendChild(app.canvas);\n    return new Engine(app, options.textures ?? new TextureRegistry(), options);\n  }\n\n  /** The scene that updates now, if any. */\n  get scene(): Scene | undefined {\n    return this.scenes.current;\n  }\n\n  /** Stops simulating and drawing; the canvas keeps its last frame. */\n  pause(): void {\n    if (!this.running) return;\n    this.running = false;\n    this.app.ticker.stop();\n  }\n\n  resume(): void {\n    if (this.running || this.destroyed) return;\n    this.running = true;\n    this.loop.reset();\n    this.app.ticker.start();\n  }\n\n  get paused(): boolean {\n    return !this.running;\n  }\n\n  /** Reports a fault to `events.error` (and the console when nobody listens). */\n  reportError(where: string, error: unknown): void {\n    if (this.events.listenerCount('error') === 0) console.error(`[engine] ${where}`, error);\n    this.events.emit('error', { where, error });\n  }\n\n  /** Leaves every scene, removes the canvas and frees the renderer. */\n  async destroy(): Promise<void> {\n    if (this.destroyed) return;\n    this.destroyed = true;\n    await this.scenes.clear();\n    this.app.ticker.remove(this.onTick);\n    if (Stage.onCaught) Stage.onCaught = null;\n    this.stage.destroy();\n    this.events.clear();\n    this.app.destroy({ removeView: true }, { children: true });\n  }\n\n  private tick(now: number, delta: number): void {\n    const scene = this.scenes.current;\n    if (scene) {\n      const report = (s: { name: string }, err: unknown) => this.reportError(`system ${s.name}`, err);\n      const step = this.loop.stepSeconds;\n      const alpha = this.loop.advance(delta, () => {\n        scene.world.run('fixed', { dt: step, now, alpha: 0 }, report);\n        scene.fixedUpdate(step);\n      });\n      const dt = delta / 1000;\n      scene.world.run('frame', { dt, now, alpha }, report);\n      scene.update(dt, alpha);\n    }\n    this.events.emit('frame', { now, dt: delta / 1000 });\n  }\n}\n"],"names":["EngineStage","Stage","app","textures","tick","now","delta","Engine","options","FixedLoop","cam","SceneManager","where","error","EventBus","t","pixel","TextureSource","resolution","patchPixi","Application","fill","TextureRegistry","scene","report","s","err","step","alpha","dt"],"mappings":"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"}

package/dist/engine/FixedLoop.js

@@ -0,0 +1,37 @@
+class i {
+  stepMs;
+  stepSeconds;
+  maxSteps;
+  carry = 0;
+  /** Steps taken since the loop started. */
+  tick = 0;
+  constructor(s = {}) {
+    const t = s.hz ?? 60;
+    if (!(t > 0)) throw new Error(`FixedLoop: hz must be positive, got ${t}`);
+    this.stepMs = 1e3 / t, this.stepSeconds = 1 / t, this.maxSteps = Math.max(1, s.maxStepsPerFrame ?? 8);
+  }
+  /**
+   * Feeds one frame of `deltaMs` and runs `step` as many times as it owes. Returns the share of a step left over
+   * (0–1), for interpolating what is drawn between the last two steps.
+   */
+  advance(s, t) {
+    s > 0 && Number.isFinite(s) && (this.carry += s);
+    let e = 0;
+    for (; this.carry >= this.stepMs; ) {
+      if (e === this.maxSteps) {
+        this.carry %= this.stepMs;
+        break;
+      }
+      this.carry -= this.stepMs, e++, t(this.tick++);
+    }
+    return this.carry / this.stepMs;
+  }
+  /** Forgets any debt, e.g. after a scene change or a long load. */
+  reset() {
+    this.carry = 0;
+  }
+}
+export {
+  i as FixedLoop
+};
+//# sourceMappingURL=FixedLoop.js.map

package/dist/engine/FixedLoop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FixedLoop.js","sources":["../../src/engine/FixedLoop.ts"],"sourcesContent":["/**\n * A fixed-timestep accumulator: frames arrive whenever the display wants them, the simulation advances in equal\n * steps. Movement and anything a server replays must run here, so every machine takes the same steps whatever its\n * frame rate.\n *\n * A frame that comes very late (a tab in the background, a debugger) would owe hundreds of steps; at most\n * `maxStepsPerFrame` are run and the rest of the debt is dropped, so the game slows down instead of freezing while it\n * catches up (the \"spiral of death\").\n */\nexport interface FixedLoopOptions {\n  /** Steps per second (default 60). */\n  hz?: number;\n  /** The most steps one frame may run before the debt is dropped (default 8). */\n  maxStepsPerFrame?: number;\n}\n\nexport class FixedLoop {\n  readonly stepMs: number;\n  readonly stepSeconds: number;\n  private readonly maxSteps: number;\n  private carry = 0;\n  /** Steps taken since the loop started. */\n  tick = 0;\n\n  constructor(options: FixedLoopOptions = {}) {\n    const hz = options.hz ?? 60;\n    if (!(hz > 0)) throw new Error(`FixedLoop: hz must be positive, got ${hz}`);\n    this.stepMs = 1000 / hz;\n    this.stepSeconds = 1 / hz;\n    this.maxSteps = Math.max(1, options.maxStepsPerFrame ?? 8);\n  }\n\n  /**\n   * Feeds one frame of `deltaMs` and runs `step` as many times as it owes. Returns the share of a step left over\n   * (0–1), for interpolating what is drawn between the last two steps.\n   */\n  advance(deltaMs: number, step: (tick: number) => void): number {\n    if (deltaMs > 0 && Number.isFinite(deltaMs)) this.carry += deltaMs;\n    let ran = 0;\n    while (this.carry >= this.stepMs) {\n      if (ran === this.maxSteps) {\n        this.carry %= this.stepMs;\n        break;\n      }\n      this.carry -= this.stepMs;\n      ran++;\n      step(this.tick++);\n    }\n    return this.carry / this.stepMs;\n  }\n\n  /** Forgets any debt, e.g. after a scene change or a long load. */\n  reset(): void {\n    this.carry = 0;\n  }\n}\n"],"names":["FixedLoop","options","hz","deltaMs","step","ran"],"mappings":"AAgBO,MAAMA,EAAU;AAAA,EACZ;AAAA,EACA;AAAA,EACQ;AAAA,EACT,QAAQ;AAAA;AAAA,EAEhB,OAAO;AAAA,EAEP,YAAYC,IAA4B,IAAI;AAC1C,UAAMC,IAAKD,EAAQ,MAAM;AACzB,QAAI,EAAEC,IAAK,GAAI,OAAM,IAAI,MAAM,uCAAuCA,CAAE,EAAE;AAC1E,SAAK,SAAS,MAAOA,GACrB,KAAK,cAAc,IAAIA,GACvB,KAAK,WAAW,KAAK,IAAI,GAAGD,EAAQ,oBAAoB,CAAC;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQE,GAAiBC,GAAsC;AAC7D,IAAID,IAAU,KAAK,OAAO,SAASA,CAAO,WAAQ,SAASA;AAC3D,QAAIE,IAAM;AACV,WAAO,KAAK,SAAS,KAAK,UAAQ;AAChC,UAAIA,MAAQ,KAAK,UAAU;AACzB,aAAK,SAAS,KAAK;AACnB;AAAA,MACF;AACA,WAAK,SAAS,KAAK,QACnBA,KACAD,EAAK,KAAK,MAAM;AAAA,IAClB;AACA,WAAO,KAAK,QAAQ,KAAK;AAAA,EAC3B;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,QAAQ;AAAA,EACf;AACF;"}