@woosh/meep-engine 2.76.3 → 2.77.0

package/build/meep.cjs

@@ -70616,6 +70616,26 @@ class Edge {
         return (this.direction & EdgeDirectionType.Backward) !== 0;
     }
 
+    /**
+     * Checks direction of the edge, if the edge is directed towards supplied node - returns true, false otherwise
+     * @param {N} node
+     * @returns {boolean}
+     */
+    isDirectedTowards(node) {
+        return (this.first === node && this.direction === EdgeDirectionType.Backward)
+            || (this.second === node && this.direction === EdgeDirectionType.Forward);
+    }
+
+    /**
+     * Checks direction of the edge, if the edge is directed away from the supplied node - returns true, false otherwise
+     * @param {N} node
+     * @returns {boolean}
+     */
+    isDirectedAwayFrom(node) {
+        return (this.first === node && this.direction === EdgeDirectionType.Forward)
+            || (this.second === node && this.direction === EdgeDirectionType.Backward)
+    }
+
     /**
      * @deprecated
      * @returns {number}
@@ -70651,46 +70671,142 @@ class Edge {
  */
 Edge.prototype.isEdge = true;
 
+/**
+ * Supplementary structure to `Graph`, holds edges and neighbour nodes for fast access
+ * Used internally by `Graph`
+ * @template N
+ */
 class NodeContainer {
     /**
-     * @template N
+     * Node being described
+     * @type {N}
      */
-    constructor() {
-        /**
-         *
-         * @type {N}
-         */
-        this.node = null;
+    node = null;
 
+    /**
+     * Attached edges
+     * @type {Edge<N>[]}
+     * @private
+     */
+    __edges = [];
+
+    /**
+     *
+     * @type {Map<N,number>}
+     * @private
+     */
+    __neighbors = new Map();
+
+    /**
+     *
+     * @return {number}
+     */
+    getEdgeCount() {
+        return this.__edges.length;
+    }
+
+    /**
+     * Do not modify the returned value
+     * @return {Edge<N>[]}
+     */
+    getEdges() {
+        return this.__edges;
+    }
+
+    /**
+     *
+     * @returns {N[]}
+     */
+    get inNodes() {
+        return this.inEdges.map(e => e.other(this.node));
+    }
+
+    /**
+     *
+     * @returns {N[]}
+     */
+    get outNodes() {
+        return this.outEdges.map(e => e.other(this.node));
+    }
+
+
+    get outEdges() {
         /**
          *
          * @type {Edge<N>[]}
-         * @private
          */
-        this.__edges = [];
+        const result = [];
+
+        this.getOutgoingEdges(result);
+
+        return result;
+    }
 
+    get inEdges() {
         /**
          *
-         * @type {Map<N,number>}
-         * @private
+         * @type {Edge<N>[]}
          */
-        this.__neighbors = new Map();
+        const result = [];
+
+        this.getIncomingEdges(result);
+
+        return result;
     }
 
+
     /**
      *
-     * @return {number}
+     * @param {Edge<N>[]} result
+     * @returns {number}
      */
-    getEdgeCount() {
-        return this.__edges.length;
+    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;
     }
 
     /**
-     * Do not modify the returned value
-     * @return {Edge<N>[]}
+     *
+     * @param {Edge<N>[]} result
+     * @returns {number}
      */
-    getEdges() {
-        return this.__edges;
+    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;
     }
 
     /**
@@ -70703,12 +70819,14 @@ 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++;
@@ -70732,7 +70850,7 @@ class NodeContainer {
 
     /**
      *
-     * @param {function(Edge)} visitor
+     * @param {function(Edge<N>)} visitor
      * @param {*} [thisArg]
      * @returns {number}
      */
@@ -70864,17 +70982,20 @@ class NodeContainer {
 }
 
 /**
+ * Reconstruct path from search metadata
  * @template T
  * @param {NodeContainer<T>} goal_node_container
- * @param {Map<NodeContainer<T>,NodeContainer<T>>} cameFrom
- * @returns {T[]}
+ * @param {Map<NodeContainer<T>,NodeContainer<T>>} came_from
+ * @returns {T[]} Nodes comprising the path from start to goal
  */
-function construct_path(goal_node_container, cameFrom) {
+function construct_path(goal_node_container, came_from) {
     const result = [];
+
     let c = goal_node_container;
+
     do {
         result.unshift(c.node);
-        c = cameFrom.get(c);
+        c = came_from.get(c);
     } while (c !== undefined);
 
     return result;
@@ -70883,21 +71004,26 @@ function construct_path(goal_node_container, cameFrom) {
 /**
  * @template N
  */
-let Graph$1 = class Graph {
+class Graph {
 
     /**
      *
      * @type {Map<N, NodeContainer<N>>}
+     * @readonly
      * @private
      */
     __nodes = new Map();
     /**
      *
      * @type {Set<Edge<N>>}
+     * @readonly
      * @private
      */
     __edges = new Set();
 
+    /**
+     * @readonly
+     */
     on = {
         /**
          * @type {Signal<N,this>}
@@ -71051,10 +71177,10 @@ let Graph$1 = class Graph {
      *
      * @param {N} source
      * @param {N} target
-     * @param {EdgeDirectionType} type
+     * @param {EdgeDirectionType} [type] Undirected by default
      * @returns {Edge<N>}
      */
-    createEdge(source, target, type) {
+    createEdge(source, target, type = EdgeDirectionType.Undirected) {
         const edge = new Edge(source, target);
 
         edge.direction = type;
@@ -71230,8 +71356,7 @@ let Graph$1 = class Graph {
         const edge_count = edges.length;
 
         for (let i = 0; i < edge_count; i++) {
-            const edge = edges[i];
-            result[i] = edge;
+            result[i] = edges[i];
         }
 
         return edge_count;
@@ -71352,7 +71477,7 @@ let Graph$1 = class Graph {
 
         return r;
     }
-};
+}
 
 /**
  *
@@ -71361,7 +71486,7 @@ let Graph$1 = class Graph {
  * @return {Graph}
  */
 function computeSystemComponentDependencyGraph(system_count, systems) {
-    const dependency_graph = new Graph$1();
+    const dependency_graph = new Graph();
 
     for (let i = 0; i < system_count; i++) {
         const system = systems[i];
@@ -86097,564 +86222,6 @@ class PeriodicConsolePrinter {
     }
 }
 
-/**
- * Created by Alex on 29/01/14.
- */
-
-
-/**
- * @callback Graph~visitor
- * @param {*} node
- * @param {Edge} edge
- * @returns {boolean|undefined} if false is returned, traversal should stop
- */
-
-/**
- * @template N
- */
-class Graph {
-    /**
-     * @template N
-     * @constructor
-     */
-    constructor() {
-        /**
-         * @private
-         * @type {N[]}
-         */
-        this.__nodes = [];
-
-        /**
-         * Accelerated data structure for faster lookups
-         * @type {Set<any>}
-         * @private
-         */
-        this.__nodes_set = new Set();
-
-        /**
-         * @private
-         * @type {Edge<N>[]}
-         */
-        this.__edges = [];
-        this.onChange = new Signal();
-    }
-
-    /**
-     *
-     * @returns {N[]}
-     */
-    get nodes() {
-        return this.__nodes;
-    }
-
-    /**
-     *
-     * @returns {Edge<N>[]}
-     */
-    get edges() {
-        return this.__edges;
-    }
-
-    /**
-     * Converts this graph into a shallow copy of supplied graph
-     * @param {Graph<N>} other
-     */
-    copy(other) {
-        this.clear();
-
-        this.__nodes = other.__nodes.slice();
-        this.__edges = other.__edges.slice();
-
-        this.__nodes_set = new Set(this.__nodes);
-    }
-
-    /**
-     *
-     * @param {N} start
-     * @param {N} goal
-     * @returns {Array<N>|null} nodes from start to goal in the shortest path including both start and goal.
-     */
-    findPath(start, goal) {
-        const open = new Set();
-        open.add(start);
-
-        const closed = new Set();
-
-        const cameFrom = new Map();
-
-        function constructPath() {
-            const result = [];
-            let c = goal;
-            do {
-                result.unshift(c);
-                c = cameFrom.get(c);
-            } while (c !== undefined);
-
-            return result;
-        }
-
-        const graph = this;
-
-        function expandNode(current) {
-            graph.traverseSuccessors(current, function (node, edge) {
-                if (closed.has(node)) {
-                    return;
-                }
-                if (open.has(node)) {
-                    return;
-                }
-                open.add(node);
-                cameFrom.set(node, current);
-            });
-        }
-
-        while (open.size > 0) {
-            const current = open.values().next().value;
-            if (current === goal) {
-                //reached the goal
-                return constructPath();
-            }
-            open.delete(current);
-            closed.add(current);
-
-            //expand node
-            expandNode(current);
-        }
-
-        //no path found
-        return null;
-    }
-
-    /**
-     * Returns true if there is an edge between two given nodes on this graph
-     * @param {N} node1
-     * @param {N} node2
-     * @returns {boolean}
-     */
-    isEdgeBetween(node1, node2) {
-        if (!this.containsNode(node1) || !this.containsNode(node2)) {
-            return false; // one or both nodes are not part of the graph
-        }
-        const connectingEdge = this.findConnectingEdge(node1, node2);
-        return connectingEdge !== null;
-    }
-
-    /**
-     * Strictly traversable edge exists from source to target
-     * @param {N} source
-     * @param {N} target
-     * @returns {boolean}
-     */
-    edgeExists(source, target) {
-        if (!this.containsNode(source) || !this.containsNode(target)) {
-            return false; // one or both nodes are not part of the graph
-        }
-
-        return this.traversePredecessors(source, function (destination) {
-            if (destination === target) {
-                //terminate traversal, this will make "traversePredecessors" return true also
-                return false;
-            }
-        });
-    }
-
-    /**
-     *
-     * @param {function(node:N):boolean} visitor
-     * @param {*} [thisArg]
-     */
-    traverseNodes(visitor, thisArg) {
-        const nodes = this.__nodes;
-        const l = nodes.length;
-        for (let i = 0; i < l; i++) {
-            const node = nodes[i];
-            if (visitor.call(thisArg, node) === false) {
-                return;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @param {function(node:N, edge:Edge<N>):(boolean|void)} visitor
-     */
-    traverseSuccessors(node, visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-
-        for (; i < l; i++) {
-            const edge = edges[i];
-            const first = edge.first;
-            const second = edge.second;
-
-            if (first === node && edge.traversableForward()) {
-                if (visitor(second, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            } else if (second === node && edge.traversableBackward()) {
-                if (visitor(first, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            }
-        }
-
-    }
-
-    /**
-     *
-     * @param {function(edge:Edge<N>):boolean} visitor
-     */
-    traverseEdges(visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            if (visitor(edge) === false) {
-                //terminate traversal if visitor returns false
-                return;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @param {function(N,Edge<N>)} visitor
-     */
-    traversePredecessors(node, visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            const first = edge.first;
-            const second = edge.second;
-
-            if (second === node && edge.traversableForward()) {
-                if (visitor(first, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return true;
-                }
-            } else if (first === node && edge.traversableBackward()) {
-                if (visitor(second, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @param {function(N,Edge):(boolean|void)} visitor
-     */
-    traverseAttachedEdges(node, visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            const first = edge.first;
-            const second = edge.second;
-
-            if (first === node) {
-                if (visitor(second, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            } else if (second === node) {
-                if (visitor(first, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} source
-     * @param {N} target
-     * @return {Edge<N>|null}
-     */
-    findTraversableEdge(source, target) {
-
-        const edges = this.__edges;
-
-        const numEdges = edges.length;
-
-        for (let i = 0; i < numEdges; i++) {
-
-            /**
-             *
-             * @type {Edge<N>}
-             */
-            const edge = edges[i];
-
-            if (
-                (edge.first === source && edge.second === target && edge.direction !== EdgeDirectionType.Backward)
-                || (edge.second === source && edge.first === target && edge.direction !== EdgeDirectionType.Forward)
-            ) {
-                return edge;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     *
-     * @param {N} node1
-     * @param {N} node2
-     * @returns {Edge<N>|null}
-     */
-    findConnectingEdge(node1, node2) {
-        const edges = this.__edges;
-
-        const numEdges = edges.length;
-
-        for (let i = 0; i < numEdges; i++) {
-
-            const edge = edges[i];
-
-            if (edge.contains(node1) && edge.contains(node2)) {
-                return edge;
-            }
-
-        }
-
-        return null;
-    }
-
-    /**
-     *
-     * @param {N} source
-     * @param {N} target
-     * @param {function(Edge<N>):boolean} visitor
-     */
-    findTraversableEdges(source, target, visitor) {
-        const edges = this.__edges;
-        for (let i = 0; i < edges.length; i++) {
-            const edge = edges[i];
-            if (edge.validateTransition(source, target)) {
-
-                if (visitor(edge) === false) {
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {Edge<N>[]}
-     */
-    getAttachedEdges(node) {
-        let i = 0;
-
-        const result = [];
-
-        const edges = this.__edges;
-        const l = edges.length;
-
-        for (; i < l; i++) {
-            const edge = edges[i];
-
-            if (edge.contains(node)) {
-                result.push(edge);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {N[]}
-     */
-    getNeighbours(node) {
-        const result = [];
-
-        const edges = this.edges;
-        const nEdges = edges.length;
-
-        for (let i = 0; i < nEdges; i++) {
-            const edge = edges[i];
-
-            const first = edge.first;
-            const second = edge.second;
-
-            if (first === node && (edge.direction === EdgeDirectionType.Forward || edge.direction === EdgeDirectionType.Undirected)) {
-                if (result.indexOf(second) === -1) {
-                    result.push(second);
-                }
-            } else if (second === node && (edge.direction === EdgeDirectionType.Backward || edge.direction === EdgeDirectionType.Undirected)) {
-                if (result.indexOf(first) === -1) {
-                    result.push(first);
-                }
-            }
-
-        }
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {boolean}
-     */
-    containsNode(node) {
-        return this.__nodes_set.has(node);
-    }
-
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    length() {
-        const edges = this.__edges;
-        let result = 0;
-        for (let i = 0; i < edges.length; i++) {
-            const edge = edges[i];
-            result += edge.length;
-        }
-        return result;
-    }
-
-    /**
-     *
-     * @param {N} node
-     */
-    addNode(node) {
-
-        this.__nodes_set.add(node);
-
-        this.__nodes.push(node);
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {boolean}
-     */
-    removeNode(node) {
-        if (!this.containsNode(node)) {
-            return false;
-        }
-
-        const i = this.__nodes.indexOf(node);
-
-        if (i === -1) {
-            // this should never happen
-            return false;
-        } else {
-            //remove attached connections
-            const attachedEdges = this.getAttachedEdges(node);
-
-            const n = attachedEdges.length;
-
-            for (let j = 0; j < n; j++) {
-                const edge = attachedEdges[j];
-
-                this.removeEdge(edge);
-            }
-
-            this.__nodes.splice(i, 1);
-            this.__nodes_set.delete(node);
-
-            return true;
-        }
-    }
-
-    /**
-     * Whether or not the graph contains given node
-     * NOTE: same as {@link #containsNode}
-     * @param {N} node
-     * @returns {boolean}
-     */
-    hasNode(node) {
-        return this.containsNode(node);
-    }
-
-    /**
-     *
-     * @param {Edge<N>} edge
-     */
-    addEdge(edge) {
-        //assert.ok(this.containsNode(edge.first), `Node Edge.first(=${edge.first}) is not present in the graph`);
-        //assert.ok(this.containsNode(edge.second), `Node Edge.second(=${edge.second}) is not present in the graph`);
-
-        this.__edges.push(edge);
-        this.onChange.send1(edge);
-    }
-
-    /**
-     *
-     * @param {N} source
-     * @param {N} target
-     * @param {EdgeDirectionType} [direction]
-     * @returns {Edge<N>}
-     */
-    createEdge(source, target, direction = EdgeDirectionType.Undirected) {
-        const edge = new Edge(source, target);
-
-        edge.direction = direction;
-
-        this.addEdge(edge);
-
-        return edge;
-    }
-
-    /**
-     *
-     * @param {Edge<N>} edge
-     * @returns {boolean}
-     */
-    removeEdge(edge) {
-        const edges = this.__edges;
-        const indexOf = edges.indexOf(edge);
-        if (indexOf >= 0) {
-            edges.splice(indexOf, 1);
-            this.onChange.send1(edge);
-
-            return true;
-        } else {
-
-            return false;
-        }
-    }
-
-    clear() {
-        this.__edges = [];
-        this.__nodes = [];
-        this.__nodes_set.clear();
-
-        this.onChange.send0();
-    }
-
-    /**
-     *
-     * @returns {Graph<N>}
-     */
-    clone() {
-        const graph = new Graph();
-
-        graph.copy(this);
-
-        return graph;
-    }
-}
-
 /**
  * Contains serializers for various data types as well as data upgraders which enable support for serialization format changes
  */
@@ -86691,23 +86258,25 @@ class BinarySerializationRegistry {
      */
     registerAdapter(adapter, className) {
 
-        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
 
             return false;
         }
 
-        this.serializers.set(className, adapter);
+        this.serializers.set(_className, adapter);
 
         return true;
     }
@@ -116362,7 +115931,7 @@ class Uint32Heap {
         const size = this.__size;
 
         while (true) {
-            const l = ((i) << 1) + 1;
+            const l = (i << 1) + 1;
             const r = l + 1;
 
             let smallest = i;
@@ -116484,6 +116053,15 @@ class Uint32Heap {
         return -1;
     }
 
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    contains(id){
+        return this.find_index_by_id(id) !== -1;
+    }
+
     /**
      * Clear out all the data, heap will be made empty
      */
@@ -116649,7 +116227,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;
 
@@ -116659,14 +116237,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++;
@@ -116683,7 +116264,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();
 
@@ -116734,7 +116315,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;
 
@@ -116789,15 +116370,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;
 }
 
 
@@ -116813,16 +116394,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
  */
 function find_path_on_grid_astar(
     field,
     width, height,
     start, goal,
-    crossingPenalty,
-    blockValue
+    crossing_penalty,
+    block_value
 ) {
 
     // prepare sets
@@ -116846,15 +116427,15 @@ 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];
@@ -116866,39 +116447,39 @@ 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);
                 }
             }
         }