@woosh/meep-engine 2.31.1 → 2.31.5

package/generation/grid/generation/grid/select/CellSupplierPathUpHill.js

@@ -0,0 +1,187 @@
+import { CellSupplier } from "./CellSupplier.js";
+import { BitSet } from "../../../../../core/binary/BitSet.js";
+import { assert } from "../../../../../core/assert.js";
+
+/**
+ *
+ * @type {Uint32Array}
+ */
+const scratch_neighbours = new Uint32Array(4);
+
+/**
+ * Supply cells that trace from source cells up to maximum value cells via hill climbing.
+ * Useful for tracing paths between features, such as path between a shipyard and the nearest water source
+ */
+export class CellSupplierPathUpHill extends CellSupplier {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {CellMatcher|null}
+         */
+        this.source = null;
+
+        /**
+         *
+         * @type {CellFilter|null}
+         */
+        this.value = null;
+
+        /**
+         *
+         * @type {BitSet}
+         * @private
+         */
+        this.__open_set = new BitSet();
+        /**
+         *
+         * @type {BitSet}
+         * @private
+         */
+        this.__visited_set = new BitSet();
+
+        /**
+         *
+         * @type { Float32Array|null}
+         * @private
+         */
+        this.__cached_values = null;
+
+        /**
+         *
+         * @type {GridData|null}
+         * @private
+         */
+        this.__grid = null;
+    }
+
+    /**
+     *
+     * @param {CellFilter} value
+     * @param {CellMatcher} source
+     */
+    static from(value, source) {
+        assert.equal(value.isCellFilter, true, 'value.isCellFilter !== true');
+        assert.equal(source.isCellMatcher, true, 'source.isCellMatcher !== true');
+
+        const r = new CellSupplierPathUpHill();
+
+        r.value = value;
+        r.source = source;
+
+        return r;
+    }
+
+    initialize(grid, seed) {
+        this.__grid = grid;
+
+        this.source.initialize(grid, seed);
+        this.value.ensureInitialized(grid, seed);
+
+        const grid_size = grid.width * grid.height;
+
+        this.__open_set.preventShrink();
+        this.__open_set.reset();
+        this.__open_set.setCapacity(grid_size);
+
+        this.__visited_set.preventShrink();
+        this.__visited_set.reset();
+        this.__visited_set.setCapacity(grid_size);
+
+        this.__cached_values = new Float32Array(grid_size);
+
+        // identify source cells
+        for (let y = 0; y < grid.height; y++) {
+            for (let x = 0; x < grid.width; x++) {
+
+                if (this.source.match(grid, x, y, 0)) {
+
+                    const index = y * grid.width + x;
+                    this.__open_set.set(index, true);
+                    this.__visited_set.set(index, true);
+
+                    this.__cached_values[index] = this.value.execute(grid, x, y, 0);
+                }
+
+            }
+        }
+    }
+
+    next() {
+        const grid_width = this.__grid.width;
+        const current_index = this.__open_set.nextSetBit(0);
+
+        if (current_index === -1) {
+            // no more
+            return undefined;
+        }
+
+        this.__open_set.clear(current_index);
+
+        const current_value = this.__cached_values[current_index];
+
+        const current_x = current_index % grid_width;
+        const current_y = (current_index / grid_width) | 0;
+
+
+        // update neighbours of the cell
+        let neighbour_count = 0;
+
+        if (current_y > 0) {
+            // up
+            scratch_neighbours[neighbour_count] = current_index - grid_width;
+            neighbour_count++;
+        }
+
+        if (current_x > 0) {
+            // left
+            scratch_neighbours[neighbour_count] = current_index - 1;
+            neighbour_count++;
+        }
+
+        if (current_x < grid_width - 1) {
+            // right
+            scratch_neighbours[neighbour_count] = current_index + 1;
+            neighbour_count++;
+        }
+
+        if (current_y < this.__grid.height - 1) {
+            // up
+            scratch_neighbours[neighbour_count] = current_index + grid_width;
+            neighbour_count++;
+        }
+
+        for (let i = 0; i < neighbour_count; i++) {
+            const neighbour = scratch_neighbours[i];
+
+            if (this.__visited_set.get(neighbour) || this.__open_set.get(neighbour)) {
+                //already visited
+                continue;
+            }
+            const n_x = neighbour % grid_width;
+            const n_y = (neighbour - n_x) / grid_width;
+
+            // pick smallest
+            const n_v = this.value.execute(this.__grid, n_x, n_y, 0);
+
+            if (n_v < current_value) {
+                // invalid
+                continue;
+            }
+
+            this.__open_set.set(neighbour, true);
+            this.__visited_set.set(neighbour, true);
+
+            this.__cached_values[neighbour] = n_v;
+        }
+
+
+        return {
+            x: current_x,
+            y: current_y,
+            rotation: 0
+        };
+    }
+
+}

package/generation/markers/GridActionRuleSet.js

@@ -205,7 +205,7 @@ export class GridActionRuleSet {
 
                         const probabilityValue = element.probability.execute(grid, p_x, p_y, rotation);
 
-                        if (roll < probabilityValue) {
+                        if (probabilityValue > roll) {
 
                             element.execute(grid, p_x, p_y, rotation);
 

package/generation/markers/MarkerNode.js

@@ -52,6 +52,24 @@ export class MarkerNode {
         return this.tags.includes(tag);
     }
 
+    /**
+     *
+     * @param {string[]} tags
+     * @returns {boolean}
+     */
+    hasAllTags(tags) {
+        const n = tags.length;
+        const this_tags = this.tags;
+
+        for (let i = 0; i < n; i++) {
+            if (!this_tags.includes(tags[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      *
      * @returns {MarkerNode}

package/generation/markers/debug/visualizeMarkers.js

@@ -17,6 +17,7 @@ import GUIElement from "../../../engine/ecs/gui/GUIElement.js";
 import ViewportPosition from "../../../engine/ecs/gui/position/ViewportPosition.js";
 import HeadsUpDisplay from "../../../engine/ecs/gui/hud/HeadsUpDisplay.js";
 import Vector3 from "../../../core/geom/Vector3.js";
+import { MarkerNodeMatcherAny } from "../matcher/MarkerNodeMatcherAny.js";
 
 function formatValue(v) {
 
@@ -49,8 +50,9 @@ function CircleGeometry(radius, arc) {
  *
  * @param {GridData} grid
  * @param {EntityComponentDataset} ecd
+ * @param {MarkerNodeMatcher} marker_filter
  */
-export function visualizeMarkers(grid, ecd) {
+export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherAny.INSTANCE }) {
 
     /**
      *
@@ -92,6 +94,11 @@ export function visualizeMarkers(grid, ecd) {
     for (let i = 0; i < n; i++) {
         const markerNode = markers[i];
 
+        if (!marker_filter.match(markerNode)) {
+            // reject marker
+            continue;
+        }
+
         const g = new Group();
 
         const mark_0 = new ThreeMesh(geometry_0, m0);

package/generation/markers/transform/MarkerNodeTransformerSequence.js

@@ -0,0 +1,47 @@
+import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
+
+export class MarkerNodeTransformerSequence extends MarkerNodeTransformer {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {MarkerNodeTransformer[]}
+         */
+        this.elements = [];
+    }
+
+    static from(elements) {
+        const r = new MarkerNodeTransformerSequence();
+
+        r.elements = elements;
+
+        return r;
+    }
+
+    initialize(grid, seed) {
+        const elements = this.elements;
+        const n = elements.length;
+
+        for (let i = 0; i < n; i++) {
+            const e = elements[i];
+            e.initialize(grid, seed);
+        }
+    }
+
+    transform(node, grid) {
+        const elements = this.elements;
+        const element_count = elements.length;
+
+        let n = node;
+
+        // transform
+        for (let j = 0; j < element_count; j++) {
+            const transformer = elements[j];
+
+            n = transformer.transform(n, grid);
+        }
+
+        return n;
+    }
+}

package/generation/placement/GridCellActionTransformNearbyMarkers.js

@@ -19,9 +19,9 @@ export class GridCellActionTransformNearbyMarkers extends GridCellAction {
 
         /**
          *
-         * @type {MarkerNodeTransformer[]}
+         * @type {MarkerNodeTransformer}
          */
-        this.transformers = [];
+        this.transformer = null;
 
         /**
          * @private
@@ -41,19 +41,19 @@ export class GridCellActionTransformNearbyMarkers extends GridCellAction {
      *
      * @param {number} radius
      * @param {MarkerNodeMatcher} matcher
-     * @param {MarkerNodeTransformer[]} transformers
+     * @param {MarkerNodeTransformer} transformer
      * @returns {GridCellActionTransformNearbyMarkers}
      */
-    static from(radius, matcher, transformers) {
+    static from(radius, matcher, transformer) {
         assert.greaterThanOrEqual(radius, 0, 'radius');
         assert.equal(matcher.isMarkerNodeMatcher, true, 'matcher.isMarkerNodeMatcher');
-        assert.isArray(transformers, 'transformers');
+        assert.equal(transformer.isMarkerNodeTransformer, true, 'matcher.isMarkerNodeTransformer');
 
         const r = new GridCellActionTransformNearbyMarkers();
 
         r.radius = radius;
         r.matcher = matcher;
-        r.transformers = transformers;
+        r.transformer = transformer;
 
         return r;
     }
@@ -61,7 +61,7 @@ export class GridCellActionTransformNearbyMarkers extends GridCellAction {
     initialize(data, seed) {
         super.initialize(data, seed);
 
-        this.transformers.forEach(t => t.initialize(data, seed));
+        this.transformer.initialize(data, seed);
     }
 
     /**
@@ -89,9 +89,7 @@ export class GridCellActionTransformNearbyMarkers extends GridCellAction {
 
     execute(data, x, y, rotation) {
 
-        const transformers = this.transformers;
-
-        const transformerCount = transformers.length;
+        const transformer = this.transformer;
 
         // reset cursor
         this.__leaf_cursor = 0;
@@ -112,14 +110,8 @@ export class GridCellActionTransformNearbyMarkers extends GridCellAction {
         for (let i = 0; i < match_count; i++) {
             const leaf = leaves[i];
 
-            let node = leaf.data;
-
             // transform
-            for (let j = 0; j < transformerCount; j++) {
-                const transformer = transformers[j];
-
-                node = transformer.transform(node, data);
-            }
+            const node = transformer.transform(leaf.data, data);
 
             // insert the node
             data.addMarker(node);

package/generation/rules/CellMatcherFromFilter.js

@@ -0,0 +1,38 @@
+import { CellMatcher } from "./CellMatcher.js";
+
+export class CellMatcherFromFilter extends CellMatcher {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {CellFilter|null}
+         */
+        this.filter = null;
+    }
+
+    /**
+     *
+     * @param {CellFilter} f
+     * @returns {CellMatcherFromFilter}
+     */
+    static from(f) {
+        const r = new CellMatcherFromFilter();
+
+        r.filter = f;
+
+        return r;
+    }
+
+    initialize(grid, seed) {
+        if (!this.filter.initialized) {
+            this.filter.initialize(grid, seed);
+        }
+    }
+
+    match(grid, x, y, rotation) {
+        const v = this.filter.execute(grid, x, y, rotation);
+
+        return v > 0;
+    }
+}

package/generation/rules/cell/CellMatcherContainsMarkerWithinRadius.js

@@ -35,7 +35,7 @@ export class CellMatcherContainsMarkerWithinRadius extends CellMatcher {
         return r;
     }
 
-    match(grid, x, y) {
+    match(grid, x, y, rotation) {
         return grid.containsMarkerInCircle(x, y, this.radius, this.matcher);
     }
 }

package/package.json

@@ -4,15 +4,15 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.31.1",
+  "version": "2.31.5",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",
-    "three": "^0.132.2"
+    "three": "0.132.2 - 0.133.1"
   },
   "devDependencies": {
     "babel-jest": "^26.6.3",
-    "@types/three": "^0.131.1"
+    "@types/three": "0.133.0"
   }
 }