@woosh/meep-engine 2.76.4 → 2.78.0

package/src/core/graph/v2/NodeContainer.js

@@ -1,29 +1,37 @@
 import { EdgeDirectionType } from "../Edge.js";
 
+/**
+ * Supplementary structure to `Graph`, holds edges and neighbour nodes for fast access
+ * Used internally by `Graph`
+ * @template N
+ */
 export class NodeContainer {
     /**
-     * @template N
+     * Node being described
+     * @type {N}
      */
-    constructor() {
-        /**
-         *
-         * @type {N}
-         */
-        this.node = null;
+    node = null;
 
-        /**
-         *
-         * @type {Edge<N>[]}
-         * @private
-         */
-        this.__edges = [];
+    /**
+     * Attached edges
+     * @type {Edge<N>[]}
+     * @private
+     */
+    __edges = [];
 
-        /**
-         *
-         * @type {Map<N,number>}
-         * @private
-         */
-        this.__neighbors = new Map();
+    /**
+     *
+     * @type {Map<N,number>}
+     * @private
+     */
+    __neighbors = new Map();
+
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {N[]}
+     */
+    get neighbours() {
+        return Array.from(this.__neighbors.keys());
     }
 
     /**
@@ -42,6 +50,110 @@ export class NodeContainer {
         return this.__edges;
     }
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {N[]}
+     */
+    get inNodes() {
+        return this.inEdges.map(e => e.other(this.node));
+    }
+
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {N[]}
+     */
+    get outNodes() {
+        return this.outEdges.map(e => e.other(this.node));
+    }
+
+
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
+    get outEdges() {
+        /**
+         *
+         * @type {Edge<N>[]}
+         */
+        const result = [];
+
+        this.getOutgoingEdges(result);
+
+        return result;
+    }
+
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
+    get inEdges() {
+        /**
+         *
+         * @type {Edge<N>[]}
+         */
+        const result = [];
+
+        this.getIncomingEdges(result);
+
+        return result;
+    }
+
+
+    /**
+     *
+     * @param {Edge<N>[]} result
+     * @returns {number}
+     */
+    getIncomingEdges(result) {
+        const edges = this.__edges;
+
+        const edge_count = edges.length;
+
+        let result_count = 0;
+
+        for (let i = 0; i < edge_count; i++) {
+            const edge = edges[i];
+
+            if (edge.isDirectedTowards(this.node)) {
+
+                result.push(edge);
+                result_count++;
+
+            }
+
+        }
+
+        return result_count;
+    }
+
+    /**
+     *
+     * @param {Edge<N>[]} result
+     * @returns {number}
+     */
+    getOutgoingEdges(result) {
+        const edges = this.__edges;
+
+        const edge_count = edges.length;
+
+        let result_count = 0;
+
+        for (let i = 0; i < edge_count; i++) {
+            const edge = edges[i];
+
+            if (edge.isDirectedAwayFrom(this.node)) {
+
+                result.push(edge);
+                result_count++;
+
+            }
+
+        }
+
+        return result_count;
+    }
+
     /**
      *
      * @return {number}
@@ -52,12 +164,14 @@ export class NodeContainer {
         const edges = this.__edges;
         const edge_count = edges.length;
 
+        const current_node = this.node;
+
         for (let i = 0; i < edge_count; i++) {
             const edge = edges[i];
 
             if (
-                (edge.first === this.node && edge.direction === EdgeDirectionType.Forward)
-                || (edge.second === this.node && edge.direction === EdgeDirectionType.Backward)
+                (edge.first === current_node && edge.direction === EdgeDirectionType.Forward)
+                || (edge.second === current_node && edge.direction === EdgeDirectionType.Backward)
 
             ) {
                 r++;
@@ -81,7 +195,7 @@ export class NodeContainer {
 
     /**
      *
-     * @param {function(Edge)} visitor
+     * @param {function(Edge<N>)} visitor
      * @param {*} [thisArg]
      * @returns {number}
      */

package/src/engine/ecs/storage/binary/BinarySerializationRegistry.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { Graph } from "../../../../core/graph/Graph.js";
+import { Graph } from "../../../../core/graph/v2/Graph.js";
 
 /**
  * Contains serializers for various data types as well as data upgraders which enable support for serialization format changes
@@ -39,25 +39,27 @@ export class BinarySerializationRegistry {
         assert.defined(adapter, 'adapter');
         assert.ok(adapter.isBinaryClassSerializationAdapter, 'adapter is not a BinaryClassSerializationAdapter');
 
-        if (className === undefined) {
+        let _className = className;
+
+        if (_className === undefined) {
             const klass = adapter.getClass();
 
             if (typeof klass.typeName === "string") {
-                className = klass.typeName;
+                _className = klass.typeName;
             } else {
                 throw new Error(`className not specified, could not infer class name from the class itself`);
             }
         }
 
-        if (this.serializers.has(className)) {
+        if (this.serializers.has(_className)) {
             //a serializer already exists
 
-            console.warn(`Serializer for class '${className}' already exists, ignoring request`);
+            console.warn(`Serializer for class '${_className}' already exists, ignoring request`);
 
             return false;
         }
 
-        this.serializers.set(className, adapter);
+        this.serializers.set(_className, adapter);
 
         return true;
     }

package/src/engine/graphics/particles/node-based/codegen/modules/FunctionModuleRegistry.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../../../../core/assert.js";
-import Graph from "../../../../../../core/graph/Graph.js";
 import { Edge, EdgeDirectionType } from "../../../../../../core/graph/Edge.js";
+import { Graph } from "../../../../../../core/graph/v2/Graph.js";
 import { FunctionModuleReference } from "./FunctionModuleReference.js";
 
 export class FunctionModuleRegistry {

package/src/engine/navigation/grid/find_path_on_grid_astar.js

@@ -26,7 +26,7 @@ function index2point(result, index, width) {
  * @param {number} height
  * @returns {number}
  */
-function computeNeighbors(result, index, width, height) {
+function compute_neighbors(result, index, width, height) {
     const x = index % width;
     const y = (index / width) | 0;
 
@@ -36,14 +36,17 @@ function computeNeighbors(result, index, width, height) {
         result[neighbour_count] = index - width;
         neighbour_count++
     }
+
     if (x > 0) {
         result[neighbour_count] = index - 1;
         neighbour_count++;
     }
+
     if (x < width - 1) {
         result[neighbour_count] = index + 1;
         neighbour_count++;
     }
+
     if (y < height - 1) {
         result[neighbour_count] = index + width;
         neighbour_count++
@@ -60,7 +63,7 @@ function computeNeighbors(result, index, width, height) {
  * @param {number} height
  * @returns {number[]}
  */
-function pathTo(node, g_score, width, height) {
+function compute_path(node, g_score, width, height) {
     let v_previous = new Vector2(-1, -1);
     let v_current = new Vector2();
 
@@ -111,7 +114,7 @@ function pathTo(node, g_score, width, height) {
         v_current = t;
 
         // find next point
-        const neighbour_count = computeNeighbors(neighbors, current, width, height);
+        const neighbour_count = compute_neighbors(neighbors, current, width, height);
 
         current = -1;
 
@@ -190,16 +193,16 @@ closed.preventShrink();
  * @param {number} height
  * @param {number} start
  * @param {number} goal
- * @param {number} crossingPenalty
- * @param {number} blockValue value in the field that signifies impassible obstacle
+ * @param {number} crossing_penalty
+ * @param {number} block_value value in the field that signifies impassible obstacle
  * @returns {Array.<number>} array of indices representing path from start to end
  */
 export function find_path_on_grid_astar(
     field,
     width, height,
     start, goal,
-    crossingPenalty,
-    blockValue
+    crossing_penalty,
+    block_value
 ) {
 
     assert.defined(field, 'field');
@@ -208,8 +211,8 @@ export function find_path_on_grid_astar(
     assert.isNonNegativeInteger(start, "start");
     assert.isNonNegativeInteger(goal, "goal");
 
-    assert.isNumber(crossingPenalty, 'crossingPenalty');
-    assert.isNumber(blockValue, 'blockValue');
+    assert.isNumber(crossing_penalty, 'crossingPenalty');
+    assert.isNumber(block_value, 'blockValue');
 
     // prepare sets
     open.clear();
@@ -232,15 +235,15 @@ export function find_path_on_grid_astar(
         const currentNode = open.pop_min();
 
         if (currentNode === goal) {
-            // End case -- result has been found, return the traced path.
-            return pathTo(currentNode, g_score, width, height);
+            // End case - result has been found, return the traced path.
+            return compute_path(currentNode, g_score, width, height);
         }
 
         // Normal case -- move currentNode from open to closed, process each of its neighbors.
         closed.set(currentNode, true);
 
         // Find all neighbors for the current node.
-        const neighbour_count = computeNeighbors(neighbors, currentNode, width, height);
+        const neighbour_count = compute_neighbors(neighbors, currentNode, width, height);
 
         for (let i = 0; i < neighbour_count; ++i) {
             const neighbor = neighbors[i];
@@ -252,39 +255,39 @@ export function find_path_on_grid_astar(
 
             // The g score is the shortest distance from start to current node.
             // We need to check if the path we have arrived at this neighbor is the shortest one we have seen yet.
-            const neighborValue = field[neighbor];
+            const neighbor_value = field[neighbor];
 
-            if (neighborValue === blockValue) {
+            if (neighbor_value === block_value) {
                 //cell is blocked, close and continue
                 closed.set(neighbor, true);
                 continue;
             }
 
             // Cost of traversing to this neighbour
-            const transition_cost = neighborValue * crossingPenalty + 1;
+            const transition_cost = neighbor_value * crossing_penalty + 1;
 
             // updated path cost
-            const gScore = g_score[currentNode] + transition_cost;
+            const cost_so_far = g_score[currentNode] + transition_cost;
 
             const index_in_open_set = open.find_index_by_id(neighbor);
 
             const not_in_open_set = index_in_open_set === -1;
 
-            if (not_in_open_set || gScore < g_score[neighbor]) {
+            if (not_in_open_set || cost_so_far < g_score[neighbor]) {
 
                 // update refined score
-                g_score[neighbor] = gScore;
+                g_score[neighbor] = cost_so_far;
 
-                const h = heuristic(neighbor, goal, width);
+                const remaining_heuristic = heuristic(neighbor, goal, width);
 
-                const fScore = gScore + h;
+                const refined_heuristic = cost_so_far + remaining_heuristic;
 
                 if (not_in_open_set) {
                     // Pushing to heap will put it in proper place based on the 'f' value.
-                    open.insert(neighbor, fScore);
+                    open.insert(neighbor, refined_heuristic);
                 } else {
                     // Already seen the node, but since it has been re-scored we need to reorder it in the heap
-                    open.__update_score_by_index(index_in_open_set, fScore);
+                    open.__update_score_by_index(index_in_open_set, refined_heuristic);
                 }
             }
         }

package/src/engine/navigation/grid/find_path_on_grid_astar.spec.js

@@ -36,7 +36,7 @@ test("path on open 3x3 grid", () => {
     expect(path).toEqual([0, 3, 5, 8]);
 });
 
-test.skip("performance, 256x256 random", () => {
+test("performance, 256x256 random", () => {
     const FIELD_SIZE = 256;
 
     const field = new Uint8Array(FIELD_SIZE * FIELD_SIZE);
@@ -45,7 +45,7 @@ test.skip("performance, 256x256 random", () => {
 
     const last_field_index = field.length - 1;
 
-    for (let i = 0; i < field.length * 0.05; i++) {
+    for (let i = 0; i < field.length * 0.15; i++) {
         const index = randomIntegerBetween(random, 0, last_field_index);
 
         field[index] = 255;

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

@@ -1,46 +1,30 @@
+import { GridTags } from "../../../../../samples/generation/grid/GridTags.js";
+import { MirGridLayers } from "../../../../../samples/generation/grid/MirGridLayers.js";
+import { matcher_tag_traversable } from "../../../../../samples/generation/rules/matcher_tag_traversable.js";
+import { BitSet } from "../../../../core/binary/BitSet.js";
+import { groupArrayBy } from "../../../../core/collection/array/groupArrayBy.js";
+import { collectIteratorValueToArray } from "../../../../core/collection/collectIteratorValueToArray.js";
+import BinaryHeap from "../../../../core/collection/heap/FastBinaryHeap.js";
+import { QuadTreeNode } from "../../../../core/geom/2d/quad-tree/QuadTreeNode.js";
+import { Graph } from "../../../../core/graph/v2/Graph.js";
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { GridTaskGenerator } from "../../GridTaskGenerator.js";
+import { remap } from "../../../../core/math/remap.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";
-import Graph from "../../../../core/graph/Graph.js";
-import BinaryHeap from "../../../../core/collection/heap/FastBinaryHeap.js";
-import { BitSet } from "../../../../core/binary/BitSet.js";
-import { matcher_tag_traversable } from "../../../../../samples/generation/rules/matcher_tag_traversable.js";
-import { buildPathFromDistanceMap } from "../util/buildPathFromDistanceMap.js";
+import { actionTask } from "../../../../core/process/task/util/actionTask.js";
+import { countTask } from "../../../../core/process/task/util/countTask.js";
 import { GridCellActionPlaceTags } from "../../../placement/action/GridCellActionPlaceTags.js";
-import { GridTags } from "../../../../../samples/generation/grid/GridTags.js";
 import { CellMatcher } from "../../../rules/CellMatcher.js";
-import { collectIteratorValueToArray } from "../../../../core/collection/collectIteratorValueToArray.js";
-import { QuadTreeNode } from "../../../../core/geom/2d/quad-tree/QuadTreeNode.js";
-import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+import { CellMatcherNot } from "../../../rules/logic/CellMatcherNot.js";
+import { GridTaskGenerator } from "../../GridTaskGenerator.js";
+import { buildPathFromDistanceMap } from "../util/buildPathFromDistanceMap.js";
+import { buildUnsignedDistanceField } from "../util/buildUnsignedDistanceField.js";
 import { PathEndPoint } from "./PathEndPoint.js";
-import { RoadConnection } from "./RoadConnection.js";
 import { readMarkerNodeGroupId } from "./readMarkerNodeGroupId.js";
-import { buildUnsignedDistanceField } from "../util/buildUnsignedDistanceField.js";
-import { CellMatcherNot } from "../../../rules/logic/CellMatcherNot.js";
+import { RoadConnection } from "./RoadConnection.js";
 import { RoadConnectionNetwork } from "./RoadConnectionNetwork.js";
-import { MirGridLayers } from "../../../../../samples/generation/grid/MirGridLayers.js";
-import { actionTask } from "../../../../core/process/task/util/actionTask.js";
-import { countTask } from "../../../../core/process/task/util/countTask.js";
-import { groupArrayBy } from "../../../../core/collection/array/groupArrayBy.js";
-import { remap } from "../../../../core/math/remap.js";
 
 const NODE_TYPE_ROAD_CONNECTOR = 'Road Connector';
 
-
-/**
- *
- * @param {QuadTreeNode} tree
- * @param {RoadConnection} path
- * @param {number} gridWidth
- */
-function addPathToQuadTree(tree, path, gridWidth) {
-    const bounds = new AABB2();
-
-    path.computeBounds(bounds, gridWidth);
-
-    tree.add(path, bounds.x0, bounds.y0, bounds.x1, bounds.y1);
-}
-
 /**
  *
  * @param {MarkerNode[]} array