@woosh/meep-engine 2.169.0 → 2.169.2

package/src/generation/filtering/numeric/math/CellFilterPower.d.ts

@@ -6,7 +6,7 @@ export class CellFilterPower extends CellFilterBinaryOperation {
      * @returns {CellFilterPower}
      */
     static from(value: CellFilter, power: CellFilter): CellFilterPower;
-    execute(grid: any, x: any, y: any, rotation: any): number;
+    operation(value: any, power: any): number;
 }
 import { CellFilterBinaryOperation } from "../../core/CellFilterBinaryOperation.js";
 //# sourceMappingURL=CellFilterPower.d.ts.map

package/src/generation/filtering/numeric/math/CellFilterPower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterPower.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/math/CellFilterPower.js"],"names":[],"mappings":"AAGA;IAGI;;;;;OAKG;IACH,mDAFa,eAAe,CAY3B;IAED,0DAKC;CACJ;0CA9ByC,yCAAyC"}
+{"version":3,"file":"CellFilterPower.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/math/CellFilterPower.js"],"names":[],"mappings":"AAGA;IAEI;;;;;OAKG;IACH,mDAFa,eAAe,CAY3B;IAED,0CAEC;CACJ;0CA1ByC,yCAAyC"}

package/src/generation/filtering/numeric/math/CellFilterPower.js

@@ -3,7 +3,6 @@ import { assert } from "../../../../core/assert.js";
 
 export class CellFilterPower extends CellFilterBinaryOperation {
 
-
     /**
      *
      * @param {CellFilter} value
@@ -22,10 +21,7 @@ export class CellFilterPower extends CellFilterBinaryOperation {
         return r;
     }
 
-    execute(grid, x, y, rotation) {
-        const value = this.left.execute(grid, x, y, rotation);
-        const power = this.right.execute(grid, x, y, rotation);
-
+    operation(value, power) {
         return Math.pow(value, power);
     }
 }

package/src/generation/filtering/numeric/process/computeCellFilterGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeCellFilterGradient.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeCellFilterGradient.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kDATW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,uCAKJ,OAAO,CAsCnB"}
+{"version":3,"file":"computeCellFilterGradient.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeCellFilterGradient.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,kDATW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,uCAKJ,OAAO,CA2BnB"}

package/src/generation/filtering/numeric/process/computeCellFilterGradient.js

@@ -1,3 +1,12 @@
+import { v2_length } from "../../../../core/geom/vec2/v2_length.js";
+import { computeCellFilterSobel } from "./computeCellFilterSobel.js";
+
+/**
+ * Scratch for the raw gradient. Read out before `result` is written, so `result` may alias it.
+ * @type {Float64Array}
+ */
+const scratch_gradient = new Float64Array(2);
+
 /**
  *
  * @param {number[]} result
@@ -11,24 +20,13 @@
  */
 export function computeCellFilterGradient(result, x, y, filter, grid) {
 
-    //read surrounding points
-    const topLeft = filter.execute(grid, x - 1, y - 1, 0);
-    const top = filter.execute(grid, x, y - 1, 0);
-    const topRight = filter.execute(grid, x + 1, y - 1, 0);
-
-    const left = filter.execute(grid, x - 1, y, 0);
-    const right = filter.execute(grid, x + 1, y, 0);
-
-    const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
-    const bottom = filter.execute(grid, x, y + 1, 0);
-    const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
+    computeCellFilterSobel(scratch_gradient, 0, filter, grid, x, y);
 
-    // compute gradients
-    const dX = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
-    const dY = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
+    const dX = scratch_gradient[0];
+    const dY = scratch_gradient[1];
 
     //normalize vector
-    const magnitude = Math.sqrt(dX * dX + dY * dY);
+    const magnitude = v2_length(dX, dY);
 
     if (magnitude === 0) {
         result[0] = 0;

package/src/generation/filtering/numeric/process/computeCellFilterSobel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Apply the 3x3 Sobel operator to a {@link CellFilter} at a grid position, writing the raw
+ * (un-normalized) gradient vector into `result`.
+ *
+ * This exists so that the eight-tap read and the operator's kernel weights have a single
+ * definition: everything downstream of the taps (magnitude, direction, thresholding) differs
+ * between callers, but the taps themselves must not.
+ *
+ * The source filter is sampled at rotation 0 — the operator is defined in grid space, so rotating
+ * the taps would rotate the reported gradient with them and cancel out.
+ *
+ * @param {Float64Array|Float32Array|number[]} result receives `[dX, dY]`
+ * @param {number} result_offset
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ */
+export function computeCellFilterSobel(result: Float64Array | Float32Array | number[], result_offset: number, filter: CellFilter, grid: GridData, x: number, y: number): void;
+//# sourceMappingURL=computeCellFilterSobel.d.ts.map

package/src/generation/filtering/numeric/process/computeCellFilterSobel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeCellFilterSobel.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeCellFilterSobel.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,yCAGN,MAAM,KACN,MAAM,QAmBhB"}

package/src/generation/filtering/numeric/process/computeCellFilterSobel.js

@@ -0,0 +1,36 @@
+/**
+ * Apply the 3x3 Sobel operator to a {@link CellFilter} at a grid position, writing the raw
+ * (un-normalized) gradient vector into `result`.
+ *
+ * This exists so that the eight-tap read and the operator's kernel weights have a single
+ * definition: everything downstream of the taps (magnitude, direction, thresholding) differs
+ * between callers, but the taps themselves must not.
+ *
+ * The source filter is sampled at rotation 0 — the operator is defined in grid space, so rotating
+ * the taps would rotate the reported gradient with them and cancel out.
+ *
+ * @param {Float64Array|Float32Array|number[]} result receives `[dX, dY]`
+ * @param {number} result_offset
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ */
+export function computeCellFilterSobel(result, result_offset, filter, grid, x, y) {
+
+    //read surrounding points
+    const topLeft = filter.execute(grid, x - 1, y - 1, 0);
+    const top = filter.execute(grid, x, y - 1, 0);
+    const topRight = filter.execute(grid, x + 1, y - 1, 0);
+
+    const left = filter.execute(grid, x - 1, y, 0);
+    const right = filter.execute(grid, x + 1, y, 0);
+
+    const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
+    const bottom = filter.execute(grid, x, y + 1, 0);
+    const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
+
+    // compute gradients
+    result[result_offset] = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
+    result[result_offset + 1] = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
+}

package/src/generation/filtering/numeric/util/CellFilterDisplaced.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterDisplaced.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/CellFilterDisplaced.js"],"names":[],"mappings":"AAIA;IAQI;;;;;;OAMG;IACH,mCAJW,MAAM,KACN,MAAM,GACL,mBAAmB,CAW9B;IAvBD;;;OAGG;IACH,iBAFU,OAAO,CAEM;CAmC1B;yCA5CwC,wCAAwC;oBAC7D,kCAAkC"}
+{"version":3,"file":"CellFilterDisplaced.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/CellFilterDisplaced.js"],"names":[],"mappings":"AAWA;IAQI;;;;;;OAMG;IACH,mCAJW,MAAM,KACN,MAAM,GACL,mBAAmB,CAW9B;IAvBD;;;OAGG;IACH,iBAFU,OAAO,CAEM;CAiC1B;yCAjDwC,wCAAwC;oBAC7D,kCAAkC"}

package/src/generation/filtering/numeric/util/CellFilterDisplaced.js

@@ -1,7 +1,14 @@
 import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
+import { v2_rotate } from "../../../../core/geom/vec2/v2_rotate.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Scratch for the rotated offset. Read out before any nested filter call, so it cannot alias.
+ * @type {Float64Array}
+ */
+const scratch_offset = new Float64Array(2);
+
 export class CellFilterDisplaced extends CellFilterUnaryOperation {
     /**
      * @readonly
@@ -30,14 +37,12 @@ export class CellFilterDisplaced extends CellFilterUnaryOperation {
 
     execute(grid, x, y, rotation) {
 
-        const sin = Math.sin(rotation);
-        const cos = Math.cos(rotation);
+        const offset = this.offset;
 
-        const local_x = this.offset.x;
-        const local_y = this.offset.y;
+        v2_rotate(scratch_offset, 0, offset.x, offset.y, rotation);
 
-        const rotated_local_x = local_x * cos - local_y * sin
-        const rotated_local_y = local_x * sin + local_y * cos;
+        const rotated_local_x = scratch_offset[0];
+        const rotated_local_y = scratch_offset[1];
 
         return this.source.execute(grid, x + rotated_local_x, y + rotated_local_y, rotation);
 

package/src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateSampler2DFromCellFilter.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2FA2BC"}
+{"version":3,"file":"populateSampler2DFromCellFilter.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,2FAQC"}

package/src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js

@@ -1,36 +1,18 @@
-import { assert } from "../../../../core/assert.js";
-
-/**
- * Utility function, mainly useful for visualizing filter values
- * @param {Sampler2D} result
- * @param {CellFilter} filter
- * @param {GridData} grid
- */
-export function populateSampler2DFromCellFilter({ result, filter, grid }) {
-    assert.defined(result,'result');
-    assert.defined(filter,'filter');
-    assert.defined(grid,'grid');
-
-    filter.ensureInitialized(grid, 0);
-
-    // ratio mapping, texel t of the result represents grid t / scale (see generation/COORDINATES.md)
-    const scale_x = result.width / grid.width;
-    const scale_y = result.height / grid.height;
-
-    const result_height = result.height;
-
-    for (let y = 0; y < result_height; y++) {
-
-        const grid_y = y / scale_y;
-
-        for (let x = 0; x < result.width; x++) {
-
-            const grid_x = x / scale_x;
-
-            const filterValue = filter.execute(grid, grid_x, grid_y, 0);
-
-            result.writeChannel(x, y, 0, filterValue);
-
-        }
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { write_cell_filter_to_sampler2d } from "./write_cell_filter_to_sampler2d.js";
+
+/**
+ * Utility function, mainly useful for visualizing filter values
+ * @param {Sampler2D} result
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ */
+export function populateSampler2DFromCellFilter({ result, filter, grid }) {
+    assert.defined(result,'result');
+    assert.defined(filter,'filter');
+    assert.defined(grid,'grid');
+
+    filter.ensureInitialized(grid, 0);
+
+    write_cell_filter_to_sampler2d(result, filter, grid);
+}

package/src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Rasterize a {@link CellFilter} into channel 0 of a {@link Sampler2D} that covers the whole grid.
+ *
+ * The sampler may be at a different resolution than the grid; the mapping is the plain ratio
+ * (texel t of the result represents grid `t / scale`, see `generation/COORDINATES.md`). That
+ * convention is the reason this lives in one place: every rasterization of a filter must agree with
+ * it, and a second hand-rolled loop is a second place for it to drift.
+ *
+ * The filter must already be initialized — this function deliberately does not call
+ * `ensureInitialized`, so that callers rasterizing during their own `initialize` (where the source
+ * has already been initialized with the real seed) are not forced through a seed-0 re-initialize.
+ *
+ * The filter is evaluated at rotation 0: a raster covers the grid in grid space, there is no
+ * placement orientation to propagate.
+ *
+ * @param {Sampler2D} result
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ */
+export function write_cell_filter_to_sampler2d(result: Sampler2D, filter: CellFilter, grid: GridData): void;
+//# sourceMappingURL=write_cell_filter_to_sampler2d.d.ts.map

package/src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_cell_filter_to_sampler2d.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,4GAyBC"}

package/src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Rasterize a {@link CellFilter} into channel 0 of a {@link Sampler2D} that covers the whole grid.
+ *
+ * The sampler may be at a different resolution than the grid; the mapping is the plain ratio
+ * (texel t of the result represents grid `t / scale`, see `generation/COORDINATES.md`). That
+ * convention is the reason this lives in one place: every rasterization of a filter must agree with
+ * it, and a second hand-rolled loop is a second place for it to drift.
+ *
+ * The filter must already be initialized — this function deliberately does not call
+ * `ensureInitialized`, so that callers rasterizing during their own `initialize` (where the source
+ * has already been initialized with the real seed) are not forced through a seed-0 re-initialize.
+ *
+ * The filter is evaluated at rotation 0: a raster covers the grid in grid space, there is no
+ * placement orientation to propagate.
+ *
+ * @param {Sampler2D} result
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ */
+export function write_cell_filter_to_sampler2d(result, filter, grid) {
+    assert.defined(result, 'result');
+    assert.defined(filter, 'filter');
+    assert.defined(grid, 'grid');
+
+    const result_width = result.width;
+    const result_height = result.height;
+
+    const scale_x = result_width / grid.width;
+    const scale_y = result_height / grid.height;
+
+    for (let y = 0; y < result_height; y++) {
+
+        const grid_y = y / scale_y;
+
+        for (let x = 0; x < result_width; x++) {
+
+            const grid_x = x / scale_x;
+
+            const filterValue = filter.execute(grid, grid_x, grid_y, 0);
+
+            result.writeChannel(x, y, 0, filterValue);
+
+        }
+    }
+}

package/src/generation/filtering/util/cell_filter_weights_pick.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pick one element out of a set of {@link CellFilter}-weighted alternatives, evaluating each weight
+ * at a single grid position.
+ *
+ * This exists because the weighted-alternative combinator is written once per node hierarchy
+ * (`MarkerNodeAction`, `GridCellAction`, ...) and the *shape* of those classes is deliberately
+ * duplicated, but the selection *logic* — evaluating the weights, clamping negatives, building the
+ * CDF and the "nothing is selectable here" contract — is not, and must stay identical between them.
+ *
+ * Weight filters are always evaluated at rotation 0: a weight is a property of the position, not of
+ * the orientation the alternative will eventually be placed with.
+ *
+ * @param {function():number} random RNG returning values in [0, 1). Consumed exactly once, and only
+ * when at least one element carries positive weight.
+ * @param {{weight:CellFilter}[]} elements weighted alternatives, in a stable order
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ * @returns {number} index into `elements`, or -1 when every element has zero weight at this
+ * position — in which case the caller must select nothing rather than fall back to a uniform pick
+ */
+export function cell_filter_weights_pick(random: () => number, elements: {
+    weight: CellFilter;
+}[], grid: GridData, x: number, y: number): number;
+//# sourceMappingURL=cell_filter_weights_pick.d.ts.map

package/src/generation/filtering/util/cell_filter_weights_pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell_filter_weights_pick.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/util/cell_filter_weights_pick.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uDATsB,MAAM,YAEjB;IAAC,MAAM,aAAW;CAAC,EAAE,qBAErB,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB"}

package/src/generation/filtering/util/cell_filter_weights_pick.js

@@ -0,0 +1,54 @@
+import { random_pick_weighted_index } from "../../../core/math/random/random_pick_weighted_index.js";
+
+/**
+ * Cumulative (inclusive prefix-sum) weight scratch.
+ *
+ * Shared across all callers because the pick is a single synchronous span: the weights are produced
+ * by {@link CellFilter#execute}, which evaluates the filter graph only and cannot re-enter an
+ * action, and the selected action is invoked after the pick has returned.
+ *
+ * @type {number[]}
+ */
+const cumulative_weights = [];
+
+/**
+ * Pick one element out of a set of {@link CellFilter}-weighted alternatives, evaluating each weight
+ * at a single grid position.
+ *
+ * This exists because the weighted-alternative combinator is written once per node hierarchy
+ * (`MarkerNodeAction`, `GridCellAction`, ...) and the *shape* of those classes is deliberately
+ * duplicated, but the selection *logic* — evaluating the weights, clamping negatives, building the
+ * CDF and the "nothing is selectable here" contract — is not, and must stay identical between them.
+ *
+ * Weight filters are always evaluated at rotation 0: a weight is a property of the position, not of
+ * the orientation the alternative will eventually be placed with.
+ *
+ * @param {function():number} random RNG returning values in [0, 1). Consumed exactly once, and only
+ * when at least one element carries positive weight.
+ * @param {{weight:CellFilter}[]} elements weighted alternatives, in a stable order
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ * @returns {number} index into `elements`, or -1 when every element has zero weight at this
+ * position — in which case the caller must select nothing rather than fall back to a uniform pick
+ */
+export function cell_filter_weights_pick(random, elements, grid, x, y) {
+
+    const n = elements.length;
+
+    let totalWeight = 0;
+
+    for (let i = 0; i < n; i++) {
+
+        const weightValue = elements[i].weight.execute(grid, x, y, 0);
+
+        if (weightValue > 0) {
+            //if the weight is negative, we clamp it to 0
+            totalWeight += weightValue;
+        }
+
+        cumulative_weights[i] = totalWeight;
+    }
+
+    return random_pick_weighted_index(random, cumulative_weights, n);
+}

package/src/generation/grid/generation/discrete/GridTaskConnectRooms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridTaskConnectRooms.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/grid/generation/discrete/GridTaskConnectRooms.js"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AACH;IAqDI;;;;;;;;OAQG;IACH;;;;;;QAFa,oBAAoB,CAoBhC;IA9ED;;;OAGG;IACH,qBAAe;IAEf;;;OAGG;IACH,wBAAkB;IAElB;;;OAGG;IACH,yBAFU,MAAM,EAAE,CAShB;IAEF;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAahB;IAEF,kBAAc;IAEd;;;OAGG;IACH,uBAAa;IAgCb;;;;;OAKG;IACH,sCAHW,OAAO,GACL,IAAI,CAqChB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,KACN,MAAM,6BAEN,MAAM,QA8DhB;IAED;;;;;;;OAOG;IACH,mCANW,OAAO,aACP,WAAW,6BAEX,MAAM,GACJ,OAAO,CAwFnB;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,aACN,MAAM,6BAEN,WAAW,aACX,MAAM,QAuEhB;IAED;;;;;;;OAOG;IACH,mCALW,MAAM,EAAE,aACR,MAAM,aACN,MAAM,EAAE,GACN,SAAS,CAyBrB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,0BAEN,MAAM,EAAE,aACR,MAAM,aACN,MAAM,EAAE,QAclB;IAED,iDAuEC;CACJ;kCA/fiC,4BAA4B;oBAR1C,kCAAkC;iBAErC,uCAAuC;uBAJjC,mCAAmC;0BAQhC,0DAA0D;sBAH9D,4CAA4C"}
+{"version":3,"file":"GridTaskConnectRooms.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/grid/generation/discrete/GridTaskConnectRooms.js"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AACH;IAqDI;;;;;;;;OAQG;IACH;;;;;;QAFa,oBAAoB,CAoBhC;IA9ED;;;OAGG;IACH,qBAAe;IAEf;;;OAGG;IACH,wBAAkB;IAElB;;;OAGG;IACH,yBAFU,MAAM,EAAE,CAShB;IAEF;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAahB;IAEF,kBAAc;IAEd;;;OAGG;IACH,uBAAa;IAgCb;;;;;OAKG;IACH,sCAHW,OAAO,GACL,IAAI,CAqChB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,KACN,MAAM,6BAEN,MAAM,QA8DhB;IAED;;;;;;;OAOG;IACH,mCANW,OAAO,aACP,WAAW,6BAEX,MAAM,GACJ,OAAO,CAqGnB;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,aACN,MAAM,6BAEN,WAAW,aACX,MAAM,QAuEhB;IAED;;;;;;;OAOG;IACH,mCALW,MAAM,EAAE,aACR,MAAM,aACN,MAAM,EAAE,GACN,SAAS,CAyBrB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,0BAEN,MAAM,EAAE,aACR,MAAM,aACN,MAAM,EAAE,QAclB;IAED,iDAuEC;CACJ;kCA5gBiC,4BAA4B;oBAR1C,kCAAkC;iBAErC,uCAAuC;uBAJjC,mCAAmC;0BAQhC,0DAA0D;sBAH9D,4CAA4C"}

package/src/generation/grid/generation/discrete/GridTaskConnectRooms.js

@@ -242,6 +242,18 @@ export class GridTaskConnectRooms extends GridTaskGenerator {
 
         const closed = new BitSet();
 
+        /**
+         * membership mirror of the open heap, O(1) replacement for linear heap.contains scans.
+         *
+         * Only the seeding loop below needs it — it inserts each boundary cell exactly once, and the
+         * heap it scanned grows with the whole connected frontier. `buildDistanceMapToObjective`
+         * takes over from there and does its own bookkeeping, so the mirror is deliberately not
+         * maintained past this function's own inserts.
+         *
+         * @type {BitSet}
+         */
+        const inOpen = new BitSet();
+
 
         //first we need to build an open set, this will be all the non-matching neighbours to connected set
         for (let current = connected.nextSetBit(0); current !== -1; current = connected.nextSetBit(current + 1)) {
@@ -289,10 +301,11 @@ export class GridTaskConnectRooms extends GridTaskGenerator {
                     continue;
                 }
 
-                const isInOpen = open.contains(neighbour_index);
+                const isInOpen = inOpen.get(neighbour_index);
 
                 if (!isInOpen) {
                     open.insert(neighbour_index, 1);
+                    inOpen.set(neighbour_index, true);
 
                     distances[neighbour_index] = 1;
                 }

package/src/generation/grid/generation/road/GridTaskGenerateRoads.js

@@ -49,7 +49,7 @@ function findMarkerNodeByPosition(array, x, y) {
  * @param {number[]} neighbourhoodMask
  * @param {MarkerNode[]} group
  * @param {PathEndPoint} targetEndpoint
- * @param {function(index:number):number} heuristic
+ * @param {(index: number) => number} heuristic
  * @param {RoadConnectionNetwork} network
  */
 function createPathToTargetEndpoint(
@@ -95,7 +95,7 @@ function createPathToTargetEndpoint(
  * @param {MarkerNode[]} nodes
  * @param {number[]} distances
  * @param {number[]} neighbourhoodMask
- * @param {function(index:number):number} heuristic
+ * @param {(index: number) => number} heuristic
  * @param {GridData} grid
  * @param {CellMatcher} traversable
  * @param {RoadConnection[]} result

package/src/generation/grid/generation/util/buildPathFromDistanceMap.d.ts

@@ -6,7 +6,7 @@
  * @param {number} x
  * @param {number} y
  * @param {number[]} neighbourhoodMask
- * @param {function(index:number):number} heuristic
+ * @param {(index: number) => number} heuristic
  * @returns {number[]} Sequence of indices
  */
 export function buildPathFromDistanceMap({ distances, width, height, x, y, neighbourhoodMask, heuristic }: number[]): number[];

package/src/generation/grid/generation/util/buildPathFromDistanceMap.js

@@ -8,7 +8,7 @@ import { returnZero } from "../../../../core/function/returnZero.js";
  * @param {number} x
  * @param {number} y
  * @param {number[]} neighbourhoodMask
- * @param {function(index:number):number} heuristic
+ * @param {(index: number) => number} heuristic
  * @returns {number[]} Sequence of indices
  */
 export function buildPathFromDistanceMap(

package/src/generation/markers/GridActionRuleSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridActionRuleSet.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridActionRuleSet.js"],"names":[],"mappings":"AAoBA;IA0BI;;;;;;;OAOG;IACH,4DANW,uBAAuB,GAIrB,iBAAiB,CAkB7B;IAhDD;;;OAGG;IACH,UAFU,uBAAuB,CAEnB;IAEd;;;OAGG;IACH,QAFU,uBAAuB,GAAC,MAAM,CAEI;IAE5C;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,aAFU,OAAO,CAEE;IA4BnB;;;OAGG;IACH,uCAEC;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,eACN,MAAM,QAqIhB;CACJ;wCAlNuC,8BAA8B"}
+{"version":3,"file":"GridActionRuleSet.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridActionRuleSet.js"],"names":[],"mappings":"AA2BA;IA0BI;;;;;;;OAOG;IACH,4DANW,uBAAuB,GAIrB,iBAAiB,CAkB7B;IAhDD;;;OAGG;IACH,UAFU,uBAAuB,CAEnB;IAEd;;;OAGG;IACH,QAFU,uBAAuB,GAAC,MAAM,CAEI;IAE5C;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,aAFU,OAAO,CAEE;IA4BnB;;;OAGG;IACH,uCAEC;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,eACN,MAAM,QAiIhB;CACJ;wCApNuC,8BAA8B"}

package/src/generation/markers/GridActionRuleSet.js

@@ -1,6 +1,7 @@
 import { assert } from "../../core/assert.js";
 import { ArrayIteratorRandom } from "../../core/collection/array/iterator/ArrayIteratorRandom.js";
 import { ArrayIteratorSequential } from "../../core/collection/array/iterator/ArrayIteratorSequential.js";
+import { v2_rotate } from "../../core/geom/vec2/v2_rotate.js";
 import { PI_HALF } from "../../core/math/PI_HALF.js";
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 import TaskGroup from "../../core/process/task/TaskGroup.js";
@@ -18,6 +19,12 @@ const POLICY_ITERATORS = {
     [RuleSelectionPolicyType.Random]: ArrayIteratorRandom
 };
 
+/**
+ * Scratch for the rotated pattern offset. Read out before any matcher/action call, so it cannot alias.
+ * @type {Float64Array}
+ */
+const scratch_offset = new Float64Array(2);
+
 export class GridActionRuleSet {
 
     /**
@@ -173,14 +180,10 @@ export class GridActionRuleSet {
 
                         const rotation = j * PI_HALF;
 
-                        const sin = Math.sin(rotation);
-                        const cos = Math.cos(rotation);
-
-                        const final_sample_offset_x = sampleOffsetX * cos - sampleOffsetY * sin;
-                        const final_sample_offset_y = sampleOffsetX * sin + sampleOffsetY * cos;
+                        v2_rotate(scratch_offset, 0, sampleOffsetX, sampleOffsetY, rotation);
 
-                        const p_x = final_sample_offset_x + x;
-                        const p_y = final_sample_offset_y + y;
+                        const p_x = scratch_offset[0] + x;
+                        const p_y = scratch_offset[1] + y;
 
 
                         let match;

package/src/generation/markers/GridCellActionPlaceMarker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridCellActionPlaceMarker.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridCellActionPlaceMarker.js"],"names":[],"mappings":"AAOA;IAkFI;;;;;;;;;;OAUG;IACH,0FAFY,yBAAyB,CAwCpC;IAjID;;;OAGG;IACH,aAAY;IAEZ;;;OAGG;IACH,WAFU,SAAS,CAES;IAE5B;;;OAGG;IACH,MAFU,QAAQ,CAER;IAEV,eAAgB;IAEhB,aAAS;IAET;;;OAGG;IACH,cAFU,uBAAuB,CAEf;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,OAAO,CAEM;IAEvB,uCAWC;IAED;;;;OAIG;IACH,qBAFa,OAAO,CAYnB;IAED;;;OAGG;IACH,yDAIC;IAqDD;;;;;;;;;OASG;IACH,iCALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,UAAU,CAuDtB;IAED;;;;;;;OAOG;IACH,6BALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,UAAU,CAgBtB;IAED,wDAIC;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;CAN9D;+BAtO8B,uCAAuC;0BAD5C,yCAAyC;oBAF/C,4BAA4B;2BAIrB,iBAAiB"}
+{"version":3,"file":"GridCellActionPlaceMarker.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridCellActionPlaceMarker.js"],"names":[],"mappings":"AAcA;IAkFI;;;;;;;;;;OAUG;IACH,0FAFY,yBAAyB,CAwCpC;IAjID;;;OAGG;IACH,aAAY;IAEZ;;;OAGG;IACH,WAFU,SAAS,CAES;IAE5B;;;OAGG;IACH,MAFU,QAAQ,CAER;IAEV,eAAgB;IAEhB,aAAS;IAET;;;OAGG;IACH,cAFU,uBAAuB,CAEf;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,OAAO,CAEM;IAEvB,uCAWC;IAED;;;;OAIG;IACH,qBAFa,OAAO,CAYnB;IAED;;;OAGG;IACH,yDAIC;IAqDD;;;;;;;;;OASG;IACH,iCALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,UAAU,CA8CtB;IAED;;;;;;;OAOG;IACH,6BALW,MAAM,KACN,MAAM,YACN,MAAM,GACJ,UAAU,CAgBtB;IAED,wDAIC;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;CAN9D;+BAnO8B,uCAAuC;0BAD5C,yCAAyC;oBAH/C,4BAA4B;2BAKrB,iBAAiB"}

package/src/generation/markers/GridCellActionPlaceMarker.js

@@ -1,10 +1,17 @@
 import { assert } from "../../core/assert.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import Vector3 from "../../core/geom/Vector3.js";
+import { v2_rotate } from "../../core/geom/vec2/v2_rotate.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
 import { GridCellAction } from "../placement/action/GridCellAction.js";
 import { MarkerNode } from "./MarkerNode.js";
 
+/**
+ * Scratch for the rotated placement offset. Read out immediately, so it cannot alias.
+ * @type {Float64Array}
+ */
+const scratch_offset = new Float64Array(2);
+
 export class GridCellActionPlaceMarker extends GridCellAction {
 
     /**
@@ -152,22 +159,13 @@ export class GridCellActionPlaceMarker extends GridCellAction {
 
         const node = new MarkerNode();
 
-
-        const sin = Math.sin(rotation);
-        const cos = Math.cos(rotation);
-
-
         //rotate offset position
         const offset = this.offset;
 
-        const offsetY = offset.y;
-        const offsetX = offset.x;
-
-        const rotated_local_offset_x = offsetX * cos - offsetY * sin
-        const rotated_local_offset_y = offsetX * sin + offsetY * cos;
+        v2_rotate(scratch_offset, 0, offset.x, offset.y, rotation);
 
-        const target_x = rotated_local_offset_x + x;
-        const target_y = rotated_local_offset_y + y;
+        const target_x = scratch_offset[0] + x;
+        const target_y = scratch_offset[1] + y;
 
         node.position.set(target_x, target_y);
         node.type = this.type;

package/src/generation/markers/actions/placement/MarkerNodeEntityProcessorRandomRotation.d.ts

@@ -2,7 +2,8 @@ export class MarkerNodeEntityProcessorRandomRotation extends MarkerNodeEntityPro
     static from(): MarkerNodeEntityProcessorRandomRotation;
     __seed: number;
     __random: (() => number) | {
-        setCurrentSeed: (arg0: v) => number;
+        setCurrentSeed: (v: number) => void;
+        getCurrentSeed: () => number;
     };
     initialize(data: any, ecd: any, seed: any): void;
     execute(entity: any, node: any, data: any, ecd: any): void;

package/src/generation/markers/actions/placement/MarkerNodeEntityProcessorRandomRotation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkerNodeEntityProcessorRandomRotation.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/markers/actions/placement/MarkerNodeEntityProcessorRandomRotation.js"],"names":[],"mappings":"AAIA;IAKI,uDAEC;IALD,eAAW;IACX;;MAA2B;IAM3B,iDAEC;IAED,2DAQC;CACJ;0CA1ByC,gCAAgC"}
+{"version":3,"file":"MarkerNodeEntityProcessorRandomRotation.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/markers/actions/placement/MarkerNodeEntityProcessorRandomRotation.js"],"names":[],"mappings":"AAIA;IAKI,uDAEC;IALD,eAAW;IACX;;;MAA2B;IAM3B,iDAEC;IAED,2DAQC;CACJ;0CA1ByC,gCAAgC"}

package/src/generation/markers/actions/probability/MarkerNodeActionSelectWeighted.d.ts

@@ -11,7 +11,8 @@ export class MarkerNodeActionSelectWeighted extends MarkerNodeAction {
      */
     elements: MarkerNodeActionWeightedElement[];
     __random: (() => number) | {
-        setCurrentSeed: (arg0: v) => number;
+        setCurrentSeed: (v: number) => void;
+        getCurrentSeed: () => number;
     };
     initialize(grid: any, ecd: any, seed: any): void;
     execute(grid: any, ecd: any, node: any): void;

package/src/generation/markers/actions/probability/MarkerNodeActionSelectWeighted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkerNodeActionSelectWeighted.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/markers/actions/probability/MarkerNodeActionSelectWeighted.js"],"names":[],"mappings":"AAWA;IAUI;;;;OAIG;IACH,sBAFW,iCAAiC,GAD/B,8BAA8B,CAW1C;IArBD;;;OAGG;IACH,UAFU,iCAAiC,CAE7B;IAEd;;MAA2B;IAiB3B,iDAiBC;IAED,8CAgDC;CACJ;iCAtGgC,wBAAwB"}
+{"version":3,"file":"MarkerNodeActionSelectWeighted.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/markers/actions/probability/MarkerNodeActionSelectWeighted.js"],"names":[],"mappings":"AAKA;IAUI;;;;OAIG;IACH,sBAFW,iCAAiC,GAD/B,8BAA8B,CAW1C;IArBD;;;OAGG;IACH,UAFU,iCAAiC,CAE7B;IAEd;;;MAA2B;IAiB3B,iDAiBC;IAED,8CAmBC;CACJ;iCAnEgC,wBAAwB"}