bard-legends-framework 0.12.1 → 1.0.0-rc0

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

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_lib_1 = require("helpers-lib");
-const vitest_1 = require("vitest");
-const closest_available_space_helper_1 = require("./closest-available-space.helper");
-(0, vitest_1.describe)('findClosestAvailableSpace', () => {
-    let grid;
-    (0, vitest_1.beforeEach)(() => {
-        grid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(10, 10), defaultValue: 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).toEqual({
-            x: -5,
-            y: -5
-        });
-    });
-    (0, vitest_1.test)('should find the no change vector space next to an existing object', () => {
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).toEqual({
-            x: 0,
-            y: 0
-        });
-    });
-    (0, vitest_1.test)('should find the closest available space if trying to spawn in occupied space', () => {
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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(helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 1, y: 0 }, bottomRight: { x: 3, y: 2 } }), false); // 1
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 4, y: 0 }, bottomRight: { x: 5, y: 2 } }), false); // 2
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 3 }, bottomRight: { x: 1, y: 3 } }), false); // 3
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 2, y: 5 }, bottomRight: { x: 2, y: 6 } }), false); // 4
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 3, y: 6 }, bottomRight: { x: 5, y: 6 } }), false); // 5
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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(helpers_lib_1.Rectangle.fromRect({ 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).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(helpers_lib_1.Rectangle.fromRect({ 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).toEqual({
-            x: 7,
-            y: 9
-        });
-    });
-    (0, vitest_1.test)('should return undefined if there is no available space', () => {
-        grid.setArea(helpers_lib_1.Rectangle.fromRect({ 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, helpers_lib_1.Rectangle.fromRect(boundingBox), 10)?.toVec2()).toBeUndefined();
-    });
-});
-//# sourceMappingURL=closest-available-space.helper.test.js.map

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

@@ -1,8 +0,0 @@
-import { Grid, GridNeighborType, Vector } from 'helpers-lib';
-export interface PathFinderResult {
-    directPathAvailable: boolean;
-    path: Vector[];
-}
-export declare class PathFinder {
-    static findPath(grid: Grid<boolean>, startingPosition: Vector, targetPosition: Vector, type: GridNeighborType): PathFinderResult;
-}

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

@@ -1,98 +0,0 @@
-"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/libraries/grid-algorithms/path-finder/path-finder.spec.d.ts

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

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

@@ -1,169 +0,0 @@
-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', () => {
-    const grid = grid_1.Grid.createByValues([[true]]);
-    const 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', () => {
-    const grid = grid_1.Grid.createByValues([[false]]);
-    const 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', () => {
-    const grid = grid_1.Grid.createByValues([
-      [true, true, true, true],
-      [true, false, false, true],
-      [true, false, false, true],
-      [true, false, false, true]
-    ]);
-    const 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', () => {
-    const grid = grid_1.Grid.createByValues([
-      [true, true, true, true],
-      [true, false, false, true],
-      [true, false, false, true],
-      [true, false, false, true]
-    ]);
-    const 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', () => {
-    const grid = grid_1.Grid.createByValues([
-      [true, true, true, false],
-      [true, false, false, false],
-      [true, true, false, true],
-      [true, false, true, true]
-    ]);
-    const 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', () => {
-    const 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]
-    ]);
-    const 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', () => {
-    const 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]
-    ]);
-    const 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', () => {
-    const grid = grid_1.Grid.createByValues([
-      [true, true, true, false],
-      [true, false, false, false],
-      [true, false, false, false],
-      [true, true, false, true]
-    ]);
-    const 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/path-finder/path-finder.test.d.ts

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

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

@@ -1,155 +0,0 @@
-"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/libraries/grid-algorithms/position-to-grid-position-converter.d.ts

@@ -1,6 +0,0 @@
-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/libraries/grid-algorithms/position-to-grid-position-converter.js

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

@@ -1,18 +0,0 @@
-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;
-}