@woosh/meep-engine 2.156.0 → 2.157.0

package/src/generation/automata/CaveGeneratorCellularAutomata.js

@@ -1,59 +1,79 @@
-import { max2 } from "../../core/math/max2.js";
-import { min2 } from "../../core/math/min2.js";
-import { CellularAutomata } from "./CellularAutomata.js";
-
-export class CaveGeneratorCellularAutomata extends CellularAutomata {
-    step(data, width, height) {
-
-        const maxY = height - 1;
-        const maxX = width - 1;
-
-        for (let y = 0; y < height; y++) {
-            const rowIndex = y * width;
-
-            const rowIndexTop = max2(y - 1, 0) * width;
-            const rowIndexBottom = min2(y + 1, maxY) * width;
-
-            for (let x = 0; x < width; x++) {
-                const cellIndex = rowIndex + x;
-
-                const columnLeft = max2(x - 1, 0);
-                const columnRight = min2(x + 1, maxX);
-
-                // read top row
-                const topLeft = data[rowIndexTop + columnLeft];
-                const top = data[rowIndexTop + x];
-                const topRight = data[rowIndexTop + columnRight];
-
-                // read middle row
-                const left = data[rowIndex + columnLeft];
-                const cellValue = data[cellIndex];
-                const right = data[rowIndex + columnRight];
-
-                // read bottom row
-                const bottomLeft = data[rowIndexBottom + columnLeft];
-                const bottom = data[rowIndexBottom + x];
-                const bottomRight = data[rowIndexBottom + columnRight];
-
-                //count neighbours
-                const neighbourSum = top + bottom + left + right + topLeft + topRight + bottomLeft + bottomRight;
-
-
-                if (cellValue > 0) {
-                    //cell is alive
-                    if (neighbourSum < 4) {
-                        data[cellIndex] = false;
-                    }
-                } else {
-                    //cell is dead
-                    if (neighbourSum > 5) {
-                        data[cellIndex] = true;
-                    }
-                }
-
-            }
-
-        }
-
-    }
-}
+import { CellularAutomata } from "./CellularAutomata.js";
+
+/**
+ * Cave-generation rule: a live cell survives with 4 or more live neighbours,
+ * a dead cell becomes alive with more than 5 live neighbours.
+ *
+ * The step is synchronous: the whole next generation is computed from `source`
+ * before anything is observed from `target`, so the result does not depend on
+ * cell visit order. Out-of-bounds neighbours count as dead.
+ */
+export class CaveGeneratorCellularAutomata extends CellularAutomata {
+    step(source, target, width, height) {
+
+        const maxY = height - 1;
+        const maxX = width - 1;
+
+        for (let y = 0; y < height; y++) {
+            const rowIndex = y * width;
+
+            const rowIndexTop = rowIndex - width;
+            const rowIndexBottom = rowIndex + width;
+
+            const topValid = y > 0;
+            const bottomValid = y < maxY;
+
+            for (let x = 0; x < width; x++) {
+                const cellIndex = rowIndex + x;
+
+                const leftValid = x > 0;
+                const rightValid = x < maxX;
+
+                //count neighbours, out-of-bounds cells are dead
+                let neighbourSum = 0;
+
+                if (topValid) {
+                    neighbourSum += source[rowIndexTop + x];
+
+                    if (leftValid) {
+                        neighbourSum += source[rowIndexTop + x - 1];
+                    }
+                    if (rightValid) {
+                        neighbourSum += source[rowIndexTop + x + 1];
+                    }
+                }
+
+                if (leftValid) {
+                    neighbourSum += source[rowIndex + x - 1];
+                }
+                if (rightValid) {
+                    neighbourSum += source[rowIndex + x + 1];
+                }
+
+                if (bottomValid) {
+                    neighbourSum += source[rowIndexBottom + x];
+
+                    if (leftValid) {
+                        neighbourSum += source[rowIndexBottom + x - 1];
+                    }
+                    if (rightValid) {
+                        neighbourSum += source[rowIndexBottom + x + 1];
+                    }
+                }
+
+                const cellValue = source[cellIndex];
+
+                if (cellValue > 0) {
+                    //cell is alive
+                    target[cellIndex] = neighbourSum < 4 ? 0 : 1;
+                } else {
+                    //cell is dead
+                    target[cellIndex] = neighbourSum > 5 ? 1 : 0;
+                }
+
+            }
+
+        }
+
+    }
+}

package/src/generation/automata/CellularAutomata.d.ts

@@ -5,11 +5,14 @@ export class CellularAutomata {
      */
     random: () => number;
     /**
-     *
-     * @param {Uint8Array} data
+     * Compute a single synchronous automata step, reading cell states from `source` and
+     * writing the next generation into `target`. Every cell of `target` is written.
+     * Out-of-bounds neighbours are treated as dead (0).
+     * @param {Uint8Array} source
+     * @param {Uint8Array} target
      * @param {number} width
      * @param {number} height
      */
-    step(data: Uint8Array, width: number, height: number): void;
+    step(source: Uint8Array, target: Uint8Array, width: number, height: number): void;
 }
 //# sourceMappingURL=CellularAutomata.d.ts.map

package/src/generation/automata/CellularAutomata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellularAutomata.d.ts","sourceRoot":"","sources":["../../../../src/generation/automata/CellularAutomata.js"],"names":[],"mappings":"AAEA;IACI;;;OAGG;IACH,cAFsB,MAAM,CAEH;IAEzB;;;;;OAKG;IACH,WAJW,UAAU,SACV,MAAM,UACN,MAAM,QAIhB;CACJ"}
+{"version":3,"file":"CellularAutomata.d.ts","sourceRoot":"","sources":["../../../../src/generation/automata/CellularAutomata.js"],"names":[],"mappings":"AAEA;IACI;;;OAGG;IACH,cAFsB,MAAM,CAEH;IAEzB;;;;;;;;OAQG;IACH,aALW,UAAU,UACV,UAAU,SACV,MAAM,UACN,MAAM,QAIhB;CACJ"}

package/src/generation/automata/CellularAutomata.js

@@ -1,19 +1,22 @@
-import { seededRandom } from "../../core/math/random/seededRandom.js";
-
-export class CellularAutomata {
-    /**
-     *
-     * @type {function(): number}
-     */
-    random = seededRandom(1);
-
-    /**
-     *
-     * @param {Uint8Array} data
-     * @param {number} width
-     * @param {number} height
-     */
-    step(data, width, height) {
-
-    }
-}
+import { seededRandom } from "../../core/math/random/seededRandom.js";
+
+export class CellularAutomata {
+    /**
+     *
+     * @type {function(): number}
+     */
+    random = seededRandom(1);
+
+    /**
+     * Compute a single synchronous automata step, reading cell states from `source` and
+     * writing the next generation into `target`. Every cell of `target` is written.
+     * Out-of-bounds neighbours are treated as dead (0).
+     * @param {Uint8Array} source
+     * @param {Uint8Array} target
+     * @param {number} width
+     * @param {number} height
+     */
+    step(source, target, width, height) {
+
+    }
+}

package/src/generation/filtering/CellFilter.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Initialization protocol:
+ * - {@link CellFilter#ensureInitialized} is the guarded entry point — it is a no-op on an
+ *   already-initialized filter. Parents initialize their children through it, so shared
+ *   sub-graphs (DAGs) are initialized exactly once.
+ * - {@link CellFilter#initialize} is the subclass hook. Overrides call `super.initialize`
+ *   first (which initializes children and sets the flag), then do their own setup. Calling
+ *   it directly re-runs the hook unconditionally.
+ * - {@link CellFilter#finalize} recursively clears the initialized flag; finalize before
+ *   re-initializing a filter graph with a different grid or seed.
+ */
 export class CellFilter {
     /**
      *
@@ -5,6 +16,12 @@ export class CellFilter {
      * @protected
      */
     protected __initialized: boolean;
+    /**
+     * Input filters of this filter. Overridden by filters with inputs so that the base
+     * class can drive initialization and finalization recursion.
+     * @returns {CellFilter[]}
+     */
+    get children(): CellFilter[];
     /**
      *
      * @returns {DataType}

package/src/generation/filtering/CellFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilter.d.ts","sourceRoot":"","sources":["../../../../src/generation/filtering/CellFilter.js"],"names":[],"mappings":"AAGA;IAEI;;;;OAIG;IACH,yBAHU,OAAO,CAGK;IAEtB;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,iCAFW,MAAM,QAOhB;IAED,iBAEC;IAED;;;;;;;OAOG;IACH,2BALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;IAIL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}
+{"version":3,"file":"CellFilter.d.ts","sourceRoot":"","sources":["../../../../src/generation/filtering/CellFilter.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH;IAEI;;;;OAIG;IACH,yBAHU,OAAO,CAGK;IAEtB;;;;OAIG;IACH,6BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,iCAFW,MAAM,QAchB;IAED,iBASC;IAED;;;;;;;OAOG;IACH,2BALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;IAIL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/generation/filtering/CellFilter.js

@@ -1,77 +1,117 @@
-import { assert } from "../../core/assert.js";
-import DataType from "../../core/parser/simple/DataType.js";
-
-export class CellFilter {
-
-    /**
-     *
-     * @type {boolean}
-     * @protected
-     */
-    __initialized = false;
-
-    /**
-     *
-     * @returns {DataType}
-     */
-    get dataType() {
-        return DataType.Number;
-    }
-
-    /**
-     *
-     * @returns {boolean}
-     */
-    get initialized() {
-        return this.__initialized;
-    }
-
-    /**
-     *
-     * @param {GridData} grid
-     * @param {number} seed
-     */
-    ensureInitialized(grid, seed) {
-        if (!this.__initialized) {
-            this.initialize(grid, seed);
-
-            // make sure initialization flag is set
-            this.__initialized = true;
-        }
-    }
-
-    /**
-     *
-     * @param {GridData} grid
-     * @param {number} seed
-     */
-    initialize(grid, seed) {
-        assert.equal(grid.isGridData, true, 'grid.isGridData !== true');
-        assert.isNumber(seed, 'seed');
-
-        this.__initialized = true;
-    }
-
-    finalize() {
-        this.__initialized = false;
-    }
-
-    /**
-     *
-     * @param {GridData} grid
-     * @param {number} x Grid coordinate X
-     * @param {number} y Grid coordinate Y
-     * @param {number} rotation
-     * @returns {number}
-     */
-    execute(grid, x, y, rotation) {
-        throw new Error('Must be overridden in the subclass');
-    }
-}
-
-
-/**
- * @readonly
- * @type {boolean}
- */
-CellFilter.prototype.isCellFilter = true;
+import { assert } from "../../core/assert.js";
+import DataType from "../../core/parser/simple/DataType.js";
+
+/**
+ * Filters with no inputs share this frozen list
+ * @type {CellFilter[]}
+ */
+const NO_CHILDREN = Object.freeze([]);
+
+/**
+ * Initialization protocol:
+ * - {@link CellFilter#ensureInitialized} is the guarded entry point — it is a no-op on an
+ *   already-initialized filter. Parents initialize their children through it, so shared
+ *   sub-graphs (DAGs) are initialized exactly once.
+ * - {@link CellFilter#initialize} is the subclass hook. Overrides call `super.initialize`
+ *   first (which initializes children and sets the flag), then do their own setup. Calling
+ *   it directly re-runs the hook unconditionally.
+ * - {@link CellFilter#finalize} recursively clears the initialized flag; finalize before
+ *   re-initializing a filter graph with a different grid or seed.
+ */
+export class CellFilter {
+
+    /**
+     *
+     * @type {boolean}
+     * @protected
+     */
+    __initialized = false;
+
+    /**
+     * Input filters of this filter. Overridden by filters with inputs so that the base
+     * class can drive initialization and finalization recursion.
+     * @returns {CellFilter[]}
+     */
+    get children() {
+        return NO_CHILDREN;
+    }
+
+    /**
+     *
+     * @returns {DataType}
+     */
+    get dataType() {
+        return DataType.Number;
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    get initialized() {
+        return this.__initialized;
+    }
+
+    /**
+     *
+     * @param {GridData} grid
+     * @param {number} seed
+     */
+    ensureInitialized(grid, seed) {
+        if (!this.__initialized) {
+            this.initialize(grid, seed);
+
+            // make sure initialization flag is set
+            this.__initialized = true;
+        }
+    }
+
+    /**
+     *
+     * @param {GridData} grid
+     * @param {number} seed
+     */
+    initialize(grid, seed) {
+        assert.equal(grid.isGridData, true, 'grid.isGridData !== true');
+        assert.isNumber(seed, 'seed');
+
+        const children = this.children;
+        const n = children.length;
+
+        for (let i = 0; i < n; i++) {
+            children[i].ensureInitialized(grid, seed);
+        }
+
+        this.__initialized = true;
+    }
+
+    finalize() {
+        const children = this.children;
+        const n = children.length;
+
+        for (let i = 0; i < n; i++) {
+            children[i].finalize();
+        }
+
+        this.__initialized = false;
+    }
+
+    /**
+     *
+     * @param {GridData} grid
+     * @param {number} x Grid coordinate X
+     * @param {number} y Grid coordinate Y
+     * @param {number} rotation
+     * @returns {number}
+     */
+    execute(grid, x, y, rotation) {
+        throw new Error('Must be overridden in the subclass');
+    }
+}
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+CellFilter.prototype.isCellFilter = true;

package/src/generation/filtering/CellFilterCellMatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterCellMatcher.d.ts","sourceRoot":"","sources":["../../../../src/generation/filtering/CellFilterCellMatcher.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAeI;;;;OAIG;IACH,mCAFa,qBAAqB,CAYjC;IA1BG;;;OAGG;IACH,qBAAmB;IAGvB,uCAEC;IAmBD,yDAKC;CACJ;2BA5C0B,iBAAiB"}
+{"version":3,"file":"CellFilterCellMatcher.d.ts","sourceRoot":"","sources":["../../../../src/generation/filtering/CellFilterCellMatcher.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAiBI;;;;OAIG;IACH,mCAFa,qBAAqB,CAYjC;IA5BG;;;OAGG;IACH,qBAAmB;IAGvB,uCAIC;IAmBD,yDAKC;CACJ;2BA9C0B,iBAAiB"}

package/src/generation/filtering/CellFilterCellMatcher.js

@@ -16,6 +16,8 @@ export class CellFilterCellMatcher extends CellFilter {
     }
 
     initialize(grid, seed) {
+        super.initialize(grid, seed);
+
         this.matcher.initialize(grid, seed);
     }
 

package/src/generation/filtering/boolean/CellFilterLiteralBoolean.d.ts

@@ -5,6 +5,11 @@ export class CellFilterLiteralBoolean extends CellFilter {
      */
     static from(value: boolean): CellFilterLiteralBoolean;
     value: boolean;
+    execute(grid: any, x: any, y: any, rotation: any): 0 | 1;
+}
+export namespace CellFilterLiteralBoolean {
+    let TRUE: CellFilterLiteralBoolean;
+    let FALSE: CellFilterLiteralBoolean;
 }
 import { CellFilter } from "../CellFilter.js";
 //# sourceMappingURL=CellFilterLiteralBoolean.d.ts.map

package/src/generation/filtering/boolean/CellFilterLiteralBoolean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterLiteralBoolean.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/boolean/CellFilterLiteralBoolean.js"],"names":[],"mappings":"AAIA;IAII;;;OAGG;IACH,mBAFW,OAAO,4BAUjB;IAdD,eAAa;CAmBhB;2BAvB0B,kBAAkB"}
+{"version":3,"file":"CellFilterLiteralBoolean.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/boolean/CellFilterLiteralBoolean.js"],"names":[],"mappings":"AAIA;IAII;;;OAGG;IACH,mBAFW,OAAO,4BAUjB;IAdD,eAAa;IAoBb,yDAEC;CACJ;;cAIS,wBAAwB;eAKxB,wBAAwB;;2BApCP,kBAAkB"}

package/src/generation/filtering/boolean/CellFilterLiteralBoolean.js

@@ -23,4 +23,19 @@ export class CellFilterLiteralBoolean extends CellFilter {
     get dataType() {
         return DataType.Boolean;
     }
+
+    execute(grid, x, y, rotation) {
+        return this.value ? 1 : 0;
+    }
 }
+
+/**
+ * @readonly
+ * @type {CellFilterLiteralBoolean}
+ */
+CellFilterLiteralBoolean.TRUE = CellFilterLiteralBoolean.from(true);
+/**
+ * @readonly
+ * @type {CellFilterLiteralBoolean}
+ */
+CellFilterLiteralBoolean.FALSE = CellFilterLiteralBoolean.from(false);

package/src/generation/filtering/core/CellFilterBinaryOperation.d.ts

@@ -17,7 +17,6 @@ export class CellFilterBinaryOperation extends CellFilter {
      */
     operation<T, R>(left: T, right: T): R;
     execute(grid: any, x: any, y: any, rotation: any): any;
-    initialize(grid: any, seed: any): void;
 }
 import { CellFilter } from "../CellFilter.js";
 //# sourceMappingURL=CellFilterBinaryOperation.d.ts.map

package/src/generation/filtering/core/CellFilterBinaryOperation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterBinaryOperation.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/core/CellFilterBinaryOperation.js"],"names":[],"mappings":"AAEA;IAEI;;;OAGG;IACH,MAFU,UAAU,CAER;IAEZ;;;OAGG;IACH,OAFU,UAAU,CAEP;IAEb;;;;;OAKG;IACH,sCAEC;IAED,uDAKC;IAED,uCAeC;CACJ;2BAjD0B,kBAAkB"}
+{"version":3,"file":"CellFilterBinaryOperation.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/core/CellFilterBinaryOperation.js"],"names":[],"mappings":"AAEA;IAEI;;;OAGG;IACH,MAFU,UAAU,CAER;IAEZ;;;OAGG;IACH,OAFU,UAAU,CAEP;IAMb;;;;;OAKG;IACH,sCAEC;IAED,uDAKC;CACJ;2BApC0B,kBAAkB"}

package/src/generation/filtering/core/CellFilterBinaryOperation.js

@@ -1,50 +1,37 @@
-import { CellFilter } from "../CellFilter.js";
-
-export class CellFilterBinaryOperation extends CellFilter {
-
-    /**
-     *
-     * @type {CellFilter}
-     */
-    left = null;
-
-    /**
-     *
-     * @type {CellFilter}
-     */
-    right = null;
-
-    /**
-     * @template T,R
-     * @param {T} left
-     * @param {T} right
-     * @returns {R}
-     */
-    operation(left, right) {
-        throw new Error('Not implemented');
-    }
-
-    execute(grid, x, y, rotation) {
-        const left = this.left.execute(grid, x, y, rotation);
-        const right = this.right.execute(grid, x, y, rotation);
-
-        return this.operation(left, right);
-    }
-
-    initialize(grid, seed) {
-        if (this.initialized) {
-            return;
-        }
-
-        super.initialize(grid, seed);
-
-        if (!this.left.initialized) {
-            this.left.initialize(grid, seed);
-        }
-
-        if (!this.right.initialized) {
-            this.right.initialize(grid, seed);
-        }
-
-    }
-}
+import { CellFilter } from "../CellFilter.js";
+
+export class CellFilterBinaryOperation extends CellFilter {
+
+    /**
+     *
+     * @type {CellFilter}
+     */
+    left = null;
+
+    /**
+     *
+     * @type {CellFilter}
+     */
+    right = null;
+
+    get children() {
+        return [this.left, this.right];
+    }
+
+    /**
+     * @template T,R
+     * @param {T} left
+     * @param {T} right
+     * @returns {R}
+     */
+    operation(left, right) {
+        throw new Error('Not implemented');
+    }
+
+    execute(grid, x, y, rotation) {
+        const left = this.left.execute(grid, x, y, rotation);
+        const right = this.right.execute(grid, x, y, rotation);
+
+        return this.operation(left, right);
+    }
+}

package/src/generation/filtering/core/CellFilterOperationTertiary.d.ts

@@ -22,7 +22,6 @@ export class CellFilterOperationTertiary extends CellFilter {
      * @returns {number}
      */
     operation(a: number, b: number, c: number): number;
-    initialize(grid: any, seed: any): void;
     execute(grid: any, x: any, y: any, rotation: any): number;
 }
 import { CellFilter } from "../CellFilter.js";

package/src/generation/filtering/core/CellFilterOperationTertiary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterOperationTertiary.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/core/CellFilterOperationTertiary.js"],"names":[],"mappings":"AAEA;IAEI;;;OAGG;IACH,GAFU,UAAU,CAEX;IACT;;;OAGG;IACH,GAFU,UAAU,CAEX;IACT;;;OAGG;IACH,GAFU,UAAU,CAEX;IAET;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;IAED,uCAkBC;IAED,0DAMC;CACJ;2BA1D0B,kBAAkB"}
+{"version":3,"file":"CellFilterOperationTertiary.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/core/CellFilterOperationTertiary.js"],"names":[],"mappings":"AAEA;IAEI;;;OAGG;IACH,GAFU,UAAU,CAEX;IACT;;;OAGG;IACH,GAFU,UAAU,CAEX;IACT;;;OAGG;IACH,GAFU,UAAU,CAEX;IAMT;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;IAED,0DAMC;CACJ;2BA1C0B,kBAAkB"}