@esengine/pathfinding 1.0.1

package/bin/pathfinding.js

@@ -0,0 +1,559 @@
+// 高性能寻路算法库 - 完整版 v1.0.1
+export { Vector2Utils } from './Types/IVector2';
+export { PriorityQueue } from './Utils/PriorityQueue';
+export { AStarPathfinder } from './AI/Pathfinding/AStar/AStarPathfinder';
+export { AstarGridGraph } from './AI/Pathfinding/AStar/AstarGridGraph';
+export { BreadthFirstPathfinder } from './AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder';
+export { UnweightedGraph } from './AI/Pathfinding/BreadthFirst/UnweightedGraph';
+export { UnweightedGridGraph } from './AI/Pathfinding/BreadthFirst/UnweightedGridGraph';
+
+var Vector2Utils = (function () {
+    function Vector2Utils() {
+    }
+    Vector2Utils.equals = function (a, b) {
+        if (a.equals) {
+            return a.equals(b);
+        }
+        return a.x === b.x && a.y === b.y;
+    };
+    Vector2Utils.create = function (x, y) {
+        return { x: x, y: y };
+    };
+    Vector2Utils.clone = function (vector) {
+        return { x: vector.x, y: vector.y };
+    };
+    Vector2Utils.add = function (a, b) {
+        return { x: a.x + b.x, y: a.y + b.y };
+    };
+    Vector2Utils.manhattanDistance = function (a, b) {
+        return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+    };
+    Vector2Utils.distance = function (a, b) {
+        var dx = a.x - b.x;
+        var dy = a.y - b.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    };
+    Vector2Utils.toHash = function (vector) {
+        var x = (vector.x + this.MAX_COORD) | 0;
+        var y = (vector.y + this.MAX_COORD) | 0;
+        return (x << 16) | y;
+    };
+    Vector2Utils.toKey = function (vector) {
+        return "".concat(vector.x, ",").concat(vector.y);
+    };
+    Vector2Utils.fromHash = function (hash) {
+        var x = (hash >> 16) - this.MAX_COORD;
+        var y = (hash & 0xFFFF) - this.MAX_COORD;
+        return { x: x, y: y };
+    };
+    Vector2Utils.HASH_MULTIPLIER = 73856093;
+    Vector2Utils.MAX_COORD = 32767;
+    return Vector2Utils;
+}());
+export { Vector2Utils };
+
+var PriorityQueue = (function () {
+    function PriorityQueue() {
+        this._heap = [];
+        this._size = 0;
+    }
+    Object.defineProperty(PriorityQueue.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PriorityQueue.prototype, "isEmpty", {
+        get: function () {
+            return this._size === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PriorityQueue.prototype.clear = function () {
+        this._heap.length = 0;
+        this._size = 0;
+    };
+    PriorityQueue.prototype.enqueue = function (item) {
+        this._heap[this._size] = item;
+        this._bubbleUp(this._size);
+        this._size++;
+    };
+    PriorityQueue.prototype.dequeue = function () {
+        if (this._size === 0) {
+            return undefined;
+        }
+        var result = this._heap[0];
+        this._size--;
+        if (this._size > 0) {
+            this._heap[0] = this._heap[this._size];
+            this._bubbleDown(0);
+        }
+        return result;
+    };
+    PriorityQueue.prototype.peek = function () {
+        return this._size > 0 ? this._heap[0] : undefined;
+    };
+    PriorityQueue.prototype._bubbleUp = function (index) {
+        while (index > 0) {
+            var parentIndex = Math.floor((index - 1) / 2);
+            if (this._heap[index].priority >= this._heap[parentIndex].priority) {
+                break;
+            }
+            this._swap(index, parentIndex);
+            index = parentIndex;
+        }
+    };
+    PriorityQueue.prototype._bubbleDown = function (index) {
+        while (true) {
+            var minIndex = index;
+            var leftChild = 2 * index + 1;
+            var rightChild = 2 * index + 2;
+            if (leftChild < this._size &&
+                this._heap[leftChild].priority < this._heap[minIndex].priority) {
+                minIndex = leftChild;
+            }
+            if (rightChild < this._size &&
+                this._heap[rightChild].priority < this._heap[minIndex].priority) {
+                minIndex = rightChild;
+            }
+            if (minIndex === index) {
+                break;
+            }
+            this._swap(index, minIndex);
+            index = minIndex;
+        }
+    };
+    PriorityQueue.prototype._swap = function (i, j) {
+        var temp = this._heap[i];
+        this._heap[i] = this._heap[j];
+        this._heap[j] = temp;
+    };
+    return PriorityQueue;
+}());
+export { PriorityQueue };
+
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { Vector2Utils } from '../../../Types/IVector2';
+import { PriorityQueue } from '../../../Utils/PriorityQueue';
+var AStarNode = (function () {
+    function AStarNode(node, gCost, hCost, parent) {
+        if (gCost === void 0) { gCost = 0; }
+        if (hCost === void 0) { hCost = 0; }
+        if (parent === void 0) { parent = null; }
+        this.priority = 0;
+        this.gCost = 0;
+        this.hCost = 0;
+        this.parent = null;
+        this.hash = 0;
+        this.node = node;
+        this.gCost = gCost;
+        this.hCost = hCost;
+        this.priority = gCost + hCost;
+        this.parent = parent;
+        this.hash = Vector2Utils.toHash(node);
+    }
+    AStarNode.prototype.updateCosts = function (gCost, hCost, parent) {
+        if (parent === void 0) { parent = null; }
+        this.gCost = gCost;
+        this.hCost = hCost;
+        this.priority = gCost + hCost;
+        this.parent = parent;
+    };
+    AStarNode.prototype.updateNode = function (node, gCost, hCost, parent) {
+        if (gCost === void 0) { gCost = 0; }
+        if (hCost === void 0) { hCost = 0; }
+        if (parent === void 0) { parent = null; }
+        this.node = node;
+        this.gCost = gCost;
+        this.hCost = hCost;
+        this.priority = gCost + hCost;
+        this.parent = parent;
+        this.hash = Vector2Utils.toHash(node);
+    };
+    AStarNode.prototype.reset = function () {
+        this.node = null;
+        this.priority = 0;
+        this.gCost = 0;
+        this.hCost = 0;
+        this.parent = null;
+        this.hash = 0;
+    };
+    return AStarNode;
+}());
+var AStarPathfinder = (function () {
+    function AStarPathfinder() {
+    }
+    AStarPathfinder._getNode = function (node, gCost, hCost, parent) {
+        if (gCost === void 0) { gCost = 0; }
+        if (hCost === void 0) { hCost = 0; }
+        if (parent === void 0) { parent = null; }
+        var astarNode = this._nodePool.pop();
+        if (!astarNode) {
+            astarNode = new AStarNode(node, gCost, hCost, parent);
+        }
+        else {
+            astarNode.updateNode(node, gCost, hCost, parent);
+        }
+        return astarNode;
+    };
+    AStarPathfinder._recycleNode = function (node) {
+        if (this._nodePool.length < 1000) {
+            node.reset();
+            this._nodePool.push(node);
+        }
+    };
+    AStarPathfinder.search = function (graph, start, goal) {
+        var openSet = new PriorityQueue();
+        var closedSet = new Set();
+        var openSetMap = new Map();
+        var startHash = Vector2Utils.toHash(start);
+        var goalHash = Vector2Utils.toHash(goal);
+        if (startHash === goalHash) {
+            return { found: true, goalNode: this._getNode(start, 0, 0) };
+        }
+        var startNode = this._getNode(start, 0, graph.heuristic(start, goal));
+        openSet.enqueue(startNode);
+        openSetMap.set(startHash, startNode);
+        var goalNode;
+        while (!openSet.isEmpty) {
+            var current = openSet.dequeue();
+            var currentHash = current.hash;
+            openSetMap.delete(currentHash);
+            if (currentHash === goalHash) {
+                goalNode = current;
+                break;
+            }
+            closedSet.add(currentHash);
+            for (var _i = 0, _a = graph.getNeighbors(current.node); _i < _a.length; _i++) {
+                var neighbor = _a[_i];
+                var neighborHash = Vector2Utils.toHash(neighbor);
+                if (closedSet.has(neighborHash)) {
+                    continue;
+                }
+                var tentativeGScore = current.gCost + graph.cost(current.node, neighbor);
+                var existingNode = openSetMap.get(neighborHash);
+                if (existingNode) {
+                    if (tentativeGScore < existingNode.gCost) {
+                        var hCost = existingNode.hCost;
+                        existingNode.updateCosts(tentativeGScore, hCost, current);
+                    }
+                }
+                else {
+                    var hCost = graph.heuristic(neighbor, goal);
+                    var neighborNode = this._getNode(neighbor, tentativeGScore, hCost, current);
+                    openSet.enqueue(neighborNode);
+                    openSetMap.set(neighborHash, neighborNode);
+                }
+            }
+            if (current !== goalNode) {
+                this._recycleNode(current);
+            }
+        }
+        while (!openSet.isEmpty) {
+            var node = openSet.dequeue();
+            if (node !== goalNode) {
+                this._recycleNode(node);
+            }
+        }
+        return { found: !!goalNode, goalNode: goalNode };
+    };
+    AStarPathfinder.searchPath = function (graph, start, goal) {
+        var result = this.search(graph, start, goal);
+        if (!result.found || !result.goalNode) {
+            return [];
+        }
+        return this.reconstructPathFromNode(result.goalNode, start);
+    };
+    AStarPathfinder.reconstructPathFromNode = function (goalNode, start) {
+        this._tempPath.length = 0;
+        var current = goalNode;
+        var startHash = Vector2Utils.toHash(start);
+        while (current) {
+            this._tempPath.unshift(current.node);
+            var currentHash = current.hash;
+            var parent_1 = current.parent;
+            if (currentHash !== startHash) {
+                this._recycleNode(current);
+            }
+            current = parent_1;
+        }
+        return __spreadArray([], this._tempPath, true);
+    };
+    AStarPathfinder.hasPath = function (graph, start, goal) {
+        var result = this.search(graph, start, goal);
+        if (result.goalNode) {
+            this._recycleNode(result.goalNode);
+        }
+        return result.found;
+    };
+    AStarPathfinder.clearPool = function () {
+        this._nodePool.length = 0;
+        this._tempPath.length = 0;
+    };
+    AStarPathfinder.getPoolStats = function () {
+        return {
+            poolSize: this._nodePool.length,
+            maxPoolSize: 1000
+        };
+    };
+    AStarPathfinder._nodePool = [];
+    AStarPathfinder._tempPath = [];
+    return AStarPathfinder;
+}());
+export { AStarPathfinder };
+
+import { Vector2Utils } from '../../../Types/IVector2';
+import { AStarPathfinder } from './AStarPathfinder';
+var AstarGridGraph = (function () {
+    function AstarGridGraph(width, height) {
+        this.dirs = [
+            Vector2Utils.create(1, 0),
+            Vector2Utils.create(0, -1),
+            Vector2Utils.create(-1, 0),
+            Vector2Utils.create(0, 1)
+        ];
+        this.walls = [];
+        this.weightedNodes = [];
+        this.defaultWeight = 1;
+        this.weightedNodeWeight = 5;
+        this._neighbors = new Array(4);
+        this._wallsSet = new Set();
+        this._weightedNodesSet = new Set();
+        this._wallsDirty = true;
+        this._weightedNodesDirty = true;
+        this._width = width;
+        this._height = height;
+    }
+    AstarGridGraph.prototype.addWall = function (wall) {
+        this.walls.push(wall);
+        this._wallsDirty = true;
+    };
+    AstarGridGraph.prototype.addWalls = function (walls) {
+        var _a;
+        (_a = this.walls).push.apply(_a, walls);
+        this._wallsDirty = true;
+    };
+    AstarGridGraph.prototype.clearWalls = function () {
+        this.walls.length = 0;
+        this._wallsSet.clear();
+        this._wallsDirty = false;
+    };
+    AstarGridGraph.prototype.addWeightedNode = function (node) {
+        this.weightedNodes.push(node);
+        this._weightedNodesDirty = true;
+    };
+    AstarGridGraph.prototype.addWeightedNodes = function (nodes) {
+        var _a;
+        (_a = this.weightedNodes).push.apply(_a, nodes);
+        this._weightedNodesDirty = true;
+    };
+    AstarGridGraph.prototype.clearWeightedNodes = function () {
+        this.weightedNodes.length = 0;
+        this._weightedNodesSet.clear();
+        this._weightedNodesDirty = false;
+    };
+    AstarGridGraph.prototype._updateHashSets = function () {
+        if (this._wallsDirty) {
+            this._wallsSet.clear();
+            for (var _i = 0, _a = this.walls; _i < _a.length; _i++) {
+                var wall = _a[_i];
+                this._wallsSet.add(Vector2Utils.toHash(wall));
+            }
+            this._wallsDirty = false;
+        }
+        if (this._weightedNodesDirty) {
+            this._weightedNodesSet.clear();
+            for (var _b = 0, _c = this.weightedNodes; _b < _c.length; _b++) {
+                var node = _c[_b];
+                this._weightedNodesSet.add(Vector2Utils.toHash(node));
+            }
+            this._weightedNodesDirty = false;
+        }
+    };
+    AstarGridGraph.prototype.isNodeInBounds = function (node) {
+        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+    };
+    AstarGridGraph.prototype.isNodePassable = function (node) {
+        this._updateHashSets();
+        return !this._wallsSet.has(Vector2Utils.toHash(node));
+    };
+    AstarGridGraph.prototype.search = function (start, goal) {
+        return AStarPathfinder.hasPath(this, start, goal);
+    };
+    AstarGridGraph.prototype.searchPath = function (start, goal) {
+        return AStarPathfinder.searchPath(this, start, goal);
+    };
+    AstarGridGraph.prototype.getNeighbors = function (node) {
+        this._neighbors.length = 0;
+        for (var _i = 0, _a = this.dirs; _i < _a.length; _i++) {
+            var dir = _a[_i];
+            var next = Vector2Utils.add(node, dir);
+            if (this.isNodeInBounds(next) && this.isNodePassable(next)) {
+                this._neighbors.push(next);
+            }
+        }
+        return this._neighbors;
+    };
+    AstarGridGraph.prototype.cost = function (from, to) {
+        this._updateHashSets();
+        return this._weightedNodesSet.has(Vector2Utils.toHash(to)) ? this.weightedNodeWeight : this.defaultWeight;
+    };
+    AstarGridGraph.prototype.heuristic = function (node, goal) {
+        return Vector2Utils.manhattanDistance(node, goal);
+    };
+    AstarGridGraph.prototype.getStats = function () {
+        this._updateHashSets();
+        return {
+            walls: this.walls.length,
+            weightedNodes: this.weightedNodes.length,
+            gridSize: "".concat(this._width, "x").concat(this._height),
+            wallsSetSize: this._wallsSet.size,
+            weightedNodesSetSize: this._weightedNodesSet.size
+        };
+    };
+    return AstarGridGraph;
+}());
+export { AstarGridGraph };
+
+export {};
+
+import { Vector2Utils } from '../../../Types/IVector2';
+var BreadthFirstPathfinder = (function () {
+    function BreadthFirstPathfinder() {
+    }
+    BreadthFirstPathfinder.search = function (graph, start, goal, cameFrom) {
+        var frontier = [];
+        var visited = new Set();
+        var pathMap = cameFrom || new Map();
+        var startHash = Vector2Utils.toHash(start);
+        var goalHash = Vector2Utils.toHash(goal);
+        if (startHash === goalHash) {
+            return true;
+        }
+        frontier.push(start);
+        visited.add(startHash);
+        while (frontier.length > 0) {
+            var current = frontier.shift();
+            var currentHash = Vector2Utils.toHash(current);
+            if (currentHash === goalHash) {
+                return true;
+            }
+            for (var _i = 0, _a = graph.getNeighbors(current); _i < _a.length; _i++) {
+                var neighbor = _a[_i];
+                var neighborHash = Vector2Utils.toHash(neighbor);
+                if (visited.has(neighborHash)) {
+                    continue;
+                }
+                visited.add(neighborHash);
+                pathMap.set(neighborHash, current);
+                frontier.push(neighbor);
+            }
+        }
+        return false;
+    };
+    BreadthFirstPathfinder.searchPath = function (graph, start, goal) {
+        var cameFrom = new Map();
+        if (this.search(graph, start, goal, cameFrom)) {
+            return this.reconstructPath(cameFrom, start, goal);
+        }
+        return [];
+    };
+    BreadthFirstPathfinder.reconstructPath = function (cameFrom, start, goal) {
+        var path = [];
+        var current = goal;
+        var startHash = Vector2Utils.toHash(start);
+        while (Vector2Utils.toHash(current) !== startHash) {
+            path.unshift(current);
+            var currentHash = Vector2Utils.toHash(current);
+            var parent_1 = cameFrom.get(currentHash);
+            if (!parent_1)
+                break;
+            current = parent_1;
+        }
+        path.unshift(start);
+        return path;
+    };
+    return BreadthFirstPathfinder;
+}());
+export { BreadthFirstPathfinder };
+
+export {};
+
+var UnweightedGraph = (function () {
+    function UnweightedGraph() {
+        this.edges = new Map();
+    }
+    UnweightedGraph.prototype.addEdgesForNode = function (node, neighbors) {
+        this.edges.set(node, neighbors);
+        return this;
+    };
+    UnweightedGraph.prototype.getNeighbors = function (node) {
+        return this.edges.get(node) || [];
+    };
+    return UnweightedGraph;
+}());
+export { UnweightedGraph };
+
+import { Vector2Utils } from '../../../Types/IVector2';
+import { BreadthFirstPathfinder } from './BreadthFirstPathfinder';
+var UnweightedGridGraph = (function () {
+    function UnweightedGridGraph(width, height, allowDiagonalSearch) {
+        if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
+        this.walls = [];
+        this._neighbors = [];
+        this._width = width;
+        this._height = height;
+        this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
+    }
+    UnweightedGridGraph.prototype.isNodeInBounds = function (node) {
+        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+    };
+    UnweightedGridGraph.prototype.isNodePassable = function (node) {
+        return !this.walls.find(function (wall) { return Vector2Utils.equals(wall, node); });
+    };
+    UnweightedGridGraph.prototype.getNeighbors = function (node) {
+        this._neighbors.length = 0;
+        for (var _i = 0, _a = this._dirs; _i < _a.length; _i++) {
+            var dir = _a[_i];
+            var next = Vector2Utils.add(node, dir);
+            if (this.isNodeInBounds(next) && this.isNodePassable(next)) {
+                this._neighbors.push(next);
+            }
+        }
+        return this._neighbors;
+    };
+    UnweightedGridGraph.prototype.searchPath = function (start, goal) {
+        return BreadthFirstPathfinder.searchPath(this, start, goal);
+    };
+    UnweightedGridGraph.prototype.hasPath = function (start, goal) {
+        return BreadthFirstPathfinder.search(this, start, goal);
+    };
+    UnweightedGridGraph.CARDINAL_DIRS = [
+        Vector2Utils.create(1, 0),
+        Vector2Utils.create(0, -1),
+        Vector2Utils.create(-1, 0),
+        Vector2Utils.create(0, 1)
+    ];
+    UnweightedGridGraph.COMPASS_DIRS = [
+        Vector2Utils.create(1, 0),
+        Vector2Utils.create(1, -1),
+        Vector2Utils.create(0, -1),
+        Vector2Utils.create(-1, -1),
+        Vector2Utils.create(-1, 0),
+        Vector2Utils.create(-1, 1),
+        Vector2Utils.create(0, 1),
+        Vector2Utils.create(1, 1),
+    ];
+    return UnweightedGridGraph;
+}());
+export { UnweightedGridGraph };

package/bin/pathfinding.min.js

@@ -0,0 +1 @@
+export{Vector2Utils}from"./Types/IVector2";export{PriorityQueue}from"./Utils/PriorityQueue";export{AStarPathfinder}from"./AI/Pathfinding/AStar/AStarPathfinder";export{AstarGridGraph}from"./AI/Pathfinding/AStar/AstarGridGraph";export{BreadthFirstPathfinder}from"./AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder";export{UnweightedGraph}from"./AI/Pathfinding/BreadthFirst/UnweightedGraph";export{UnweightedGridGraph}from"./AI/Pathfinding/BreadthFirst/UnweightedGridGraph";var t=function(){function t(){}return t.equals=function(t,e){return t.equals?t.equals(e):t.x===e.x&&t.y===e.y},t.create=function(t,e){return{x:t,y:e}},t.clone=function(t){return{x:t.x,y:t.y}},t.add=function(t,e){return{x:t.x+e.x,y:t.y+e.y}},t.manhattanDistance=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},t.distance=function(t,e){var i=t.x-e.x,r=t.y-e.y;return Math.sqrt(i*i+r*r)},t.toHash=function(t){return(t.x+this.MAX_COORD|0)<<16|(t.y+this.MAX_COORD|0)},t.toKey=function(t){return"".concat(t.x,",").concat(t.y)},t.fromHash=function(t){return{x:(t>>16)-this.MAX_COORD,y:(65535&t)-this.MAX_COORD}},t.HASH_MULTIPLIER=73856093,t.MAX_COORD=32767,t}();export{t as Vector2Utils};var e=function(){function t(){this._heap=[],this._size=0}return Object.defineProperty(t.prototype,"size",{get:function(){return this._size},enumerable:!1,configurable:!0}),Object.defineProperty(t.prototype,"isEmpty",{get:function(){return 0===this._size},enumerable:!1,configurable:!0}),t.prototype.clear=function(){this._heap.length=0,this._size=0},t.prototype.enqueue=function(t){this._heap[this._size]=t,this._bubbleUp(this._size),this._size++},t.prototype.dequeue=function(){if(0!==this._size){var t=this._heap[0];return this._size--,this._size>0&&(this._heap[0]=this._heap[this._size],this._bubbleDown(0)),t}},t.prototype.peek=function(){return this._size>0?this._heap[0]:void 0},t.prototype._bubbleUp=function(t){for(;t>0;){var e=Math.floor((t-1)/2);if(this._heap[t].priority>=this._heap[e].priority)break;this._swap(t,e),t=e}},t.prototype._bubbleDown=function(t){for(;;){var e=t,i=2*t+1,r=2*t+2;if(i<this._size&&this._heap[i].priority<this._heap[e].priority&&(e=i),r<this._size&&this._heap[r].priority<this._heap[e].priority&&(e=r),e===t)break;this._swap(t,e),t=e}},t.prototype._swap=function(t,e){var i=this._heap[t];this._heap[t]=this._heap[e],this._heap[e]=i},t}();export{e as PriorityQueue};var i=this&&this.__spreadArray||function(t,e,i){if(i||2===arguments.length)for(var r,s=0,o=e.length;s<o;s++)!r&&s in e||(r||(r=Array.prototype.slice.call(e,0,s)),r[s]=e[s]);return t.concat(r||Array.prototype.slice.call(e))};import{Vector2Utils as t}from"../../../Types/IVector2";import{PriorityQueue as e}from"../../../Utils/PriorityQueue";var r=function(){function e(e,i,r,s){void 0===i&&(i=0),void 0===r&&(r=0),void 0===s&&(s=null),this.priority=0,this.gCost=0,this.hCost=0,this.parent=null,this.hash=0,this.node=e,this.gCost=i,this.hCost=r,this.priority=i+r,this.parent=s,this.hash=t.toHash(e)}return e.prototype.updateCosts=function(t,e,i){void 0===i&&(i=null),this.gCost=t,this.hCost=e,this.priority=t+e,this.parent=i},e.prototype.updateNode=function(e,i,r,s){void 0===i&&(i=0),void 0===r&&(r=0),void 0===s&&(s=null),this.node=e,this.gCost=i,this.hCost=r,this.priority=i+r,this.parent=s,this.hash=t.toHash(e)},e.prototype.reset=function(){this.node=null,this.priority=0,this.gCost=0,this.hCost=0,this.parent=null,this.hash=0},e}(),s=function(){function s(){}return s._getNode=function(t,e,i,s){void 0===e&&(e=0),void 0===i&&(i=0),void 0===s&&(s=null);var o=this._nodePool.pop();return o?o.updateNode(t,e,i,s):o=new r(t,e,i,s),o},s._recycleNode=function(t){this._nodePool.length<1e3&&(t.reset(),this._nodePool.push(t))},s.search=function(i,r,s){var o=new e,h=new Set,n=new Map,a=t.toHash(r),u=t.toHash(s);if(a===u)return{found:!0,goalNode:this._getNode(r,0,0)};var d,p=this._getNode(r,0,i.heuristic(r,s));for(o.enqueue(p),n.set(a,p);!o.isEmpty;){var c=o.dequeue(),l=c.hash;if(n.delete(l),l===u){d=c;break}h.add(l);for(var f=0,_=i.getNeighbors(c.node);f<_.length;f++){var g=_[f],y=t.toHash(g);if(!h.has(y)){var w=c.gCost+i.cost(c.node,g),N=n.get(y);if(N){if(w<N.gCost){var v=N.hCost;N.updateCosts(w,v,c)}}else{v=i.heuristic(g,s);var P=this._getNode(g,w,v,c);o.enqueue(P),n.set(y,P)}}}c!==d&&this._recycleNode(c)}for(;!o.isEmpty;){var S=o.dequeue();S!==d&&this._recycleNode(S)}return{found:!!d,goalNode:d}},s.searchPath=function(t,e,i){var r=this.search(t,e,i);return r.found&&r.goalNode?this.reconstructPathFromNode(r.goalNode,e):[]},s.reconstructPathFromNode=function(e,r){this._tempPath.length=0;for(var s=e,o=t.toHash(r);s;){this._tempPath.unshift(s.node);var h=s.hash,n=s.parent;h!==o&&this._recycleNode(s),s=n}return i([],this._tempPath,!0)},s.hasPath=function(t,e,i){var r=this.search(t,e,i);return r.goalNode&&this._recycleNode(r.goalNode),r.found},s.clearPool=function(){this._nodePool.length=0,this._tempPath.length=0},s.getPoolStats=function(){return{poolSize:this._nodePool.length,maxPoolSize:1e3}},s._nodePool=[],s._tempPath=[],s}();export{s as AStarPathfinder};import{Vector2Utils as t}from"../../../Types/IVector2";import{AStarPathfinder as s}from"./AStarPathfinder";var o=function(){function e(e,i){this.dirs=[t.create(1,0),t.create(0,-1),t.create(-1,0),t.create(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._wallsSet=new Set,this._weightedNodesSet=new Set,this._wallsDirty=!0,this._weightedNodesDirty=!0,this._width=e,this._height=i}return e.prototype.addWall=function(t){this.walls.push(t),this._wallsDirty=!0},e.prototype.addWalls=function(t){var e;(e=this.walls).push.apply(e,t),this._wallsDirty=!0},e.prototype.clearWalls=function(){this.walls.length=0,this._wallsSet.clear(),this._wallsDirty=!1},e.prototype.addWeightedNode=function(t){this.weightedNodes.push(t),this._weightedNodesDirty=!0},e.prototype.addWeightedNodes=function(t){var e;(e=this.weightedNodes).push.apply(e,t),this._weightedNodesDirty=!0},e.prototype.clearWeightedNodes=function(){this.weightedNodes.length=0,this._weightedNodesSet.clear(),this._weightedNodesDirty=!1},e.prototype._updateHashSets=function(){if(this._wallsDirty){this._wallsSet.clear();for(var e=0,i=this.walls;e<i.length;e++){var r=i[e];this._wallsSet.add(t.toHash(r))}this._wallsDirty=!1}if(this._weightedNodesDirty){this._weightedNodesSet.clear();for(var s=0,o=this.weightedNodes;s<o.length;s++){var h=o[s];this._weightedNodesSet.add(t.toHash(h))}this._weightedNodesDirty=!1}},e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(e){return this._updateHashSets(),!this._wallsSet.has(t.toHash(e))},e.prototype.search=function(t,e){return s.hasPath(this,t,e)},e.prototype.searchPath=function(t,e){return s.searchPath(this,t,e)},e.prototype.getNeighbors=function(e){this._neighbors.length=0;for(var i=0,r=this.dirs;i<r.length;i++){var s=r[i],o=t.add(e,s);this.isNodeInBounds(o)&&this.isNodePassable(o)&&this._neighbors.push(o)}return this._neighbors},e.prototype.cost=function(e,i){return this._updateHashSets(),this._weightedNodesSet.has(t.toHash(i))?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(e,i){return t.manhattanDistance(e,i)},e.prototype.getStats=function(){return this._updateHashSets(),{walls:this.walls.length,weightedNodes:this.weightedNodes.length,gridSize:"".concat(this._width,"x").concat(this._height),wallsSetSize:this._wallsSet.size,weightedNodesSetSize:this._weightedNodesSet.size}},e}();export{o as AstarGridGraph};export{};import{Vector2Utils as t}from"../../../Types/IVector2";var h=function(){function e(){}return e.search=function(e,i,r,s){var o=[],h=new Set,n=s||new Map,a=t.toHash(i),u=t.toHash(r);if(a===u)return!0;for(o.push(i),h.add(a);o.length>0;){var d=o.shift();if(t.toHash(d)===u)return!0;for(var p=0,c=e.getNeighbors(d);p<c.length;p++){var l=c[p],f=t.toHash(l);h.has(f)||(h.add(f),n.set(f,d),o.push(l))}}return!1},e.searchPath=function(t,e,i){var r=new Map;return this.search(t,e,i,r)?this.reconstructPath(r,e,i):[]},e.reconstructPath=function(e,i,r){for(var s=[],o=r,h=t.toHash(i);t.toHash(o)!==h;){s.unshift(o);var n=t.toHash(o),a=e.get(n);if(!a)break;o=a}return s.unshift(i),s},e}();export{h as BreadthFirstPathfinder};export{};var n=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)||[]},t}();export{n as UnweightedGraph};import{Vector2Utils as t}from"../../../Types/IVector2";import{BreadthFirstPathfinder as h}from"./BreadthFirstPathfinder";var a=function(){function e(t,i,r){void 0===r&&(r=!1),this.walls=[],this._neighbors=[],this._width=t,this._height=i,this._dirs=r?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(e){return!this.walls.find((function(i){return t.equals(i,e)}))},e.prototype.getNeighbors=function(e){this._neighbors.length=0;for(var i=0,r=this._dirs;i<r.length;i++){var s=r[i],o=t.add(e,s);this.isNodeInBounds(o)&&this.isNodePassable(o)&&this._neighbors.push(o)}return this._neighbors},e.prototype.searchPath=function(t,e){return h.searchPath(this,t,e)},e.prototype.hasPath=function(t,e){return h.search(this,t,e)},e.CARDINAL_DIRS=[t.create(1,0),t.create(0,-1),t.create(-1,0),t.create(0,1)],e.COMPASS_DIRS=[t.create(1,0),t.create(1,-1),t.create(0,-1),t.create(-1,-1),t.create(-1,0),t.create(-1,1),t.create(0,1),t.create(1,1)],e}();export{a as UnweightedGridGraph};