@woosh/meep-engine 2.37.18 → 2.38.0

package/generation/grid/GridData.js

@@ -1,10 +1,15 @@
 import { assert } from "../../core/assert.js";
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { OffsetScaleTransform2D } from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D.js";
-import { MarkerMatchCounter } from "./MarkerMatchCounter.js";
 import { max2 } from "../../core/math/max2.js";
+import { qt_collect_by_circle } from "../../core/geom/2d/quad-tree/qt_collect_by_circle.js";
+import { v2_length_sqr } from "../../core/geom/Vector2.js";
 
-const scratch_match_counter = new MarkerMatchCounter();
+/**
+ *
+ * @type {QuadTreeDatum<MarkerNode>[]}
+ */
+const marker_collection = [];
 
 export class GridData {
     constructor() {
@@ -78,34 +83,6 @@ export class GridData {
         return undefined;
     }
 
-    /**
-     *
-     * @param {MarkerNode[]} result
-     * @param {number} x
-     * @param {number} y
-     * @param {number} radius
-     * @param {MarkerNodeMatcher} matcher
-     * @returns {number} match count
-     */
-    queryMarkersInCircle(result, x, y, radius, matcher) {
-        let count = 0;
-        this.markers.traverseCircleIntersections(x, y, this.radius, leaf => {
-            /**
-             *
-             * @type {MarkerNode}
-             */
-            const marker = leaf.data;
-
-            if (matcher.match(marker)) {
-                result.push(marker);
-
-                count++;
-            }
-        });
-
-        return count;
-    }
-
     /**
      *
      * @param {number} x
@@ -127,12 +104,34 @@ export class GridData {
      * @returns {number}
      */
     countMarkerInCircle(x, y, radius, matcher) {
-        scratch_match_counter.matcher = matcher;
-        scratch_match_counter.count = 0;
+        const match_count = qt_collect_by_circle(marker_collection, 0, this.markers, x, y, radius);
+
+        let result = 0;
+
+        for (let i = 0; i < match_count; i++) {
+            const marker_datum = marker_collection[i];
+
+            /**
+             *
+             * @type {MarkerNode|null}
+             */
+            const marker = marker_datum.data;
+
+            const distance_limit = radius + marker.size;
+
+            const distance_limit_sqr = distance_limit * distance_limit;
+
+            // check refined containment
+            if (v2_length_sqr(x - marker.position.x, y - marker.position.y) > distance_limit_sqr) {
+                continue;
+            }
 
-        this.markers.traverseCircleIntersections(x, y, radius, scratch_match_counter.exec, scratch_match_counter);
+            if (matcher.match(marker)) {
+                result++;
+            }
+        }
 
-        return scratch_match_counter.count;
+        return result;
     }
 
     /**
@@ -171,8 +170,8 @@ export class GridData {
         assert.isNumber(width, 'width');
         assert.isNumber(height, 'height');
 
-        assert.isNonNegativeInteger(width,'width');
-        assert.isNonNegativeInteger(height,'height');
+        assert.isNonNegativeInteger(width, 'width');
+        assert.isNonNegativeInteger(height, 'height');
 
         assert.isFiniteNumber(width, 'width');
         assert.isFiniteNumber(height, 'width');

package/generation/grid/MarkerMatchCounter.js

@@ -5,7 +5,7 @@ export class MarkerMatchCounter {
     constructor() {
         /**
          * Predicate
-         * @type {{match:function(T):boolean}|null}
+         * @type {MarkerNodeMatcher|null}
          */
         this.matcher = null;
         this.count = 0;
@@ -13,10 +13,12 @@ export class MarkerMatchCounter {
 
     /**
      *
-     * @param {QuadTreeDatum<T>} node
+     * @param {QuadTreeDatum<MarkerNode>} node
      */
     exec(node) {
-        if (this.matcher.match(node.data)) {
+        const marker = node.data;
+
+        if (this.matcher.match(marker)) {
             this.count++;
         }
     }

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

@@ -4,7 +4,7 @@ import { BitSet } from "../../../../core/binary/BitSet.js";
 import Task from "../../../../core/process/task/Task.js";
 import TaskSignal from "../../../../core/process/task/TaskSignal.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
-import BinaryHeap from "../../../../engine/navigation/grid/FastBinaryHeap.js";
+import BinaryHeap from "../../../../core/collection/heap/FastBinaryHeap.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";
 import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";

package/generation/grid/generation/discrete/layer/GridTaskBuildSourceDistanceMap.js

@@ -3,7 +3,7 @@ import Task from "../../../../../core/process/task/Task.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
 import TaskGroup from "../../../../../core/process/task/TaskGroup.js";
 import TaskSignal from "../../../../../core/process/task/TaskSignal.js";
-import BinaryHeap from "../../../../../engine/navigation/grid/FastBinaryHeap.js";
+import BinaryHeap from "../../../../../core/collection/heap/FastBinaryHeap.js";
 import { GridTaskGenerator } from "../../../GridTaskGenerator.js";
 import { assert } from "../../../../../core/assert.js";
 

package/generation/grid/generation/discrete/layer/GridTaskDistanceToMarkers.js

@@ -1,6 +1,6 @@
 import { GridTaskGenerator } from "../../../GridTaskGenerator.js";
 import { actionTask } from "../../../../../core/process/task/TaskUtils.js";
-import BinaryHeap from "../../../../../engine/navigation/grid/FastBinaryHeap.js";
+import BinaryHeap from "../../../../../core/collection/heap/FastBinaryHeap.js";
 
 export class GridTaskDistanceToMarkers extends GridTaskGenerator {
     constructor() {

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

@@ -5,7 +5,7 @@ import { GridTaskGenerator } from "../../GridTaskGenerator.js";
 import { actionTask, countTask } from "../../../../core/process/task/TaskUtils.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";
 import Graph from "../../../../core/graph/Graph.js";
-import BinaryHeap from "../../../../engine/navigation/grid/FastBinaryHeap.js";
+import BinaryHeap from "../../../../core/collection/heap/FastBinaryHeap.js";
 import { BitSet } from "../../../../core/binary/BitSet.js";
 import { matcher_tag_traversable } from "../../../example/rules/matcher_tag_traversable.js";
 import { buildPathFromDistanceMap } from "../util/buildPathFromDistanceMap.js";

package/generation/markers/GridActionRuleSet.js

@@ -43,11 +43,6 @@ export class GridActionRuleSet {
          */
         this.matchOrigin = true;
 
-        /**
-         *
-         * @type {boolean}
-         */
-        this.allowEveryRotation = false;
     }
 
     /**
@@ -58,16 +53,20 @@ export class GridActionRuleSet {
      * @param {boolean} [allowEveryRotation]
      * @returns {GridActionRuleSet}
      */
-    static from({ rules, policy = RuleSelectionPolicyType.Sequential, pattern = [0, 0], allowEveryRotation = false }) {
+    static from({ rules, policy = RuleSelectionPolicyType.Sequential, pattern = [0, 0], allowEveryRotation }) {
         assert.enum(policy, RuleSelectionPolicyType, 'policy');
-        assert.typeOf(allowEveryRotation, 'boolean', 'allowEveryRotation');
+        assert.isArray(rules, 'rules');
+        assert.isArray(pattern, 'pattern');
 
         const r = new GridActionRuleSet();
 
         rules.forEach(r.add, r);
         r.policy = policy;
         r.pattern = pattern;
-        r.allowEveryRotation = allowEveryRotation;
+
+        if (allowEveryRotation !== undefined) {
+            console.warn('.allowEveryRotation is deprecated');
+        }
 
         return r;
     }
@@ -122,7 +121,6 @@ export class GridActionRuleSet {
         const patternSize = pattern.length;
 
         const matchOrigin = this.matchOrigin;
-        const allowEveryRotation = this.allowEveryRotation;
 
         const sampleCountX = width * resolution;
         const sampleCountY = height * resolution;
@@ -160,30 +158,17 @@ export class GridActionRuleSet {
                     const sampleOffsetX = pattern[sampleIndex++];
                     const sampleOffsetY = pattern[sampleIndex++];
 
+                    const ROTATION_COUNT = element.allowRotation ? 4 : 1;
 
-                    let final_sample_offset_x = sampleOffsetX;
-                    let final_sample_offset_y = sampleOffsetY;
-
-                    rotation_loop: for (let j = 0; j < 4; j++) {
-
+                    for (let j = 0; j < ROTATION_COUNT; j++) {
 
                         const rotation = j * PI_HALF;
 
-                        if (j > 0) {
-                            if (!element.allowRotation) {
-                                break rotation_loop;
-                            } else {
-
-
-                                const sin = Math.sin(rotation);
-                                const cos = Math.cos(rotation);
+                        const sin = Math.sin(rotation);
+                        const cos = Math.cos(rotation);
 
-                                final_sample_offset_x = sampleOffsetX * cos - sampleOffsetY * sin;
-                                final_sample_offset_y = sampleOffsetX * sin + sampleOffsetY * cos;
-
-                            }
-
-                        }
+                        const final_sample_offset_x = sampleOffsetX * cos - sampleOffsetY * sin;
+                        const final_sample_offset_y = sampleOffsetX * sin + sampleOffsetY * cos;
 
                         const p_x = final_sample_offset_x + x;
                         const p_y = final_sample_offset_y + y;
@@ -198,7 +183,7 @@ export class GridActionRuleSet {
                         }
 
                         if (!match) {
-                            continue rotation_loop;
+                            continue;
                         }
 
                         const roll = random();
@@ -209,9 +194,7 @@ export class GridActionRuleSet {
 
                             element.execute(grid, p_x, p_y, rotation);
 
-                            if (!allowEveryRotation) {
-                                break sampling_loop;
-                            }
+                            break sampling_loop;
                         }
 
                     }

package/generation/markers/GridCellActionPlaceMarker.js

@@ -3,6 +3,7 @@ import { MarkerNode } from "./MarkerNode.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import { assert } from "../../core/assert.js";
+import Vector3 from "../../core/geom/Vector3.js";
 
 export class GridCellActionPlaceMarker extends GridCellAction {
     constructor() {
@@ -172,22 +173,25 @@ export class GridCellActionPlaceMarker extends GridCellAction {
 
         node.size = this.size;
 
+        const transform = data.transform;
+
         node.transform.position.set(
-            target_x * data.transform.scale_x + data.transform.offset_x,
+            target_x * transform.scale_x + transform.offset_x,
             0,
-            target_y * data.transform.scale_y + data.transform.offset_y
+            target_y * transform.scale_y + transform.offset_y
         );
 
-        node.transform.rotation.__setFromEuler(0, -rotation, 0);
+        node.transform.rotation.fromAxisAngle(Vector3.down, rotation);
 
         node.transform.multiplyTransforms(node.transform, this.transform);
 
         //add tags
         const tags = this.tags;
-        const tagCount = tags.length;
-        for (let i = 0; i < tagCount; i++) {
+        const tag_count = tags.length;
+        const node_tags = node.tags;
+        for (let i = 0; i < tag_count; i++) {
             const tag = tags[i];
-            node.tags.push(tag);
+            node_tags.push(tag);
         }
 
         //write properties
@@ -197,9 +201,9 @@ export class GridCellActionPlaceMarker extends GridCellAction {
 
         //apply transformations
         const transformers = this.transformers;
-        const transformerCount = transformers.length;
+        const transformer_count = transformers.length;
 
-        for (let i = 0; i < transformerCount; i++) {
+        for (let i = 0; i < transformer_count; i++) {
             const transformer = transformers[i];
             node = transformer.transform(node, data);
         }

package/generation/markers/debug/visualizeMarkers.js

@@ -51,8 +51,14 @@ function CircleGeometry(radius, arc) {
  * @param {GridData} grid
  * @param {EntityComponentDataset} ecd
  * @param {MarkerNodeMatcher} marker_filter
+ * @param {boolean} [display_data]
  */
-export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherAny.INSTANCE }) {
+export function visualizeMarkers({
+                                     grid,
+                                     ecd,
+                                     marker_filter = MarkerNodeMatcherAny.INSTANCE,
+                                     display_data = true
+                                 }) {
 
     /**
      *
@@ -85,7 +91,8 @@ export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherA
      */
     const terrain = obtainTerrain(ecd);
 
-    const geometry_0 = new TetrahedronBufferGeometry(0.05, 2);
+    const marker_radius = 0.05;
+    const geometry_0 = new TetrahedronBufferGeometry(marker_radius, 2);
 
     const geometry_cylinder = CircleGeometry(1, 1);
 
@@ -110,63 +117,76 @@ export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherA
         mark_1.position.copy(markerNode.transform.position);
         mark_1.position.sub(v3);
 
-        const line_geometry = new BufferGeometry();
-        line_geometry.setFromPoints([
-            mark_0.position,
-            mark_1.position
-        ]);
-
-        const mark_line = new Line(line_geometry, m_line);
-
-
         const mark_size = new Line(geometry_cylinder, m3);
         mark_size.scale.set(markerNode.size, markerNode.size, markerNode.size);
 
 
         g.add(mark_0);
-        g.add(mark_1);
+
+        if (mark_1.position.distanceToSquared(mark_0.position) > marker_radius * marker_radius * 0.2) {
+            // only draw second marker if they are sufficiently far apart
+
+            const line_geometry = new BufferGeometry();
+            line_geometry.setFromPoints([
+                mark_0.position,
+                mark_1.position
+            ]);
+
+            const mark_line = new Line(line_geometry, m_line);
+
+            g.add(mark_1);
+            g.add(mark_line);
+        }
+
         g.add(mark_size);
-        g.add(mark_line);
+
+        const entityBuilder = new EntityBuilder();
 
         const renderable = new Renderable(g);
         renderable.computeBoundsFromObject();
 
-        const props = [];
+        if (display_data) {
+            const props = [];
 
-        props.push(`TYPE: ${markerNode.type}`);
+            props.push(`TYPE: ${markerNode.type}`);
 
-        for (const propertyKey in markerNode.properties) {
-            let propValue = formatValue(markerNode.properties[propertyKey]);
+            for (const propertyKey in markerNode.properties) {
+                let propValue = formatValue(markerNode.properties[propertyKey]);
 
-            props.push(`${propertyKey}:${propValue}`);
-        }
+                props.push(`${propertyKey}:${propValue}`);
+            }
 
-        props.push(`# [x: ${formatValue(markerNode.position.x)}, y: ${formatValue(markerNode.position.y)}]`);
-        props.push(`# [size: ${formatValue(markerNode.size)}]`);
+            props.push(`# [x: ${formatValue(markerNode.position.x)}, y: ${formatValue(markerNode.position.y)}]`);
+            props.push(`# [size: ${formatValue(markerNode.size)}]`);
 
-        for (let j = 0; j < markerNode.tags.length; j++) {
-            const tag = markerNode.tags[j];
+            for (let j = 0; j < markerNode.tags.length; j++) {
+                const tag = markerNode.tags[j];
 
-            props.push(`# T: ${tag}`);
-        }
+                props.push(`# T: ${tag}`);
+            }
 
 
-        const v = new LabelView(props.join('\n'), { classList: ['__debug-plaque'] });
-        v.css({
-            position: 'absolute',
-            whiteSpace: 'pre',
-            left: 0,
-            top: 0
-        })
+            const v = new LabelView(props.join('\n'), { classList: ['__debug-plaque'] });
+            v.css({
+                position: 'absolute',
+                whiteSpace: 'pre',
+                left: 0,
+                top: 0
+            })
+
+            entityBuilder
+                .add(new HeadsUpDisplay())
+                .add(new ViewportPosition())
+                .add(GUIElement.fromView(v))
+            ;
+        }
 
         const t = new Transform();
 
         t.position.copy(v3);
 
-        new EntityBuilder()
-            .add(new HeadsUpDisplay())
-            .add(new ViewportPosition())
-            .add(GUIElement.fromView(v))
+
+        entityBuilder
             .add(renderable)
             .add(t)
             .build(ecd);

package/generation/markers/emitter/MarkerNodeEmitterFromAction.js

@@ -1,7 +1,7 @@
 import { MarkerNodeEmitter } from "./MarkerNodeEmitter.js";
 import { assert } from "../../../core/assert.js";
 
-export class MarkerNodeEmitterFromAction extends MarkerNodeEmitter{
+export class MarkerNodeEmitterFromAction extends MarkerNodeEmitter {
     constructor() {
         super();
 
@@ -18,8 +18,8 @@ export class MarkerNodeEmitterFromAction extends MarkerNodeEmitter{
      * @param {GridCellActionPlaceMarker[]} actions
      * @return {MarkerNodeEmitterFromAction}
      */
-    static from(actions){
-assert.isArray(actions,'actions');
+    static from(actions) {
+        assert.isArray(actions, 'actions');
 
         for (let i = 0; i < actions.length; i++) {
 
@@ -27,11 +27,11 @@ assert.isArray(actions,'actions');
             assert.equal(action.isGridCellActionPlaceMarker, true, 'action.isGridCellActionPlaceMarker !== true');
         }
 
-         const r = new MarkerNodeEmitterFromAction();
+        const r = new MarkerNodeEmitterFromAction();
 
-         r.actions = actions;
+        r.actions = actions;
 
-         return r;
+        return r;
     }
 
     initialize(data, seed) {
@@ -41,7 +41,7 @@ assert.isArray(actions,'actions');
         for (let i = 0; i < n; i++) {
             const action = actions[i];
 
-            action.initialize(data,seed);
+            action.initialize(data, seed);
         }
     }
 
@@ -54,7 +54,7 @@ assert.isArray(actions,'actions');
 
             const action = actions[i];
 
-            const node = action.buildNode(data,x,y,rotation);
+            const node = action.buildNode(data, x, y, rotation);
 
             consumer.consume(node);