bard-legends-framework 0.12.1 → 1.0.0-rc0

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

@@ -1,129 +0,0 @@
-"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.isEmpty) {
-            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/libraries/grid-algorithms/vector-field-path-finder/vector-field-path-finder.spec.d.ts

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

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

@@ -1,296 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-const vitest_1 = require('vitest');
-const helpers_lib_1 = require('helpers-lib');
-const grid_1 = require('../../data-structures/grid/grid');
-const vector_field_path_finder_1 = require('./vector-field-path-finder');
-(0, vitest_1.describe)('VectorFieldPathFinder', () => {
-  (0, vitest_1.describe)('weight grid', () => {
-    (0, vitest_1.test)('basic 1', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 1, y: 1 }, true);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 0, y: 0 })).toBe(0);
-    });
-    (0, vitest_1.test)('basic 2', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 1, y: 1 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true],
-        [true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 0, y: 0 })).toBe(0);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 1, y: 0 })).toBe(0);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 0, y: 1 })).toBe(0);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 1, y: 1 })).toBe(0);
-    });
-    (0, vitest_1.test)('sample 1', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true],
-        [true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 0, y: 0 })).toBe(0);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 1, y: 0 })).toBe(10);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 0, y: 1 })).toBe(10);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 1, y: 1 })).toBe(14);
-    });
-    (0, vitest_1.test)('sample 2', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 1, y: 1 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [0, 0, 10],
-        [0, 0, 10],
-        [10, 10, 14]
-      ]);
-    });
-    (0, vitest_1.test)('sample 3', () => {
-      const targetArea = {
-        topLeft: { x: 1, y: 1 },
-        bottomRight: { x: 2, y: 2 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [14, 10, 10],
-        [10, 0, 0],
-        [10, 0, 0]
-      ]);
-    });
-    (0, vitest_1.test)('complex 1', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, false, true],
-        [true, true, true],
-        [false, false, true],
-        [false, false, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      const h = pathFinder['getHighestWeight'](availabilityGrid.size);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [0, h, 28],
-        [10, 14, 24],
-        [h, h, 28],
-        [h, h, 38]
-      ]);
-    });
-    (0, vitest_1.test)('complex 2', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 1, y: 1 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true, false, true],
-        [true, true, false, true],
-        [false, false, true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      const h = pathFinder['getHighestWeight'](availabilityGrid.size);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [0, 0, h, 38],
-        [0, 0, h, 28],
-        [h, h, 14, 24]
-      ]);
-    });
-    (0, vitest_1.test)('complex 3', () => {
-      const targetArea = {
-        topLeft: { x: 2, y: 2 },
-        bottomRight: { x: 3, y: 3 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true, false, true],
-        [true, true, false, true],
-        [false, false, true, true],
-        [false, false, true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      const h = pathFinder['getHighestWeight'](availabilityGrid.size);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [28, 24, h, 20],
-        [24, 14, h, 10],
-        [h, h, 0, 0],
-        [h, h, 0, 0]
-      ]);
-    });
-    (0, vitest_1.test)('unreachable area 1', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, false, true, false, true],
-        [true, false, true, false, true],
-        [true, false, false, false, true],
-        [true, false, false, false, true],
-        [true, true, true, true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      const h = pathFinder['getHighestWeight'](availabilityGrid.size);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [0, h, h, h, 108],
-        [10, h, h, h, 98],
-        [20, h, h, h, 88],
-        [30, h, h, h, 78],
-        [40, 44, 54, 64, 74]
-      ]);
-    });
-  });
-  (0, vitest_1.describe)('getDirectionToTarget', () => {
-    (0, vitest_1.test)('sample 1', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true],
-        [true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 1, y: 1 })).toEqual(-helpers_lib_1.Radian.get45);
-    });
-    (0, vitest_1.test)('sample 2', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true, true],
-        [false, true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 2, y: 1 })).toEqual(
-        helpers_lib_1.Radian.vectorToRadian({ x: -2, y: -1 })
-      );
-    });
-    (0, vitest_1.test)('sample 3', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, false, true],
-        [true, false, true],
-        [true, true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 2, y: 0 })).toEqual(helpers_lib_1.Radian.get180);
-    });
-    (0, vitest_1.test)('sample 4', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, false, false],
-        [true, false, false]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 2, y: 0 })).toBeUndefined();
-    });
-  });
-  (0, vitest_1.describe)('edge cases', () => {
-    (0, vitest_1.test)('should create an instance', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 1, y: 1 }, true);
-      (0, vitest_1.expect)(new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid)).toBeTruthy();
-    });
-    (0, vitest_1.test)('should activate unavailable target cells of the target area', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 1, y: 1 }, false);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid'].get({ x: 0, y: 0 })).toBe(0);
-    });
-    (0, vitest_1.test)('should select closest grid cells if the target is outside of the grid', () => {
-      const targetArea = {
-        topLeft: { x: 3, y: -1 },
-        bottomRight: { x: 3, y: 1 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-        [20, 10, 0],
-        [20, 10, 0],
-        [24, 14, 10]
-      ]);
-    });
-    (0, vitest_1.test)('should return undefined if starting position and its neighbors are unreachable', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, false, false],
-        [true, false, false]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 2, y: 1 })).toBeUndefined();
-    });
-    (0, vitest_1.test)('should find the direction if starting position is unreachable but there is a reachable neighbor', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true, false],
-        [true, false, false]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 2, y: 1 })).toEqual(-helpers_lib_1.Radian.get45);
-    });
-    (0, vitest_1.test)('should return undefined if starting point is inside target area', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 1, y: 1 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 2, y: 2 }, true);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 0, y: 0 })).toBeUndefined();
-    });
-    (0, vitest_1.test)('should return closest cell result if starting point is outside of the grid', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createNew({ x: 2, y: 1 }, true);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      (0, vitest_1.expect)(pathFinder.getDirectionToTarget({ x: 2, y: 0 })).toEqual(-helpers_lib_1.Radian.get90);
-    });
-    (0, vitest_1.test)('if average direction is pointing blocked path, it should pick random available direction', () => {
-      const targetArea = {
-        topLeft: { x: 0, y: 0 },
-        bottomRight: { x: 0, y: 0 }
-      };
-      const availabilityGrid = grid_1.Grid.createByValues([
-        [true, true, true],
-        [true, false, true],
-        [true, true, true]
-      ]);
-      const pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-      const result = pathFinder.getDirectionToTarget({ x: 2, y: 2 });
-      (0, vitest_1.expect)(result === -helpers_lib_1.Radian.get90 || result === 0).toBeTruthy();
-    });
-  });
-});
-//# sourceMappingURL=vector-field-path-finder.spec.js.map

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

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