@vworlds/vecs 1.0.10 → 1.0.12

package/dist/timer.js

@@ -0,0 +1,154 @@
+/** Shared state and start/stop control for concrete tick sources. */
+class BaseTickSource {
+    constructor() {
+        /** @internal */
+        this._didTick = false;
+        /** @internal */
+        this._running = true;
+        /** @internal */
+        this._lastEvaluatedFrame = -1;
+        /** @internal */
+        this._timeSinceLastTick = 0;
+        /** @internal Delta accumulated into the most recent tick, in milliseconds. */
+        this._lastFireDelta = 0;
+    }
+    get didTick() {
+        return this._didTick;
+    }
+    get lastFireDelta() {
+        return this._lastFireDelta;
+    }
+    /** Resume this source without replaying time elapsed while stopped. */
+    start() {
+        this._running = true;
+        return this;
+    }
+    /** Pause this source, freezing accumulators and counters until `start()`. */
+    stop() {
+        this._running = false;
+        return this;
+    }
+    /** @internal Register this source with `world`. */
+    _register(world) {
+        world._registerTickSource(this);
+    }
+}
+/** Fires every `intervalSeconds` of accumulated wall-clock time. */
+export class IntervalTickSource extends BaseTickSource {
+    /**
+     * Create an interval source.
+     *
+     * Intervals are expressed in seconds, unlike `World.progress` and
+     * `World.beginFrame`, which receive millisecond deltas. Large deltas produce
+     * at most one tick; residual time is preserved by subtracting the interval.
+     *
+     * @param intervalSeconds - Positive interval duration in seconds.
+     * @throws When `intervalSeconds` is less than or equal to zero.
+     */
+    constructor(intervalSeconds) {
+        super();
+        this._accumulator = 0;
+        if (intervalSeconds <= 0) {
+            throw "interval seconds must be greater than 0";
+        }
+        this._intervalMs = intervalSeconds * 1000;
+    }
+    /** @internal */
+    _evalTick(deltaMs, frameId) {
+        if (this._lastEvaluatedFrame === frameId) {
+            return this._didTick;
+        }
+        this._lastEvaluatedFrame = frameId;
+        if (!this._running) {
+            this._didTick = false;
+            return false;
+        }
+        this._timeSinceLastTick += deltaMs;
+        this._accumulator += deltaMs;
+        let fired = false;
+        if (this._accumulator >= this._intervalMs) {
+            this._accumulator -= this._intervalMs;
+            fired = true;
+            this._lastFireDelta = this._timeSinceLastTick;
+            this._timeSinceLastTick = 0;
+        }
+        this._didTick = fired;
+        return fired;
+    }
+}
+/** Fires every `rate` ticks of `source`, or every `rate` frames without one. */
+export class RateTickSource extends BaseTickSource {
+    /**
+     * Create a rate filter.
+     *
+     * Without `source`, this counts world frames. With `source`, it counts ticks
+     * from that upstream clock. The source is immutable, so cyclic source graphs
+     * cannot be constructed through the public API.
+     *
+     * @param rate - Positive integer tick divisor.
+     * @param source - Optional upstream source to divide.
+     * @throws When `rate` is not a positive integer.
+     */
+    constructor(rate, source) {
+        super();
+        this._counter = 0;
+        if (!Number.isInteger(rate) || rate <= 0) {
+            throw "rate must be a positive integer";
+        }
+        this._rate = rate;
+        this._source = source;
+    }
+    /** @internal */
+    _evalTick(deltaMs, frameId) {
+        if (this._lastEvaluatedFrame === frameId) {
+            return this._didTick;
+        }
+        this._lastEvaluatedFrame = frameId;
+        if (!this._running) {
+            this._didTick = false;
+            return false;
+        }
+        const upstreamFired = this._source ? this._source._evalTick(deltaMs, frameId) : true;
+        const upstreamDelta = this._source ? this._source.lastFireDelta : deltaMs;
+        let fired = false;
+        if (upstreamFired) {
+            this._timeSinceLastTick += upstreamDelta;
+            this._counter++;
+            if (this._counter >= this._rate) {
+                this._counter = 0;
+                fired = true;
+                this._lastFireDelta = this._timeSinceLastTick;
+                this._timeSinceLastTick = 0;
+            }
+        }
+        this._didTick = fired;
+        return fired;
+    }
+    /** @internal */
+    _register(world) {
+        super._register(world);
+        this._source?._register(world);
+    }
+}
+/** @internal Singleton source used by systems with no explicit cadence. */
+class _AlwaysTickSource {
+    constructor() {
+        this._lastDelta = 0;
+    }
+    get didTick() {
+        return true;
+    }
+    get lastFireDelta() {
+        return this._lastDelta;
+    }
+    /** @internal */
+    _evalTick(deltaMs, _frameId) {
+        this._lastDelta = deltaMs;
+        return true;
+    }
+    /** @internal */
+    _register(_world) { }
+}
+/** @internal Shared default clock for unconfigured systems. */
+export const ALWAYS_TICK_SOURCE = new _AlwaysTickSource();
+//# sourceMappingURL=timer.js.map

package/dist/timer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.js","sourceRoot":"","sources":["../src/timer.ts"],"names":[],"mappings":"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"}

package/dist/util/array_map.d.ts

@@ -1,58 +1,7 @@
 /**
- * A `Map<number, T>` backed by a sparse JavaScript array.
+ * Read-only view of an {@link ArrayMap}: the mutating methods `set`, `delete`,
+ * and `clear` are omitted.
  *
- * For small, dense integer key spaces this is significantly faster than
- * `Map` because array index access avoids the hash-table overhead. Used
- * internally to store per-entity component instances and per-type component
- * metadata.
- *
- * Keys must be non-negative integers. Gaps in the key space are represented
- * as `undefined` slots and do not count toward `size`.
- *
- * @typeParam T - The value type stored in the map.
+ * @typeParam T - Value type stored in the map.
  */
-export declare class ArrayMap<T> {
-    private backend;
-    private _size;
-    constructor();
-    /**
-     * Store `value` at `key`, replacing any existing value.
-     *
-     * @param key - Non-negative integer key.
-     * @param value - Value to store.
-     */
-    set(key: number, value: T): void;
-    /**
-     * Return the value stored at `key`, or `undefined` if not present.
-     *
-     * @param key - Non-negative integer key.
-     */
-    get(key: number): T | undefined;
-    /**
-     * Remove the entry at `key`. Does nothing if `key` is not present.
-     *
-     * @param key - Non-negative integer key.
-     */
-    delete(key: number): void;
-    /**
-     * Return `true` if an entry exists at `key`.
-     *
-     * @param key - Non-negative integer key.
-     */
-    has(key: number): boolean;
-    /**
-     * Iterate over all present entries.
-     *
-     * Undefined slots are skipped; the callback is only called for keys that
-     * have an associated value.
-     *
-     * @param callback - Called with `(value, key, map)` for each entry.
-     */
-    forEach(callback: (value: T, key: number, map: ArrayMap<T>) => void): void;
-    /**
-     * Remove all entries and reset the size to zero.
-     */
-    clear(): void;
-    /** The number of entries currently in the map. */
-    get size(): number;
-}
+export type ReadonlyArrayMap<T> = Omit<ArrayMap<T>, "set" | "delete" | "clear">;

package/dist/util/array_map.js

@@ -1,84 +1,82 @@
 /**
- * A `Map<number, T>` backed by a sparse JavaScript array.
+ * A `Map<number, T>` substitute backed by a sparse JavaScript array.
  *
- * For small, dense integer key spaces this is significantly faster than
- * `Map` because array index access avoids the hash-table overhead. Used
- * internally to store per-entity component instances and per-type component
- * metadata.
+ * For small, dense, non-negative integer key spaces, indexing into a regular
+ * array is faster than the hash-table lookups performed by the built-in
+ * `Map`. `ArrayMap` is used inside the ECS to store per-entity component
+ * instances and per-type metadata.
  *
- * Keys must be non-negative integers. Gaps in the key space are represented
- * as `undefined` slots and do not count toward `size`.
+ * Empty slots are represented as `undefined` and do not count toward
+ * {@link size}.
  *
- * @typeParam T - The value type stored in the map.
+ * @internal Used only inside the package.
+ *
+ * @typeParam T - Value type stored in the map.
  */
 export class ArrayMap {
     constructor() {
-        this.backend = [];
+        this._backend = [];
         this._size = 0;
     }
+    /** The number of entries currently in the map. */
+    get size() {
+        return this._size;
+    }
     /**
-     * Store `value` at `key`, replacing any existing value.
+     * Insert or replace the value at `key`.
      *
      * @param key - Non-negative integer key.
      * @param value - Value to store.
      */
     set(key, value) {
-        if (this.backend[key] === undefined) {
+        if (this._backend[key] === undefined) {
             this._size++;
         }
-        this.backend[key] = value;
+        this._backend[key] = value;
     }
     /**
-     * Return the value stored at `key`, or `undefined` if not present.
+     * Retrieve the value stored at `key`, or `undefined` if no entry exists.
      *
      * @param key - Non-negative integer key.
      */
     get(key) {
-        return this.backend[key];
+        return this._backend[key];
     }
     /**
-     * Remove the entry at `key`. Does nothing if `key` is not present.
+     * Return `true` when an entry exists at `key`.
      *
      * @param key - Non-negative integer key.
      */
-    delete(key) {
-        if (this.backend[key] !== undefined) {
-            this.backend[key] = undefined;
-            this._size--;
-        }
+    has(key) {
+        return this._backend[key] !== undefined;
     }
     /**
-     * Return `true` if an entry exists at `key`.
+     * Remove the entry at `key`. Does nothing if no entry exists there.
      *
      * @param key - Non-negative integer key.
      */
-    has(key) {
-        return this.backend[key] !== undefined;
+    delete(key) {
+        if (this._backend[key] !== undefined) {
+            this._backend[key] = undefined;
+            this._size--;
+        }
     }
     /**
-     * Iterate over all present entries.
-     *
-     * Undefined slots are skipped; the callback is only called for keys that
-     * have an associated value.
+     * Visit every present entry in ascending key order. Empty slots are skipped.
      *
-     * @param callback - Called with `(value, key, map)` for each entry.
+     * @param callback - Invoked with `(value, key, map)` for each entry.
      */
     forEach(callback) {
-        this.backend.forEach((value, index) => {
+        this._backend.forEach((value, index) => {
             if (value !== undefined) {
                 callback(value, index, this);
             }
         });
     }
-    /**
-     * Remove all entries and reset the size to zero.
-     */
+    /** Remove all entries and reset {@link size} to zero. */
     clear() {
-        this.backend.length = 0;
-    }
-    /** The number of entries currently in the map. */
-    get size() {
-        return this._size;
+        this._backend.length = 0;
+        this._size = 0;
     }
 }
 //# sourceMappingURL=array_map.js.map

package/dist/util/array_map.js.map

@@ -1 +1 @@
-{"version":3,"file":"array_map.js","sourceRoot":"","sources":["../../src/util/array_map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,QAAQ;IAInB;QACE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,GAAW,EAAE,KAAQ;QACvB,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YACnC,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,GAAW;QAChB,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YACnC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;YAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;IACH,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;IACzC,CAAC;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,QAA2D;QACjE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACpC,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;aAC9B;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED,kDAAkD;IAClD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;CACF"}
+{"version":3,"file":"array_map.js","sourceRoot":"","sources":["../../src/util/array_map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,QAAQ;IAArB;QACU,aAAQ,GAAsB,EAAE,CAAC;QACjC,UAAK,GAAW,CAAC,CAAC;IAoE5B,CAAC;IAlEC,kDAAkD;IAClD,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACI,GAAG,CAAC,GAAW,EAAE,KAAQ;QAC9B,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YACpC,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACI,GAAG,CAAC,GAAW;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACI,GAAG,CAAC,GAAW;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,GAAW;QACvB,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;YACpC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;YAC/B,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;IACH,CAAC;IAED;;;;OAIG;IACI,OAAO,CAAC,QAA2D;QACxE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACrC,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;aAC9B;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,yDAAyD;IAClD,KAAK;QACV,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;IACjB,CAAC;CACF"}

package/dist/util/bitset.d.ts

@@ -2,93 +2,79 @@
  * A compact, growable set of non-negative integers backed by an array of
  * 32-bit words.
  *
- * Used internally to represent entity archetypes (the set of component type
- * ids attached to an entity) and system watchlists. Exposed in the public API
- * so that component data can use it for bit-flag fields:
+ * `Bitset` is the data structure the ECS uses to represent entity archetypes
+ * (the set of component type ids attached to an entity) and watchlists
+ * (the set of component types a query reacts to).
+ *
+ * It is exported in the public API so component data can use it for
+ * compact bit-flag fields:
  *
  * ```ts
  * class Tags extends Component {
- *   tags    = new Bitset();
- *   oldTags = new Bitset();
+ *   tags = new Bitset();
  * }
  *
- * // Check a specific tag bit:
+ * tags.tags.add(TAG_VISIBLE);
  * if (tags.tags.has(TAG_VISIBLE)) { ... }
  * ```
  */
 export declare class Bitset {
-    /** @internal */
-    _bits: number[];
-    constructor();
-    /**
-     * Return `true` if this bitset and `other` have exactly the same bits set.
-     */
-    equal(other: Bitset): boolean;
     /**
-     * OR the given `bitmask` word into the word at position `arrayIndex`.
-     *
-     * @internal Low-level bulk operation; prefer {@link add} for single bits.
-     */
-    addIndexBitmask(arrayIndex: number, bitmask: number): void;
-    /**
-     * Replace the word at position `arrayIndex` with `bitmask`.
+     * Set bit `n`.
      *
-     * @internal Used by network deserialization to set a whole word at once.
+     * @param n - Non-negative integer bit index.
      */
-    setIndexBitmask(arrayIndex: number, bitmask: number): void;
+    add(n: number): void;
     /**
      * Set the bit described by `bptr` (fast path using a pre-computed
      * {@link BitPtr}).
+     *
+     * @param bptr - Pre-computed pointer to a bit position.
      */
     addBit(bptr: BitPtr): void;
     /**
-     * Set bit `n`.
+     * Clear bit `n`. Trailing zero words are trimmed so the internal storage
+     * stays compact.
      *
      * @param n - Non-negative integer bit index.
      */
-    add(n: number): void;
+    delete(n: number): void;
     /**
-     * Clear bit `n`.
-     *
-     * Trailing zero words are trimmed so that the internal array stays compact.
+     * Return `true` when bit `n` is set.
      *
      * @param n - Non-negative integer bit index.
      */
-    delete(n: number): void;
-    /**
-     * Return `true` if the bit described by `bptr` is set (fast path).
-     */
-    hasBit(bptr: BitPtr): boolean;
+    has(n: number): boolean;
     /**
-     * Return `true` if bit `n` is set.
+     * Return `true` when the bit described by `bptr` is set (fast path).
      *
-     * @param n - Non-negative integer bit index.
+     * @param bptr - Pre-computed pointer to a bit position.
      */
-    has(n: number): boolean;
+    hasBit(bptr: BitPtr): boolean;
     /**
-     * Return `true` if the given word-level bitmask is fully set at `arrayIndex`.
+     * Return `true` when this bitset and `other` have exactly the same bits set.
      *
-     * @internal
+     * @param other - Bitset to compare against.
      */
-    hasIndexBitmask(arrayIndex: number, bitmask: number): boolean;
+    equal(other: Bitset): boolean;
     /**
-     * Return `true` if every bit set in `other` is also set in `this` (i.e.
-     * `other` is a subset of `this`).
+     * Return `true` when every bit set in `other` is also set in this bitset
+     * (i.e. `other` is a subset of `this`).
      *
      * Used by the world to test whether an entity's archetype satisfies a
-     * system's `HAS` query.
+     * `HAS` query.
+     *
+     * @param other - Bitset whose set bits must all appear in this bitset.
      */
     hasBitset(other: Bitset): boolean;
     /**
-     * Iterate over every set bit index in ascending order.
+     * Visit each set bit index in ascending order.
      *
-     * @param callback - Called with each set bit index.
+     * @param callback - Invoked once per set bit.
      */
     forEach(callback: (n: number) => void): void;
     /**
-     * Return an array of all set bit indices in ascending order.
-     *
-     * @returns `number[]` of set bit positions.
+     * Return an array of every set bit index in ascending order.
      */
     indices(): number[];
 }
@@ -96,12 +82,12 @@ export declare class Bitset {
  * A pre-computed pointer into a {@link Bitset}'s internal word array.
  *
  * Computing `arrayIndex` and `bitmask` from a raw bit index requires a floor
- * division and a bitshift. `BitPtr` caches those values so that hot-path
+ * division and a bit shift. `BitPtr` caches both values so that hot-path
  * archetype checks ({@link Bitset.hasBit}, {@link Bitset.addBit}) avoid
  * repeating the arithmetic on every entity update.
  *
- * A `BitPtr` is created once per component type and stored on
- * {@link ComponentMeta.bitPtr}.
+ * One `BitPtr` is created per registered component type and stored on
+ * `ComponentMeta.bitPtr`.
  */
 export declare class BitPtr {
     /** The raw bit index this pointer refers to. */
@@ -113,6 +99,10 @@ export declare class BitPtr {
     constructor(
     /** The raw bit index this pointer refers to. */
     value: number);
-    /** Return `true` if both pointers refer to the same bit position. */
+    /**
+     * Return `true` when both pointers refer to the same bit position.
+     *
+     * @param other - Pointer to compare against.
+     */
     equals(other: BitPtr): boolean;
 }