@woosh/meep-engine 2.76.0 → 2.76.1

package/build/meep.cjs

@@ -71805,7 +71805,7 @@ BitSet.prototype.shift = function (distance, start_index, end_index) {
 };
 
 /**
- * Sets all of the bits in this BitSet to false.
+ * Sets all the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
     const current_length = this.__length;
@@ -71813,7 +71813,9 @@ BitSet.prototype.reset = function () {
     if (current_length <= 0) {
         // no action required
         return;
-    } else if (current_length <= 32) {
+    }
+
+    if (current_length <= 32) {
         // one word, set first word to 0 manually
         this.__data_uint32[0] = 0;
     } else {

package/build/meep.module.js

@@ -71803,7 +71803,7 @@ BitSet.prototype.shift = function (distance, start_index, end_index) {
 };
 
 /**
- * Sets all of the bits in this BitSet to false.
+ * Sets all the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
     const current_length = this.__length;
@@ -71811,7 +71811,9 @@ BitSet.prototype.reset = function () {
     if (current_length <= 0) {
         // no action required
         return;
-    } else if (current_length <= 32) {
+    }
+
+    if (current_length <= 32) {
         // one word, set first word to 0 manually
         this.__data_uint32[0] = 0;
     } else {

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.76.0",
+  "version": "2.76.1",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/BitSet.js

@@ -546,7 +546,7 @@ BitSet.prototype.shift = function (distance, start_index, end_index) {
 };
 
 /**
- * Sets all of the bits in this BitSet to false.
+ * Sets all the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
     const current_length = this.__length;
@@ -554,7 +554,9 @@ BitSet.prototype.reset = function () {
     if (current_length <= 0) {
         // no action required
         return;
-    } else if (current_length <= 32) {
+    }
+
+    if (current_length <= 32) {
         // one word, set first word to 0 manually
         this.__data_uint32[0] = 0;
     } else {

package/src/core/collection/heap/Uin32Heap.spec.js

@@ -1,5 +1,5 @@
-import { Uint32Heap } from "./Uint32Heap.js";
 import { seededRandom } from "../../math/random/seededRandom.js";
+import { Uint32Heap } from "./Uint32Heap.js";
 
 test('initial capacity setting via constructor', () => {
     const heap = new Uint32Heap(3);
@@ -126,6 +126,19 @@ test("insert_or_update", () => {
 
 });
 
+test("clear should make heap empty", () => {
+    const heap = new Uint32Heap();
+
+    heap.clear();
+
+    expect(heap.is_empty()).toBe(true);
+
+    heap.insert(1, 7);
+
+    heap.clear();
+
+    expect(heap.is_empty()).toBe(true);
+});
 
 test.skip("performance 1,000,000 random element fill / drain", () => {
 

package/src/core/collection/heap/Uint32Heap.js

@@ -55,12 +55,12 @@ function HEAP_RIGHT(i) {
 export class Uint32Heap {
     /**
      *
-     * @param {number} [capacity] Can supply initial capacity, heap will still grow when necessary. This allows to prevent needless re-allocations when max heap size is known in advance
+     * @param {number} [initial_capacity] Can supply initial capacity, heap will still grow when necessary. This allows to prevent needless re-allocations when max heap size is known in advance
      */
-    constructor(capacity = DEFAULT_CAPACITY) {
-        assert.isNonNegativeInteger(capacity, 'capacity');
+    constructor(initial_capacity = DEFAULT_CAPACITY) {
+        assert.isNonNegativeInteger(initial_capacity, 'capacity');
 
-        this.__data_buffer = new ArrayBuffer(capacity * ELEMENT_BYTE_SIZE);
+        this.__data_buffer = new ArrayBuffer(initial_capacity * ELEMENT_BYTE_SIZE);
 
         /**
          * Used to access stored IDs
@@ -76,7 +76,7 @@ export class Uint32Heap {
          */
         this.__data_float32 = new Float32Array(this.__data_buffer);
 
-        this.__capacity = capacity;
+        this.__capacity = initial_capacity;
         this.__size = 0;
     }
 
@@ -140,9 +140,12 @@ export class Uint32Heap {
         uint32[i2] = uint32[j2];
         uint32[j2] = mem_0;
 
-        const mem_1 = uint32[i2 + 1];
-        uint32[i2 + 1] = uint32[j2 + 1];
-        uint32[j2 + 1] = mem_1;
+        const i21 = i2 + 1;
+        const j21 = j2 + 1;
+
+        const mem_1 = uint32[i21];
+        uint32[i21] = uint32[j21];
+        uint32[j21] = mem_1;
     }
 
     /**
@@ -263,7 +266,7 @@ export class Uint32Heap {
      */
     find_index_by_id(id) {
         const n = this.__size
-        const n2 = n * 2;
+        const n2 = n << 1; // fast *2 multiplication
 
         const uint32 = this.__data_uint32;
 
@@ -279,6 +282,12 @@ export class Uint32Heap {
         return -1;
     }
 
+    /**
+     * Clear out all the data, heap will be made empty
+     */
+    clear() {
+        this.__size = 0;
+    }
 
     /**
      *
@@ -331,14 +340,16 @@ export class Uint32Heap {
     }
 
     /**
-     *
+     * Update score of an element referenced directly by index, this is a fast method, but you're generally not going to know the index so in most cases it's best to use "update_score" instead
      * @param {number} index
      * @param {number} score
      */
     __update_score_by_index(index, score) {
 
         const float32 = this.__data_float32;
-        const index2 = index * 2;
+
+        const index2 = index << 1; // fast *2 multiplication
+
         const existing_score = float32[index2];
 
         if (score < existing_score) {
@@ -362,7 +373,9 @@ export class Uint32Heap {
             return Number.NaN;
         }
 
-        return this.__data_float32[index * 2];
+        const index2 = index << 1; // fast *2 multiplication
+
+        return this.__data_float32[index2];
     }
 
 
@@ -391,21 +404,23 @@ export class Uint32Heap {
         assert.lessThanOrEqual(id, UINT32_MAX - 1, 'must be less than or equal to (2^32 - 2)');
         assert.isNumber(score, 'score');
 
-        if (this.__size >= this.__capacity) {
+        const current_size = this.__size;
+
+        if (current_size >= this.__capacity) {
             // need to re-allocate
             this.__capacity_grow();
         }
 
         // insert at the end
-        const index = this.__size;
-        const address = index * 2;
+        const index = current_size;
+        const address = index << 1;
 
         // write data
         this.__data_float32[address] = score;
         this.__data_uint32[address + 1] = id;
 
         // record increased size
-        this.__size++;
+        this.__size = current_size + 1;
 
         this.heap_up(index);
     }

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

@@ -1,7 +1,9 @@
-import BinaryHeap from '../../../core/collection/heap/FastBinaryHeap.js';
-import Vector2 from '../../../core/geom/Vector2.js';
 import { assert } from "../../../core/assert.js";
+import { BitSet } from "../../../core/binary/BitSet.js";
+import { Uint32Heap } from "../../../core/collection/heap/Uint32Heap.js";
+import Vector2 from '../../../core/geom/Vector2.js';
 
+const neighbors = new Uint32Array(4);
 
 /**
  *
@@ -18,28 +20,169 @@ function index2point(result, index, width) {
 
 /**
  *
- * @param {number[]} result
+ * @param {number[]|Uint32Array} result
  * @param {number} index
  * @param {number} width
  * @param {number} height
+ * @returns {number}
  */
-function computeOrthogonalNeighbors(result, index, width, height) {
+function computeNeighbors(result, index, width, height) {
     const x = index % width;
     const y = (index / width) | 0;
+
+    let neighbour_count = 0;
+
+    if (y > 0) {
+        result[neighbour_count] = index - width;
+        neighbour_count++
+    }
     if (x > 0) {
-        result.push(index - 1);
+        result[neighbour_count] = index - 1;
+        neighbour_count++;
     }
     if (x < width - 1) {
-        result.push(index + 1);
-    }
-    if (y > 0) {
-        result.push(index - width);
+        result[neighbour_count] = index + 1;
+        neighbour_count++;
     }
     if (y < height - 1) {
-        result.push(index + width);
+        result[neighbour_count] = index + width;
+        neighbour_count++
+    }
+
+    return neighbour_count;
+}
+
+/**
+ *
+ * @param {number} node
+ * @param {number[]} g_score
+ * @param {number} width
+ * @param {number} height
+ * @returns {number[]}
+ */
+function pathTo(node, g_score, width, height) {
+    let v_previous = new Vector2(-1, -1);
+    let v_current = new Vector2();
+
+    let dx = 1,
+        dy = 1,
+        _dx = 0,
+        _dy = 0;
+
+    const result = [];
+
+    let current = node;
+    let prev = current;
+
+    let last_value = g_score[current];
+
+    while (current !== -1) {
+        index2point(v_current, current, width);
+
+        _dx = v_current.x - v_previous.x;
+        _dy = v_current.y - v_previous.y;
+
+        // normalize
+        if (_dx !== 0) {
+            _dx /= Math.abs(_dx);
+        }
+
+        if (_dy !== 0) {
+            _dy /= Math.abs(_dy);
+        }
+
+        const direction_change = dx !== _dx || dy !== _dy;
+
+        if (direction_change) {
+            // direction changed
+            dx = _dx;
+            dy = _dy;
+
+            //only record points where connection bends to save space
+            result.push(prev);
+        }
+
+        prev = current;
+
+
+        //swap vectors
+        const t = v_previous;
+        v_previous = v_current;
+        v_current = t;
+
+        // find next point
+        const neighbour_count = computeNeighbors(neighbors, current, width, height);
+
+        current = -1;
+
+        for (let i = 0; i < neighbour_count; i++) {
+            const neighbor = neighbors[i];
+
+            const score = g_score[neighbor];
+
+            if (score < last_value) {
+                current = neighbor;
+                last_value = score;
+            } else if (score === last_value) {
+                // same score, prefer non-bending neighbours
+
+                index2point(v_current, neighbor, width);
+
+                _dx = v_current.x - v_previous.x;
+                _dy = v_current.y - v_previous.y;
+
+                if (_dx === dx && _dy === dy) {
+                    // same direction
+                    current = neighbor;
+                    last_value = score;
+                }
+
+            }
+        }
+
     }
+
+    if (result[result.length - 1] !== prev) {
+
+        //check if last node needs to be added
+        result.push(prev);
+
+    }
+
+    result.reverse();
+
+    return result;
 }
 
+
+/**
+ *
+ * @param {number} index0
+ * @param {number} index1
+ * @param {number} width
+ * @returns {number}
+ */
+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);
+
+    return dx + dy;
+}
+
+
+const open = new Uint32Heap();
+
+const closed = new BitSet();
+closed.preventShrink();
+
 /**
  *
  * @param {number[]|Uint8Array|Uint16Array|Float32Array} field
@@ -48,8 +191,7 @@ function computeOrthogonalNeighbors(result, index, width, height) {
  * @param {number} start
  * @param {number} goal
  * @param {number} crossingPenalty
- * @param {number} bendPenalty
- * @param {number} blockValue
+ * @param {number} blockValue 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(
@@ -57,170 +199,97 @@ export function find_path_on_grid_astar(
     width, height,
     start, goal,
     crossingPenalty,
-    bendPenalty,
     blockValue
 ) {
 
     assert.defined(field, 'field');
     assert.notNull(field, 'field');
 
-
     assert.isNonNegativeInteger(start, "start");
     assert.isNonNegativeInteger(goal, "goal");
 
     assert.isNumber(crossingPenalty, 'crossingPenalty');
-    assert.isNumber(bendPenalty, 'bendPenalty');
     assert.isNumber(blockValue, 'blockValue');
 
+    // prepare sets
+    open.clear();
+    closed.reset();
 
-    let limitCycles = 5000000;
-
-    const heuristic = function (index0, index1) {
-        const x1 = index0 % width;
-        const y1 = Math.floor(index0 / width);
-        //
-        const x2 = index1 % width;
-        const y2 = Math.floor(index1 / width);
-        //
-        const dx = Math.abs(x1 - x2);
-        const dy = Math.abs(y1 - y2);
-        return dx + dy;
-    };
-
-    const came_from = [];
-    const f_score = [];
+    /**
+     * Contains refined heuristic value
+     * @type {number[]}
+     */
     const g_score = [];
 
-    const open = new BinaryHeap(function score(i1) {
-        return f_score[i1];
-    });
+    g_score[start] = 0;
 
-    const closed = [];
 
-    g_score[start] = 0;
-    f_score[goal] = heuristic(start, goal);
-
-    const directionTo = [];
-    directionTo[start] = 0;
-
-    open.push(start);
-
-    function pathTo(node) {
-        let pP = new Vector2(-1, -1),
-            pC = new Vector2();
-        let dx = 1,
-            dy = 1,
-            _dx = 0,
-            _dy = 0;
-        const result = [];
-        let prev = node;
-        while (node !== void 0) {
-            index2point(pC, node, width);
-            _dx = pC.x - pP.x;
-            _dy = pC.y - pP.y;
-            //
-            if (_dx !== 0) {
-                _dx /= Math.abs(_dx);
-            }
-            if (_dy !== 0) {
-                _dy /= Math.abs(_dy);
-            }
-            if (dx !== _dx || dy !== _dy) {
-                dx = _dx;
-                dy = _dy;
-                //only record points where connection bends to save space
-                result.push(prev);
-            }
-            prev = node;
-            node = came_from[node];
-            //swap
-            const t = pP;
-            pP = pC;
-            pC = t;
-        }
-        if (result[result.length - 1] !== prev) {
-            //check if last node needs to be added
-            result.push(prev);
-        }
-        result.reverse();
-        return result;
-    }
+    open.insert(start, heuristic(start, goal, width));
+
+    while (!open.is_empty()) {
 
-    const neighbors = [];
-    while (open.size() > 0) {
-        if (limitCycles-- === 0) {
-            throw new Error("maximum number of cycles reached");
-        }
         // Grab the lowest f(x) to process next.  Heap keeps this sorted for us.
-        const currentNode = open.pop();
+        const currentNode = open.pop_min();
 
-        // End case -- result has been found, return the traced path.
         if (currentNode === goal) {
-            return pathTo(currentNode);
+            // End case -- result has been found, return the traced path.
+            return pathTo(currentNode, g_score, width, height);
         }
 
         // Normal case -- move currentNode from open to closed, process each of its neighbors.
-        closed[currentNode] = true;
+        closed.set(currentNode, true);
 
         // Find all neighbors for the current node.
-        neighbors.length = 0;
-        computeOrthogonalNeighbors(neighbors, currentNode, width, height);
-        const numNeighbours = neighbors.length;
-        if (numNeighbours === 0) {
-            continue;
-        }
-        const directionToCurrent = directionTo[currentNode];
-        for (let i = 0; i < numNeighbours; ++i) {
+        const neighbour_count = computeNeighbors(neighbors, currentNode, width, height);
+
+        for (let i = 0; i < neighbour_count; ++i) {
             const neighbor = neighbors[i];
 
-            if (closed[neighbor] !== void 0) {
-                // Not a valid node to process, skip to next neighbor.
+            if (closed.get(neighbor)) {
+                // Already closed, skip to next neighbor.
                 continue;
             }
 
             // 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];
+
             if (neighborValue === blockValue) {
-                //cell is blocked, cloe and continue
-                closed[neighbor] = true;
+                //cell is blocked, close and continue
+                closed.set(neighbor, true);
                 continue;
             }
-            const direction = neighbor - currentNode;
-            let turnValue;
-            if (direction !== directionToCurrent) {
-                turnValue = bendPenalty;
-            } else {
-                turnValue = 0;
-            }
-            const transitionCost = neighborValue * crossingPenalty + 1 + turnValue;
 
-            const gScore = g_score[currentNode] + transitionCost,
-                notInOpenSet = !open.contains(neighbor);
+            // Cost of traversing to this neighbour
+            const transition_cost = neighborValue * crossingPenalty + 1;
 
-            if (notInOpenSet || gScore < g_score[neighbor]) {
+            // updated path cost
+            const gScore = g_score[currentNode] + transition_cost;
 
-                // Found an optimal (so far) path to this node.  Take score for node to see how good it is.
-                came_from[neighbor] = currentNode;
+            const index_in_open_set = open.find_index_by_id(neighbor);
 
-                directionTo[neighbor] = direction;
+            const not_in_open_set = index_in_open_set === -1;
 
+            if (not_in_open_set || gScore < g_score[neighbor]) {
+
+                // update refined score
                 g_score[neighbor] = gScore;
-                const h = heuristic(neighbor, goal);
 
-                f_score[neighbor] = gScore + h;
+                const h = heuristic(neighbor, goal, width);
 
+                const fScore = gScore + h;
 
-                if (notInOpenSet) {
+                if (not_in_open_set) {
                     // Pushing to heap will put it in proper place based on the 'f' value.
-                    open.push(neighbor);
+                    open.insert(neighbor, fScore);
                 } else {
-                    // Already seen the node, but since it has been rescored we need to reorder it in the heap
-                    open.updateElementScore(neighbor);
+                    // 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);
                 }
             }
         }
     }
+
     // No result was found - empty array signifies failure to find path.
     return [];
 }

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

@@ -1,32 +1,92 @@
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { number_pretty_print } from "../../../core/primitives/numbers/number_pretty_print.js";
 import { find_path_on_grid_astar } from "./find_path_on_grid_astar.js";
 
 test("sanity check on 1x1 grid", () => {
-    const path = find_path_on_grid_astar([0], 1, 1, 0, 0, 0, 0, 1);
+    const path = find_path_on_grid_astar([0], 1, 1, 0, 0, 0, 1);
 
     expect(path).toEqual([0]);
 });
 
 test("sanity check on 2x1 grid", () => {
-    const path = find_path_on_grid_astar(
-        [0, 0], 2, 1,
-        0, 1,
-        0, 0, 1
-    );
+    const path = find_path_on_grid_astar([0, 0], 2, 1, 0, 1, 0, 1);
 
     expect(path).toEqual([0, 1]);
 });
 
 test("sanity check on 2x2 grid", () => {
 
-    const path = find_path_on_grid_astar(
-        [
-            0, 0,
-            1, 0
-        ],
-        2, 2,
-        0, 3,
-        0, 0, 1
-    );
+    const path = find_path_on_grid_astar([
+        0, 0,
+        1, 0
+    ], 2, 2, 0, 3, 0, 1);
 
     expect(path).toEqual([0, 1, 3]);
 });
+
+test("path on open 3x3 grid", () => {
+
+    const path = find_path_on_grid_astar([
+        0, 0, 0,
+        0, 0, 0,
+        0, 0, 0
+    ], 3, 3, 0, 8, 0, 1);
+
+    expect(path).toEqual([0, 6, 8]);
+});
+
+test("performance, 256x256 random", () => {
+    const FIELD_SIZE = 256;
+
+    const field = new Uint8Array(FIELD_SIZE * FIELD_SIZE);
+
+    const random = seededRandom(42);
+
+    const last_field_index = field.length - 1;
+
+    for (let i = 0; i < field.length * 0.05; i++) {
+        const index = randomIntegerBetween(random, 0, last_field_index);
+
+        field[index] = 255;
+
+    }
+
+    const SAMPLE_COUNT = 10000;
+
+    const coordinates = new Uint32Array(SAMPLE_COUNT * 2);
+
+    for (let i = 0; i < SAMPLE_COUNT * 2; i++) {
+        //build non-blocking point pairs for rout endpoints
+        const index = randomIntegerBetween(random, 0, last_field_index);
+
+        if (field[index] !== 0) {
+            i--;
+            continue;
+        }
+
+        coordinates[i] = index;
+    }
+
+    const t0 = performance.now();
+
+    for (let i = 0; i < SAMPLE_COUNT; i++) {
+
+        const i2 = i * 2;
+        const start = coordinates[i2];
+        const goal = coordinates[i2 + 1];
+
+        find_path_on_grid_astar(
+            field,
+            FIELD_SIZE, FIELD_SIZE,
+            start,
+            goal, 1, 255
+        );
+    }
+
+    const t1 = performance.now();
+
+    const duration = t1 - t0;
+
+    console.log(`${number_pretty_print(SAMPLE_COUNT)} paths, ${number_pretty_print(duration / SAMPLE_COUNT)}ms per path`);
+});