@woosh/meep-engine 2.76.3 → 2.77.0

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;
 
@@ -166,15 +169,15 @@ function heuristic(index0, index1, width) {
     const x1 = index0 % width;
     const y1 = (index0 / width) | 0;
 
-    //
     const x2 = index1 % width;
     const y2 = (index1 / width) | 0;
 
-    //
-    const dx = Math.abs(x1 - x2);
-    const dy = Math.abs(y1 - y2);
+    // deltas
+    const dx = x2 - x1;
+    const dy = y2 - y1;
 
-    return dx + dy;
+    // we skip expensive SQRT, but still get a good guiding heuristic which has the same monotonic order
+    return dx * dx + dy * dy;
 }
 
 
@@ -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

@@ -33,7 +33,7 @@ test("path on open 3x3 grid", () => {
         0, 0, 0
     ], 3, 3, 0, 8, 0, 1);
 
-    expect(path).toEqual([0, 6, 8]);
+    expect(path).toEqual([0, 3, 5, 8]);
 });
 
 test("performance, 256x256 random", () => {
@@ -45,7 +45,7 @@ test("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

package/src/core/graph/GraphUtils.js

@@ -1,284 +0,0 @@
-/**
- * Created by Alex on 05/02/14.
- */
-
-
-import {
-    line_segment_compute_line_segment_intersection_vectors_array_2d
-} from "../geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js";
-
-const Utils = {};
-
-function pointBetweenEdges(edge1, edge2, node, thickness) {
-    const other1 = edge1.other(node);
-    const other2 = edge2.other(node);
-    const delta1 = other1.clone().sub(node);
-    const delta2 = other2.clone().sub(node);
-    const sum = delta2.normalize().clone().add(delta1.normalize());
-    let angle = edge2.angle() - edge1.angle();
-    if (angle < 0) {
-        angle += Math.PI * 2;
-    }
-//                console.log(angle * (57.295));
-    if (angle === 0) {
-        //parallel edges
-        sum.set(delta1.y, delta1.x);
-        sum.multiplyScalar(thickness / 2);
-        console.log(">");
-    } else {
-        const scalar = (thickness / 2) * (1 + sum.length() / 4);
-        sum.normalize().multiplyScalar(scalar);
-        if (angle > Math.PI) {
-            console.log("<");
-            sum.negate();
-        }
-    }
-    return sum;
-}
-
-function angleDifference(edge1, edge2) {
-    return edge1.angle() - edge2.angle();
-}
-
-function trace2(graph, thickness) {
-    //clone graph
-    const g = graph.clone();
-    let closedNodes = [];
-    let closedEdges = [];
-    //edge needs to be covered twice to be closed
-    let prevEdge, prevNode,
-        currentEdge, currentNode;
-    while (g.edges.length > 0) {
-        //pick next edge
-        const node = prevEdge.other(prevNode);
-        const neighbours = g.getAttachedEdges(node);
-        neighbours.sort(angleDifference);
-        let index = neighbours.indexOf(prevEdge);
-        index = (index + 1) % neighbours.length;
-        const edge = neighbours[index];
-    }
-}
-
-function makeCap(node, edge, thickness, type) {
-    const result = [];
-    //get direction
-    const other = edge.other(node);
-    const first = node.clone();
-    const second = other.clone();
-    const delta = second.clone().sub(first);
-    const inverseDelta = delta.clone();
-    //
-    inverseDelta.x = delta.y;
-    inverseDelta.y = -delta.x;
-
-    inverseDelta.normalize();
-    //projecting cap
-    if (type === "projecting") {
-        const half_thickness = thickness / 2;
-        const sid = inverseDelta.clone().multiplyScalar(half_thickness);
-        //projecting offset
-        const offset = delta.clone().normalize().multiplyScalar(half_thickness);
-        const anchor = node.clone().sub(offset);
-        result.push(sid.clone().add(anchor));
-        result.push(sid.negate().add(anchor));
-    }
-    return result;
-}
-
-function makeJoint2(node, edges, thickness) {
-    const result = [];
-    //sort edges by angle
-    edges.sort(angleDifference);
-
-    for (let i = 0; i < edges.length; i++) {
-        const j = (i + 1) % edges.length;
-        const edge1 = edges[i];
-        const edge2 = edges[j];
-        const sum = pointBetweenEdges(edge1, edge2, node, thickness);
-        result.push({
-            point: sum,
-            edges: [edge1, edge2]
-        })
-    }
-    result.forEach(function (element) {
-        element.point.add(node);
-    });
-    return result;
-}
-
-function graph2paths(graph, thickness) {
-    const points = [];
-    const nodes = graph.nodes;
-    //generating outline points
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        const attachedEdges = graph.getAttachedEdges(node);
-        const length = attachedEdges.length;
-        if (length === 0) {
-            //this node is not attached to any edge
-            console.warn("unconnected node, not representable");
-        } else if (length === 1) {
-            //this is an end point
-            const attachedEdge = attachedEdges[0];
-            const cap = makeCap(node, attachedEdge, thickness, "projecting");
-            cap.forEach(function (point) {
-                points.push({ node: node, edges: [attachedEdge], position: point });
-            });
-        } else if (length > 1) {
-            //this is a joint
-            const joint = makeJoint2(node, attachedEdges, thickness, null);
-            joint.forEach(function (data) {
-                points.push({ node: node, edges: data.edges, position: data.point })
-            });
-        }
-    }
-    let path;
-
-    function getCommonEdge(point1, point2) {
-        const edges1 = point1.edges;
-        const edges2 = point2.edges;
-        const l1 = edges1.length;
-        const l2 = edges2.length;
-        for (let i = 0; i < l1; i++) {
-            const edge1 = edges1[i];
-            for (let j = 0; j < l2; j++) {
-                const edge2 = edges2[j];
-                if (edge1 === edge2) {
-                    return edge1;
-                }
-            }
-        }
-        return null;
-    }
-
-    function lineIntersectsGraph(from, to, graph) {
-        const edges = graph.edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            if (line_segment_compute_line_segment_intersection_vectors_array_2d(from, to, edge.first, edge.second)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    function getNextPoint2(from) {
-        //filter points based on common edge
-        const edges0 = from.edges;
-        const l0 = edges0.length;
-        const candidates = [];
-        points.forEach(function (point, index) {
-            const edges1 = point.edges;
-            const l1 = edges1.length;
-            for (let i = 0; i < l0; i++) {
-                const e0 = edges0[i];
-                for (let j = 0; j < l1; j++) {
-                    const e1 = edges1[j];
-                    if (e0 === e1) {
-                        //now filter out those that cross the graph
-                        if (!lineIntersectsGraph(from.position, point.position, graph)) {
-                            candidates.push(index);
-                        }
-                    }
-                }
-            }
-        });
-        if (candidates.length > 0) {
-            const index = candidates[0];
-            const point = points[index];
-            points.splice(index, 1);
-            return point;
-        } else {
-            console.warn("No next point from ", from);
-        }
-
-    }
-
-    function getNextPoint(from) {
-        for (let i = 0; i < points.length; i++) {
-            const p = points[i];
-            const commonEdge = getCommonEdge(p, from);
-            if (commonEdge != null) {
-                //make sure line would not intersect the edge
-//                        var intersects = getLineIntersection(p.position, from.position, commonEdge.first, commonEdge.second);
-                const intersects = lineIntersectsGraph(p.position, from.position, graph);
-                if (intersects) {
-                    continue;
-                }
-                points.splice(i, 1);
-                return p;
-            }
-        }
-        console.warn("No next point from", from);
-        return null;
-    }
-
-    function trace() {
-        //pick a point
-        let currentPoint = points.pop();
-        let nextPoint;
-        path.moveTo(currentPoint.position.x, currentPoint.position.y);
-//            console.log("path.moveTo("+currentPoint.position.x+","+currentPoint.position.y+");");
-        const firstPoint = currentPoint;
-        for (nextPoint = getNextPoint2(currentPoint); nextPoint != null; nextPoint = getNextPoint2(currentPoint)) {
-            path.lineTo(nextPoint.position.x, nextPoint.position.y);
-//                console.log("path.lineTo("+nextPoint.position.x+","+nextPoint.position.y+");");
-            currentPoint = nextPoint;
-        }
-        path.lineTo(firstPoint.position.x, firstPoint.position.y);
-//            console.log("path.lineTo("+firstPoint.position.x+","+firstPoint.position.y+");");
-    }
-
-    const paths = [];
-    while (points.length > 0) {
-        path = new THREE.Path();
-        trace();
-        paths.push(path);
-    }
-    return paths;
-}
-
-function graph2rects(graph, thickness) {
-    const edges = graph.edges;
-    const paths = [];
-    for (let i = 0; i < edges.length; i++) {
-        const path = new THREE.Path();
-        const edge = edges[i];
-        //outline edge
-        const cap1 = makeCap(edge.first, edge, thickness, "projecting");
-        const cap2 = makeCap(edge.second, edge, thickness, "projecting");
-        const points = cap1.concat(cap2);
-        let point = points[0];
-        path.moveTo(point.x, point.y);
-        let j = 1;
-        const l = points.length;
-        for (; j < l + 1; j++) {
-            point = points[j % l];
-            path.lineTo(point.x, point.y);
-        }
-        paths.push(path);
-    }
-    return paths;
-}
-
-Utils.makeJoint2 = makeJoint2;
-
-Utils.paths2shapes = function (paths) {
-    const shapes = [];
-    paths.forEach(function (path) {
-        const r = path.toShapes();
-        Array.prototype.push.apply(shapes, r);
-    });
-    return shapes;
-};
-
-Utils.graph2shapes = function (graph, thickness) {
-    const paths = Utils.graph2paths(graph, thickness);
-    return Utils.paths2shapes(paths);
-};
-
-Utils.graph2paths = graph2paths;
-
-export default Utils;