bard-legends-framework 0.10.9 → 0.12.0

package/dist/utilities/grid-algorithms/path-finder/path-finder.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathFinder = void 0;
+const helpers_lib_1 = require("helpers-lib");
+class PathfinderNode {
+    constructor(position, distanceFromStart, distanceToEnd, parent = undefined) {
+        this.position = position;
+        this.distanceFromStart = distanceFromStart;
+        this.distanceToEnd = distanceToEnd;
+        this.parent = parent;
+        this.closed = false;
+    }
+    get pathLength() {
+        return this.distanceFromStart + this.distanceToEnd;
+    }
+    isEqual(targetPosition) {
+        return helpers_lib_1.Vector.isEqual(this.position, targetPosition);
+    }
+    createSolutionPath(directPathAvailable) {
+        let path = [this.position];
+        let current = this.parent;
+        while (current !== undefined) {
+            path.push(current.position);
+            current = current.parent;
+        }
+        path.reverse();
+        return { directPathAvailable, path };
+    }
+    getDistance(targetPosition) {
+        return this.position.getDistance(targetPosition);
+    }
+}
+class PathfinderGrid {
+    constructor(_grid, _startingPosition) {
+        this._grid = _grid;
+        this._startingPosition = _startingPosition;
+        this._openMinBinaryHeap = new helpers_lib_1.BinaryHeap('min');
+        this._closedNodes = [];
+        this._nodes = new helpers_lib_1.Grid({ size: _grid.size, defaultValue: undefined });
+        let startingNode = new PathfinderNode(this._startingPosition, 0, Number.MAX_SAFE_INTEGER);
+        this._openMinBinaryHeap.add(startingNode.pathLength, startingNode);
+    }
+    get hasOpenNodes() {
+        return this._openMinBinaryHeap.size > 0;
+    }
+    getNeighbors(node, type) {
+        return this._grid
+            .getNeighborPositions(node.position, type)
+            .filter(neighborPosition => this._grid.get(neighborPosition))
+            .map(neighborPosition => this._nodes.get(neighborPosition) || this._createNewNode(neighborPosition));
+    }
+    popLowestPathCostNode() {
+        let lowestPathNode = this._openMinBinaryHeap.pop();
+        this._openMinBinaryHeap.delete(lowestPathNode);
+        lowestPathNode.closed = true;
+        this._closedNodes.push(lowestPathNode);
+        return lowestPathNode;
+    }
+    changeNodeCost(node, distanceFromStart, targetPosition, newParent) {
+        this._openMinBinaryHeap.delete(node);
+        node.distanceFromStart = distanceFromStart;
+        node.distanceToEnd = node.getDistance(targetPosition);
+        node.parent = newParent;
+        this._openMinBinaryHeap.add(node.pathLength, node);
+    }
+    getBestClosedNode() {
+        return this._closedNodes.reduce((prev, current) => (prev.distanceToEnd < current.distanceToEnd ? prev : current));
+    }
+    _createNewNode(position) {
+        let node = new PathfinderNode(position, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        this._nodes.set(position, node);
+        this._openMinBinaryHeap.add(node.pathLength, node);
+        return node;
+    }
+}
+class PathFinder {
+    static findPath(grid, startingPosition, targetPosition, type) {
+        let pathfinderGrid = new PathfinderGrid(grid, startingPosition);
+        while (pathfinderGrid.hasOpenNodes) {
+            let currentNode = pathfinderGrid.popLowestPathCostNode();
+            if (currentNode.isEqual(targetPosition)) {
+                return currentNode.createSolutionPath(true);
+            }
+            let neighbors = pathfinderGrid.getNeighbors(currentNode, type);
+            for (let neighbor of neighbors) {
+                if (!neighbor.closed) {
+                    let distanceFromStart = currentNode.distanceFromStart + currentNode.getDistance(neighbor.position);
+                    if (distanceFromStart < neighbor.distanceFromStart) {
+                        pathfinderGrid.changeNodeCost(neighbor, distanceFromStart, targetPosition, currentNode);
+                    }
+                }
+            }
+        }
+        return pathfinderGrid.getBestClosedNode().createSolutionPath(false);
+    }
+}
+exports.PathFinder = PathFinder;
+//# sourceMappingURL=path-finder.js.map

package/dist/utilities/grid-algorithms/path-finder/path-finder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/grid-algorithms/path-finder/path-finder.test.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const path_finder_1 = require("./path-finder");
+(0, vitest_1.describe)('PATH_FINDER', () => {
+    (0, vitest_1.test)('basic 1', () => {
+        let grid = new helpers_lib_1.Grid([[true]]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, helpers_lib_1.Vector.zero, helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([{ x: 0, y: 0 }]);
+    });
+    (0, vitest_1.test)('basic 2', () => {
+        let grid = new helpers_lib_1.Grid([[false]]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, helpers_lib_1.Vector.zero, helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([{ x: 0, y: 0 }]);
+    });
+    (0, vitest_1.test)('should give the shortest path without diagonals', () => {
+        let grid = new helpers_lib_1.Grid([
+            [true, true, true, true],
+            [true, false, false, true],
+            [true, false, false, true],
+            [true, false, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, new helpers_lib_1.Vector(3, 3), helpers_lib_1.GridNeighborType.Ortogonal);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([
+            { x: 0, y: 0 },
+            { x: 1, y: 0 },
+            { x: 2, y: 0 },
+            { x: 3, y: 0 },
+            { x: 3, y: 1 },
+            { x: 3, y: 2 },
+            { x: 3, y: 3 }
+        ]);
+    });
+    (0, vitest_1.test)('should give the shortest path 1', () => {
+        let grid = new helpers_lib_1.Grid([
+            [true, true, true, true],
+            [true, false, false, true],
+            [true, false, false, true],
+            [true, false, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, new helpers_lib_1.Vector(3, 3), helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([
+            { x: 0, y: 0 },
+            { x: 1, y: 0 },
+            { x: 2, y: 0 },
+            { x: 3, y: 1 },
+            { x: 3, y: 2 },
+            { x: 3, y: 3 }
+        ]);
+    });
+    (0, vitest_1.test)('should give the shortest path 2', () => {
+        let grid = new helpers_lib_1.Grid([
+            [true, true, true, false],
+            [true, false, false, false],
+            [true, true, false, true],
+            [true, false, true, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, new helpers_lib_1.Vector(3, 3), helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([
+            { x: 0, y: 0 },
+            { x: 0, y: 1 },
+            { x: 1, y: 2 },
+            { x: 2, y: 3 },
+            { x: 3, y: 3 }
+        ]);
+    });
+    (0, vitest_1.test)('should give the shortest path 3', () => {
+        let grid = new helpers_lib_1.Grid([
+            [true, false, false, true, false],
+            [true, false, true, false, true],
+            [true, false, true, false, true],
+            [false, true, false, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, new helpers_lib_1.Vector(4, 3), helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([
+            { x: 0, y: 0 },
+            { x: 0, y: 1 },
+            { x: 0, y: 2 },
+            { x: 1, y: 3 },
+            { x: 2, y: 2 },
+            { x: 2, y: 1 },
+            { x: 3, y: 0 },
+            { x: 4, y: 1 },
+            { x: 4, y: 2 },
+            { x: 4, y: 3 }
+        ]);
+    });
+    (0, vitest_1.test)('should give the shortest path backwards 3', () => {
+        let grid = new helpers_lib_1.Grid([
+            [true, false, false, true, false],
+            [true, false, true, false, true],
+            [true, false, true, false, true],
+            [false, true, false, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, new helpers_lib_1.Vector(4, 3), helpers_lib_1.Vector.zero, helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(true);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([
+            { x: 4, y: 3 },
+            { x: 4, y: 2 },
+            { x: 4, y: 1 },
+            { x: 3, y: 0 },
+            { x: 2, y: 1 },
+            { x: 2, y: 2 },
+            { x: 1, y: 3 },
+            { x: 0, y: 2 },
+            { x: 0, y: 1 },
+            { x: 0, y: 0 }
+        ]);
+    });
+    (0, vitest_1.test)('should give the shortest path to closest position', () => {
+        let grid = new helpers_lib_1.Grid([
+            [true, true, true, false],
+            [true, false, false, false],
+            [true, false, false, false],
+            [true, true, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, helpers_lib_1.Vector.zero, new helpers_lib_1.Vector(3, 3), helpers_lib_1.GridNeighborType.All);
+        (0, vitest_1.expect)(result.directPathAvailable).toBe(false);
+        (0, vitest_1.expect)(result.path.map(value => value.toVec2())).toEqual([
+            { x: 0, y: 0 },
+            { x: 0, y: 1 },
+            { x: 0, y: 2 },
+            { x: 1, y: 3 }
+        ]);
+    });
+    /*
+    test('stress test', () => {
+      let size = 800;
+      let centerPos = new Vector(Math.floor(size / 2), Math.floor(size / 2));
+  
+      let bigGrid = new Grid({ size: new Vector(size, size), defaultValue: true });
+      for (let x = 0; x < size; x++) {
+        for (let y = 0; y < size; y++) {
+          let vector = new Vector(x, y);
+          if (centerPos.getDistance(vector) < size / 4) {
+            bigGrid.set(vector, false);
+          }
+        }
+      }
+  
+      let start = new Date();
+      PathFinder.findPath(bigGrid, Vector.zero, new Vector(-1, -1), GridNeighborType.All);
+      let end = new Date();
+  
+      console.info(end.getTime() - start.getTime());
+    });*/
+});
+//# sourceMappingURL=path-finder.test.js.map

package/dist/utilities/grid-algorithms/position-to-grid-position-converter.d.ts

@@ -0,0 +1,6 @@
+import { Rectangle, Vector } from 'helpers-lib';
+export declare class PositionToGridPositionConverter {
+    static areaToGridArea(boundingBox: Rectangle, cellSize: number): Rectangle;
+    static positionToGridPosition(point: Vector, cellSize: number): Vector;
+    static gridPositionToPosition(gridPosition: Vector, cellSize: number): Vector;
+}

package/dist/utilities/grid-algorithms/position-to-grid-position-converter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionToGridPositionConverter = void 0;
+const helpers_lib_1 = require("helpers-lib");
+class PositionToGridPositionConverter {
+    static areaToGridArea(boundingBox, cellSize) {
+        return new helpers_lib_1.Rectangle(this.positionToGridPosition(boundingBox.topLeft, cellSize), this.positionToGridPosition(boundingBox.bottomRight, cellSize));
+    }
+    static positionToGridPosition(point, cellSize) {
+        return point.divideNumber(cellSize).floor();
+    }
+    static gridPositionToPosition(gridPosition, cellSize) {
+        return gridPosition.add(new helpers_lib_1.Vector(0.5, 0.5)).multiplyNumber(cellSize);
+    }
+}
+exports.PositionToGridPositionConverter = PositionToGridPositionConverter;
+//# sourceMappingURL=position-to-grid-position-converter.js.map

package/dist/utilities/grid-algorithms/vector-field-path-finder/vector-field-path-finder.d.ts

@@ -0,0 +1,18 @@
+import { Grid, Radian, Rectangle, Vector } from 'helpers-lib';
+export declare class VectorFieldPathFinder {
+    private _targetArea;
+    private _availabilityGrid;
+    private _weightGrid;
+    private _directionsToTargetCache;
+    private _highestWeight;
+    constructor(_targetArea: Rectangle, _availabilityGrid: Grid<boolean>);
+    getDirectionToTarget(startingPosition: Vector): Radian | undefined;
+    private _getDirectionAwayFromObstacles;
+    private _getBestDirectionToTarget;
+    private _getTheResultFromBestDirections;
+    private _isNextPositionAvailable;
+    private _getNeighborValues;
+    private _getAreaPositions;
+    private _vectorToNeighborDirection;
+    private _getHighestWeight;
+}

package/dist/utilities/grid-algorithms/vector-field-path-finder/vector-field-path-finder.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorFieldPathFinder = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const vector_set_1 = require("../../data-structures/vector-set/vector-set");
+class VectorFieldPathFinder {
+    constructor(_targetArea, _availabilityGrid) {
+        this._targetArea = _targetArea;
+        this._availabilityGrid = _availabilityGrid;
+        this._highestWeight = this._getHighestWeight(this._availabilityGrid.size);
+        this._weightGrid = new helpers_lib_1.Grid({ size: this._availabilityGrid.size, defaultValue: this._highestWeight });
+        this._directionsToTargetCache = new helpers_lib_1.Grid({ size: this._availabilityGrid.size, defaultValue: undefined });
+        let closedPositions = new vector_set_1.VectorSet();
+        let queue = new helpers_lib_1.Queue();
+        let targetPositions = this._getAreaPositions(this._availabilityGrid.cropAreaOutsideOfTheGrid(_targetArea));
+        targetPositions.forEach(position => {
+            this._weightGrid.set(position, 0);
+            queue.add(position);
+        });
+        while (queue.notEmpty) {
+            let currentPoint = queue.pop();
+            if (!closedPositions.has(currentPoint)) {
+                closedPositions.add(currentPoint);
+                let currentWeight = this._weightGrid.getOrFail(currentPoint);
+                this._getNeighborValues(currentPoint, this._availabilityGrid).forEach(neighbor => {
+                    if (!closedPositions.has(neighbor.position)) {
+                        let neighborsCurrentWeight = this._weightGrid.getOrFail(neighbor.position);
+                        let newWeight = currentWeight + neighbor.distance;
+                        if (this._availabilityGrid.getOrFail(neighbor.position) && newWeight < neighborsCurrentWeight) {
+                            this._weightGrid.set(neighbor.position, newWeight);
+                            queue.add(neighbor.position);
+                        }
+                    }
+                });
+            }
+        }
+    }
+    getDirectionToTarget(startingPosition) {
+        if (!startingPosition.isInsideRectangle(this._targetArea)) {
+            startingPosition = this._weightGrid.movePositionInsideGrid(startingPosition);
+            if (this._directionsToTargetCache.has(startingPosition)) {
+                return this._directionsToTargetCache.get(startingPosition);
+            }
+            else {
+                let neighborValues = this._getNeighborValues(startingPosition, this._availabilityGrid);
+                let result;
+                if (this._weightGrid.getOrFail(startingPosition) >= this._highestWeight) {
+                    let atLeastOneNeighborIsAvailable = neighborValues.some(neighbor => this._availabilityGrid.get(neighbor.position));
+                    if (atLeastOneNeighborIsAvailable) {
+                        let atLeastOneNeighborIsUnavailable = neighborValues.some(neighbor => !this._availabilityGrid.get(neighbor.position));
+                        if (atLeastOneNeighborIsUnavailable) {
+                            result = this._getDirectionAwayFromObstacles(neighborValues);
+                        }
+                        else {
+                            result = this._getBestDirectionToTarget(startingPosition, neighborValues);
+                        }
+                    }
+                }
+                else {
+                    result = this._getBestDirectionToTarget(startingPosition, neighborValues);
+                }
+                this._directionsToTargetCache.set(startingPosition, result);
+                return result;
+            }
+        }
+    }
+    _getDirectionAwayFromObstacles(neighborDirections) {
+        let allAvailableDirections = neighborDirections
+            .filter(neighbor => this._availabilityGrid.get(neighbor.position))
+            .map(neighbor => neighbor.direction.radian);
+        return helpers_lib_1.Radian.getAverage(...allAvailableDirections);
+    }
+    _getBestDirectionToTarget(startingPosition, neighborDirections) {
+        let bestDirections = neighborDirections
+            .filter(neighbor => this._weightGrid.getOrFail(neighbor.position) < this._highestWeight)
+            .reduce((acc, neighbor) => {
+            let newWeight = this._weightGrid.getOrFail(neighbor.position) + neighbor.distance;
+            if (newWeight < acc.bestWeight) {
+                acc.bestDirections = [neighbor.direction];
+                acc.bestWeight = newWeight;
+            }
+            else if (newWeight === acc.bestWeight) {
+                acc.bestDirections.push(neighbor.direction);
+            }
+            return acc;
+        }, { bestDirections: [], bestWeight: this._highestWeight }).bestDirections;
+        return this._getTheResultFromBestDirections(bestDirections, startingPosition);
+    }
+    _getTheResultFromBestDirections(bestDirections, startingPosition) {
+        if (bestDirections.length > 0) {
+            let sumVector = bestDirections.reduce((acc, direction) => acc.add(direction), helpers_lib_1.Vector.zero);
+            if (sumVector.isZero() || !this._isNextPositionAvailable(startingPosition, sumVector)) {
+                return helpers_lib_1.Random.pickRandomElement(bestDirections).radian;
+            }
+            else if (bestDirections.length >= 1) {
+                return sumVector.radian;
+            }
+        }
+    }
+    _isNextPositionAvailable(position, direction) {
+        let nextPosition = position.add(this._vectorToNeighborDirection(direction));
+        return this._availabilityGrid.isPointWithinBounds(nextPosition) && this._availabilityGrid.getOrFail(nextPosition);
+    }
+    _getNeighborValues(position, grid) {
+        return this._weightGrid.getNeighborDirections(position, helpers_lib_1.GridNeighborType.All).map(neighborDirection => ({
+            position: position.add(neighborDirection),
+            direction: neighborDirection,
+            distance: neighborDirection.x !== 0 && neighborDirection.y !== 0 ? 14 : 10
+        }));
+    }
+    _getAreaPositions(area) {
+        let positions = [];
+        for (let y = area.topLeft.y; y <= area.bottomRight.y; y++) {
+            for (let x = area.topLeft.x; x <= area.bottomRight.x; x++) {
+                positions.push(new helpers_lib_1.Vector(x, y));
+            }
+        }
+        return positions;
+    }
+    _vectorToNeighborDirection(vector) {
+        let roundedVector = vector.normalize().round();
+        return new helpers_lib_1.Vector(roundedVector.x, roundedVector.y);
+    }
+    _getHighestWeight(size) {
+        return (size.x + size.y) * 20;
+    }
+}
+exports.VectorFieldPathFinder = VectorFieldPathFinder;
+//# sourceMappingURL=vector-field-path-finder.js.map

package/dist/utilities/grid-algorithms/vector-field-path-finder/vector-field-path-finder.test.d.ts

@@ -0,0 +1 @@
+export {};