bard-legends-framework 0.9.4 → 0.9.5

package/dist/utilities/libraries/data-structures/grid/grid.spec.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const grid_1 = require("./grid");
+(0, vitest_1.describe)('Grid', () => {
+    let grid;
+    (0, vitest_1.beforeEach)(() => {
+        grid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
+    });
+    (0, vitest_1.test)('should be defined', () => {
+        (0, vitest_1.expect)(grid).toBeDefined();
+    });
+    (0, vitest_1.test)('should set and get values', () => {
+        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
+        (0, vitest_1.expect)(grid.get({ x: 0, y: 0 })).toBeFalsy();
+        (0, vitest_1.expect)(grid.get({ x: 0, y: 1 })).toBeFalsy();
+        (0, vitest_1.expect)(grid.get({ x: 1, y: 0 })).toBeFalsy();
+        (0, vitest_1.expect)(grid.get({ x: 1, y: 1 })).toBeFalsy();
+    });
+    (0, vitest_1.test)('should throw an error if area is outside of the grid', () => {
+        (0, vitest_1.expect)(() => grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 3, y: 3 } }, false)).toThrow();
+    });
+    (0, vitest_1.test)('should crop area outside of the grid 1', () => {
+        (0, vitest_1.expect)(grid.cropPartsOutsideOfTheGrid({ topLeft: { x: -1, y: -1 }, bottomRight: { x: 3, y: 3 } })).toEqual({
+            topLeft: { x: 0, y: 0 },
+            bottomRight: { x: 2, y: 2 }
+        });
+    });
+    (0, vitest_1.test)('should crop area outside of the grid 2', () => {
+        (0, vitest_1.expect)(grid.cropPartsOutsideOfTheGrid({ topLeft: { x: 3, y: 3 }, bottomRight: { x: 4, y: 4 } })).toEqual({
+            topLeft: { x: 2, y: 2 },
+            bottomRight: { x: 2, y: 2 }
+        });
+    });
+    (0, vitest_1.test)('should crop area outside of the grid 2', () => {
+        (0, vitest_1.expect)(grid.cropPartsOutsideOfTheGrid({ topLeft: { x: -1, y: -1 }, bottomRight: { x: -1, y: -1 } })).toEqual({
+            topLeft: { x: 0, y: 0 },
+            bottomRight: { x: 0, y: 0 }
+        });
+    });
+    (0, vitest_1.test)('should check if area is within bounds', () => {
+        (0, vitest_1.expect)(grid.isAreaWithinBounds({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } })).toBeTruthy();
+        (0, vitest_1.expect)(grid.isAreaWithinBounds({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 3, y: 3 } })).toBeFalsy();
+    });
+    (0, vitest_1.test)('should check if point is within bounds', () => {
+        (0, vitest_1.expect)(grid.isPointWithinBounds({ x: 0, y: 0 })).toBeTruthy();
+        (0, vitest_1.expect)(grid.isPointWithinBounds({ x: 1, y: 1 })).toBeTruthy();
+        (0, vitest_1.expect)(grid.isPointWithinBounds({ x: 3, y: 3 })).toBeFalsy();
+    });
+    (0, vitest_1.test)('should set area within bounds', () => {
+        grid.safeSetArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 3, y: 3 } }, false);
+        (0, vitest_1.expect)(grid.get({ x: 0, y: 0 })).toBeFalsy();
+        (0, vitest_1.expect)(grid.get({ x: 0, y: 1 })).toBeFalsy();
+        (0, vitest_1.expect)(grid.get({ x: 1, y: 0 })).toBeFalsy();
+        (0, vitest_1.expect)(grid.get({ x: 1, y: 1 })).toBeFalsy();
+    });
+    (0, vitest_1.test)('should return neighbor positions only adjacent', () => {
+        (0, vitest_1.expect)(grid.getNeighborPositions({ x: 1, y: 1 })).toEqual([
+            { x: 0, y: 1 },
+            { x: 1, y: 0 },
+            { x: 1, y: 2 },
+            { x: 2, y: 1 }
+        ]);
+    });
+    (0, vitest_1.test)('should return neighbor positions with diagonals', () => {
+        (0, vitest_1.expect)(grid.getNeighborPositions({ x: 1, y: 1 }, { includeDiagonals: true })).toEqual([
+            { x: 0, y: 1 },
+            { x: 1, y: 0 },
+            { x: 1, y: 2 },
+            { x: 2, y: 1 },
+            { x: 0, y: 0 },
+            { x: 0, y: 2 },
+            { x: 2, y: 0 },
+            { x: 2, y: 2 }
+        ]);
+    });
+    (0, vitest_1.test)('should return neighbor positions only adjacent at the edge', () => {
+        (0, vitest_1.expect)(grid.getNeighborPositions({ x: 2, y: 2 })).toEqual([
+            { x: 1, y: 2 },
+            { x: 2, y: 1 }
+        ]);
+    });
+    (0, vitest_1.test)('should return neighbor positions at the edge with diagonals', () => {
+        (0, vitest_1.expect)(grid.getNeighborPositions({ x: 0, y: 0 }, { includeDiagonals: true })).toEqual([
+            { x: 0, y: 1 },
+            { x: 1, y: 0 },
+            { x: 1, y: 1 }
+        ]);
+    });
+    (0, vitest_1.test)('should iterate over all values', () => {
+        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
+        let values = [];
+        grid.forEach((value, position) => values.push({ value, position }));
+        (0, vitest_1.expect)(values).toEqual([
+            { value: true, position: { x: 0, y: 0 } },
+            { value: false, position: { x: 1, y: 0 } },
+            { value: true, position: { x: 2, y: 0 } },
+            { value: true, position: { x: 0, y: 1 } },
+            { value: false, position: { x: 1, y: 1 } },
+            { value: true, position: { x: 2, y: 1 } },
+            { value: true, position: { x: 0, y: 2 } },
+            { value: true, position: { x: 1, y: 2 } },
+            { value: true, position: { x: 2, y: 2 } }
+        ]);
+    });
+    (0, vitest_1.test)('should map over all values', () => {
+        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
+        let newGrid = grid.map((value, position) => (position.x + position.y) * (value ? 1 : -1));
+        (0, vitest_1.expect)(newGrid.get({ x: 0, y: 0 })).toBe(0);
+        (0, vitest_1.expect)(newGrid.get({ x: 1, y: 0 })).toBe(-1);
+        (0, vitest_1.expect)(newGrid.get({ x: 2, y: 0 })).toBe(2);
+        (0, vitest_1.expect)(newGrid.get({ x: 0, y: 1 })).toBe(1);
+        (0, vitest_1.expect)(newGrid.get({ x: 1, y: 1 })).toBe(-2);
+        (0, vitest_1.expect)(newGrid.get({ x: 2, y: 1 })).toBe(3);
+        (0, vitest_1.expect)(newGrid.get({ x: 0, y: 2 })).toBe(2);
+        (0, vitest_1.expect)(newGrid.get({ x: 1, y: 2 })).toBe(3);
+        (0, vitest_1.expect)(newGrid.get({ x: 2, y: 2 })).toBe(4);
+        (0, vitest_1.expect)(newGrid.size).toEqual({ x: 3, y: 3 });
+    });
+    (0, vitest_1.test)('should find the neighbor direction from a vector', () => {
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0, y: 1 })).toEqual({ x: 0, y: 1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 1, y: 0 })).toEqual({ x: 1, y: 0 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0, y: -1 })).toEqual({ x: 0, y: -1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: -1, y: 0 })).toEqual({ x: -1, y: 0 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0.5, y: 2 })).toEqual({ x: 0, y: 1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 2, y: -0.5 })).toEqual({ x: 1, y: 0 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0.5, y: -2 })).toEqual({ x: 0, y: -1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: -2, y: -0.5 })).toEqual({ x: -1, y: 0 });
+        let middle = grid_1.Grid.vectorToNeighborDirection({ x: 1, y: 1 });
+        (0, vitest_1.expect)(helpers_lib_1.Vector.isEqual(middle, { x: 0, y: 1 }) || helpers_lib_1.Vector.isEqual(middle, { x: 1, y: 0 })).toBeTruthy();
+    });
+    (0, vitest_1.test)('should find the neighbor direction with diagonals from a vector', () => {
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 0, y: 1 }, { includeDiagonals: true })).toEqual({ x: 0, y: 1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 1, y: 1 }, { includeDiagonals: true })).toEqual({ x: 1, y: 1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: -1, y: -1 }, { includeDiagonals: true })).toEqual({ x: -1, y: -1 });
+        (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection({ x: 2, y: 1 }, { includeDiagonals: true })).toEqual({ x: 1, y: 0 });
+    });
+});
+//# sourceMappingURL=grid.spec.js.map

package/dist/utilities/libraries/grid-algorithms/closest-available-space/closest-available-space.helper.spec.d.ts

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

package/dist/utilities/libraries/grid-algorithms/closest-available-space/closest-available-space.helper.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const closest_available_space_helper_1 = require("./closest-available-space.helper");
+const grid_1 = require("../../data-structures/grid/grid");
+(0, vitest_1.describe)('findClosestAvailableSpace', () => {
+    let grid;
+    (0, vitest_1.beforeEach)(() => {
+        grid = grid_1.Grid.createNew({ x: 10, y: 10 }, true);
+    });
+    (0, vitest_1.test)('should return no change vector if the location is available', () => {
+        let boundingBox = { topLeft: { x: 50, y: 50 }, bottomRight: { x: 60, y: 60 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 0, y: 0 });
+    });
+    (0, vitest_1.test)('should support object positions outside of the world size', () => {
+        let boundingBox = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 5, y: 5 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 5, y: 5 });
+        boundingBox = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 15, y: 15 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 5, y: 5 });
+        boundingBox = { topLeft: { x: 95, y: 95 }, bottomRight: { x: 105, y: 105 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -5, y: -5 });
+        boundingBox = { topLeft: { x: 85, y: 85 }, bottomRight: { x: 105, y: 105 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -5, y: -5 });
+    });
+    (0, vitest_1.test)('should find the no change vector space next to an existing object', () => {
+        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } }, false);
+        let boundingBox = { topLeft: { x: 10, y: 10 }, bottomRight: { x: 20, y: 20 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 0, y: 0 });
+    });
+    (0, vitest_1.test)('should find the closest available space if trying to spawn in occupied space', () => {
+        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } }, false);
+        let boundingBox = { topLeft: { x: 5, y: 5 }, bottomRight: { x: 15, y: 15 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -5, y: 15 });
+    });
+    (0, vitest_1.test)('should find the closest available space if trying to spawn in crowded space', () => {
+        // Crowded space
+        //   0 1 2 3 4 5 6 7 8 9
+        // 0 □ 1 1 1 2 2 □ □ □ □
+        // 1 □ 1 1 1 2 2 □ □ □ □
+        // 2 □ 1 1 1 2 2 □ □ □ □
+        // 3 3 3 3 ■ ■ ■ □ □ □ □
+        // 4 □ □ □ ■ ■ ■ □ □ □ □
+        // 5 □ □ 4 ■ ■ ■ 6 6 6 □
+        // 6 □ □ 4 5 5 5 □ □ □ □
+        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 3, y: 2 } }, false); // 1
+        grid.setArea({ topLeft: { x: 4, y: 0 }, bottomRight: { x: 5, y: 2 } }, false); // 2
+        grid.setArea({ topLeft: { x: 0, y: 3 }, bottomRight: { x: 1, y: 3 } }, false); // 3
+        grid.setArea({ topLeft: { x: 2, y: 5 }, bottomRight: { x: 2, y: 6 } }, false); // 4
+        grid.setArea({ topLeft: { x: 3, y: 6 }, bottomRight: { x: 5, y: 6 } }, false); // 5
+        grid.setArea({ topLeft: { x: 6, y: 5 }, bottomRight: { x: 8, y: 5 } }, false); // 6
+        let boundingBox = { topLeft: { x: 10, y: 20 }, bottomRight: { x: 40, y: 50 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 20, y: 10 });
+    });
+    (0, vitest_1.test)('should not fooled by initial position occupying more space in grid and find narrower gap 1', () => {
+        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 4, y: 3 } }, false);
+        let boundingBox = { topLeft: { x: 4, y: 2 }, bottomRight: { x: 12, y: 20 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: -3, y: -1 });
+    });
+    (0, vitest_1.test)('should not fooled by initial position occupying more space in grid and find narrower gap 2', () => {
+        grid.setArea({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 4, y: 3 } }, false);
+        let boundingBox = { topLeft: { x: -6, y: -8 }, bottomRight: { x: 2, y: 10 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toEqual({ x: 7, y: 9 });
+    });
+    (0, vitest_1.test)('should return undefined if there is no available space', () => {
+        grid.setArea({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 9, y: 9 } }, false);
+        let boundingBox = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } };
+        (0, vitest_1.expect)(closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(grid, boundingBox, 10)).toBeUndefined();
+    });
+});
+//# sourceMappingURL=closest-available-space.helper.spec.js.map

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

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

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const grid_1 = require("../../data-structures/grid/grid");
+const path_finder_1 = require("./path-finder");
+(0, vitest_1.describe)('PATH_FINDER', () => {
+    (0, vitest_1.test)('basic 1', () => {
+        let grid = grid_1.Grid.createByValues([[true]]);
+        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 0, y: 0 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({ directPathAvailable: true, path: [{ x: 0, y: 0 }] });
+    });
+    (0, vitest_1.test)('basic 2', () => {
+        let grid = grid_1.Grid.createByValues([[false]]);
+        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 0, y: 0 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({ directPathAvailable: true, path: [{ x: 0, y: 0 }] });
+    });
+    (0, vitest_1.test)('should give the shortest path without diagonals', () => {
+        let grid = grid_1.Grid.createByValues([
+            [true, true, true, true],
+            [true, false, false, true],
+            [true, false, false, true],
+            [true, false, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: false });
+        (0, vitest_1.expect)(result).toEqual({
+            directPathAvailable: true,
+            path: [
+                { 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 = grid_1.Grid.createByValues([
+            [true, true, true, true],
+            [true, false, false, true],
+            [true, false, false, true],
+            [true, false, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({
+            directPathAvailable: true,
+            path: [
+                { 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 = grid_1.Grid.createByValues([
+            [true, true, true, false],
+            [true, false, false, false],
+            [true, true, false, true],
+            [true, false, true, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({
+            directPathAvailable: true,
+            path: [
+                { 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 = grid_1.Grid.createByValues([
+            [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, { x: 0, y: 0 }, { x: 4, y: 3 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({
+            directPathAvailable: true,
+            path: [
+                { 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 = grid_1.Grid.createByValues([
+            [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, { x: 4, y: 3 }, { x: 0, y: 0 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({
+            directPathAvailable: true,
+            path: [
+                { 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 = grid_1.Grid.createByValues([
+            [true, true, true, false],
+            [true, false, false, false],
+            [true, false, false, false],
+            [true, true, false, true]
+        ]);
+        let result = path_finder_1.PathFinder.findPath(grid, { x: 0, y: 0 }, { x: 3, y: 3 }, { includeDiagonals: true });
+        (0, vitest_1.expect)(result).toEqual({
+            directPathAvailable: false,
+            path: [
+                { x: 0, y: 0 },
+                { x: 0, y: 1 },
+                { x: 0, y: 2 },
+                { x: 1, y: 3 }
+            ]
+        });
+    });
+    /*
+    test('stress test', () => {
+      let size = 800;
+      let centerPos = { x: Math.floor(size / 2), y: Math.floor(size / 2) };
+  
+      let bigGrid = Grid.createNew({ x: size, y: size }, true);
+      for (let x = 0; x < size; x++) {
+        for (let y = 0; y < size; y++) {
+          if (Vector.getDistance(centerPos, { x, y }) < size / 4) {
+            bigGrid.set({ x, y }, false);
+          }
+        }
+      }
+  
+      let start = new Date();
+      PathFinder.findPath(bigGrid, { x: 0, y: 0 }, { x: size - 1, y: size - 1 }, { includeDiagonals: true });
+      let end = new Date();
+  
+      console.info(end.getTime() - start.getTime());
+    });*/
+});
+//# sourceMappingURL=path-finder.spec.js.map

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

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

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

@@ -0,0 +1,232 @@
+"use strict";
+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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 1, y: 1 }, true);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true],
+                [true, true]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true],
+                [true, true]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 1, y: 1 }, bottomRight: { x: 2, y: 2 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, false, true],
+                [true, true, true],
+                [false, false, true],
+                [false, false, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true, false, true],
+                [true, true, false, true],
+                [false, false, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 2, y: 2 }, bottomRight: { x: 3, y: 3 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true, false, true],
+                [true, true, false, true],
+                [false, false, true, true],
+                [false, false, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let 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]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true],
+                [true, true]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true, true],
+                [false, true, true]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, false, true],
+                [true, false, true],
+                [true, true, true]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, false, false],
+                [true, false, false]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 1, y: 1 }, false);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 3, y: -1 }, bottomRight: { x: 3, y: 1 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 3, y: 3 }, true);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, false, false],
+                [true, false, false]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true, false],
+                [true, false, false]
+            ]);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 2, y: 2 }, true);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createNew({ x: 2, y: 1 }, true);
+            let 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', () => {
+            let targetArea = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } };
+            let availabilityGrid = grid_1.Grid.createByValues([
+                [true, true, true],
+                [true, false, true],
+                [true, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let 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/path-finder/path-finder.spec.d.ts

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