@woosh/meep-engine 2.94.0 → 2.94.2

package/build/meep.cjs

@@ -102844,7 +102844,7 @@ class GUIEngine {
 
     constructor() {
 
-        this.ticker.subscribe(d => {
+        this.ticker.onTick.add(d => {
 
 
             let ctx = null;
@@ -116253,17 +116253,17 @@ class Uint32Heap {
         const size = this.__size;
 
         while (true) {
-            const l = (i << 1) + 1;
-            const r = l + 1;
+            const left = (i << 1) + 1;
+            const right = left + 1;
 
             let smallest = i;
 
-            if (l < size && this.compare(l, smallest)) {
-                smallest = l;
+            if (left < size && this.compare(left, smallest)) {
+                smallest = left;
             }
 
-            if (r < size && this.compare(r, smallest)) {
-                smallest = r;
+            if (right < size && this.compare(right, smallest)) {
+                smallest = right;
             }
 
             if (smallest === i) {
@@ -116337,19 +116337,23 @@ class Uint32Heap {
 
     pop_min() {
 
-        const result = this.top_id;
+        const new_size = this.__size - 1;
+        this.__size = new_size;
 
-        this.__size--;
+        const uint32 = this.__data_uint32;
+        const top_id = uint32[1];
 
-        if (this.__size > 0) {
-            // move top element to the bottom
-            this.swap(0, this.__size);
+        // move bottom element to the top.
+        // the top doesn't need to be moved down as we have discarded it already
+        const i2 = new_size << 1; // same as *2
 
-            // rebalance
-            this.heap_down(0);
-        }
+        uint32[0] = uint32[i2];
+        uint32[1] = uint32[i2 + 1];
 
-        return result;
+        // re-balance
+        this.heap_down(0);
+
+        return top_id;
     }
 
     /**
@@ -116367,6 +116371,7 @@ class Uint32Heap {
             const _id = uint32[address];
 
             if (_id === id) {
+                // reverse address to index
                 return (address >>> 1);
             }
         }
@@ -116380,7 +116385,7 @@ class Uint32Heap {
      * @param {number} id
      * @returns {boolean}
      */
-    contains(id){
+    contains(id) {
         return this.find_index_by_id(id) !== -1;
     }
 
@@ -116511,7 +116516,7 @@ class Uint32Heap {
 
         // insert at the end
         const index = current_size;
-        const address = index << 1;
+        const address = index << 1; // same as *2
 
         // write data
         this.__data_float32[address] = score;
@@ -116581,7 +116586,7 @@ function compute_neighbors(result, index, width, height) {
 /**
  *
  * @param {number} node
- * @param {number[]} g_score
+ * @param {number[]|Float32Array} g_score
  * @param {number} width
  * @param {number} height
  * @returns {number[]}
@@ -116610,11 +116615,11 @@ function compute_path(node, g_score, width, height) {
 
         // normalize
         if (_dx !== 0) {
-            _dx /= Math.abs(_dx);
+            _dx = sign$1(_dx);
         }
 
         if (_dy !== 0) {
-            _dy /= Math.abs(_dy);
+            _dy = sign$1(_dy);
         }
 
         const direction_change = dx !== _dx || dy !== _dy;
@@ -116675,6 +116680,7 @@ function compute_path(node, g_score, width, height) {
 
     }
 
+    // so far the path is from goal to start, we need to reverse it
     result.reverse();
 
     return result;
@@ -116709,6 +116715,12 @@ const open = new Uint32Heap();
 const closed = new BitSet();
 closed.preventShrink();
 
+/**
+ * Contains refined heuristic value
+ * @type {Float32Array}
+ */
+let g_score = new Float32Array(1024);
+
 /**
  *
  * @param {number[]|Uint8Array|Uint16Array|Float32Array} field
@@ -116716,7 +116728,6 @@ closed.preventShrink();
  * @param {number} height
  * @param {number} start
  * @param {number} goal
- * @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
  */
@@ -116724,7 +116735,6 @@ function find_path_on_grid_astar(
     field,
     width, height,
     start, goal,
-    crossing_penalty,
     block_value
 ) {
 
@@ -116732,14 +116742,15 @@ function find_path_on_grid_astar(
     open.clear();
     closed.reset();
 
-    /**
-     * Contains refined heuristic value
-     * @type {number[]}
-     */
-    const g_score = [];
+    const cell_count = width * height;
 
-    g_score[start] = 0;
+    if (g_score.length < cell_count) {
+        g_score = new Float32Array(cell_count);
+    }
 
+    g_score.fill(Infinity, 0, cell_count);
+
+    g_score[start] = 0;
 
     open.insert(start, heuristic(start, goal, width));
 
@@ -116778,32 +116789,24 @@ function find_path_on_grid_astar(
             }
 
             // Cost of traversing to this neighbour
-            const transition_cost = neighbor_value * crossing_penalty + 1;
+            const transition_cost = neighbor_value + 1;
 
             // updated path cost
             const cost_so_far = g_score[currentNode] + transition_cost;
 
-            const index_in_open_set = open.find_index_by_id(neighbor);
+            if (cost_so_far < g_score[neighbor]) {
 
-            const not_in_open_set = index_in_open_set === -1;
-
-            if (not_in_open_set || cost_so_far < g_score[neighbor]) {
-
-                // update refined score
+                // update actual cost
                 g_score[neighbor] = cost_so_far;
 
                 const remaining_heuristic = heuristic(neighbor, goal, width);
 
                 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, 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, refined_heuristic);
-                }
+                // Pushing to heap will put it in proper place based on the 'f' value.
+                open.insert_or_update(neighbor, refined_heuristic);
             }
+
         }
     }