bard-legends-framework 0.11.0 → 0.12.0

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

@@ -6,13 +6,13 @@ 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);
+        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);
+        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 }]);
     });
@@ -23,7 +23,7 @@ const path_finder_1 = require("./path-finder");
             [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);
+        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 },
@@ -42,7 +42,7 @@ const path_finder_1 = require("./path-finder");
             [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);
+        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 },
@@ -60,7 +60,7 @@ const path_finder_1 = require("./path-finder");
             [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);
+        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 },
@@ -77,7 +77,7 @@ const path_finder_1 = require("./path-finder");
             [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);
+        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 },
@@ -99,7 +99,7 @@ const path_finder_1 = require("./path-finder");
             [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);
+        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 },
@@ -121,7 +121,7 @@ const path_finder_1 = require("./path-finder");
             [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);
+        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 },
@@ -146,7 +146,7 @@ const path_finder_1 = require("./path-finder");
       }
   
       let start = new Date();
-      PathFinder.findPath(bigGrid, Vector.zero, new Vector(-1, -1), GridNeighborType.ALL);
+      PathFinder.findPath(bigGrid, Vector.zero, new Vector(-1, -1), GridNeighborType.All);
       let end = new Date();
   
       console.info(end.getTime() - start.getTime());

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

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

@@ -4,30 +4,30 @@ 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 });
+    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));
+        let targetPositions = this._getAreaPositions(this._availabilityGrid.cropAreaOutsideOfTheGrid(_targetArea));
         targetPositions.forEach(position => {
-            this.weightGrid.set(position, 0);
+            this._weightGrid.set(position, 0);
             queue.add(position);
         });
-        while (!queue.isEmpty) {
+        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 => {
+                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 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);
+                        if (this._availabilityGrid.getOrFail(neighbor.position) && newWeight < neighborsCurrentWeight) {
+                            this._weightGrid.set(neighbor.position, newWeight);
                             queue.add(neighbor.position);
                         }
                     }
@@ -36,45 +36,45 @@ class VectorFieldPathFinder {
         }
     }
     getDirectionToTarget(startingPosition) {
-        if (!startingPosition.isInsideRectangle(this.targetArea)) {
-            startingPosition = this.weightGrid.movePositionInsideGrid(startingPosition);
-            if (this.directionsToTargetCache.has(startingPosition)) {
-                return this.directionsToTargetCache.get(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 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 (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));
+                        let atLeastOneNeighborIsUnavailable = neighborValues.some(neighbor => !this._availabilityGrid.get(neighbor.position));
                         if (atLeastOneNeighborIsUnavailable) {
-                            result = this.getDirectionAwayFromObstacles(neighborValues);
+                            result = this._getDirectionAwayFromObstacles(neighborValues);
                         }
                         else {
-                            result = this.getBestDirectionToTarget(startingPosition, neighborValues);
+                            result = this._getBestDirectionToTarget(startingPosition, neighborValues);
                         }
                     }
                 }
                 else {
-                    result = this.getBestDirectionToTarget(startingPosition, neighborValues);
+                    result = this._getBestDirectionToTarget(startingPosition, neighborValues);
                 }
-                this.directionsToTargetCache.set(startingPosition, result);
+                this._directionsToTargetCache.set(startingPosition, result);
                 return result;
             }
         }
     }
-    getDirectionAwayFromObstacles(neighborDirections) {
+    _getDirectionAwayFromObstacles(neighborDirections) {
         let allAvailableDirections = neighborDirections
-            .filter(neighbor => this.availabilityGrid.get(neighbor.position))
+            .filter(neighbor => this._availabilityGrid.get(neighbor.position))
             .map(neighbor => neighbor.direction.radian);
         return helpers_lib_1.Radian.getAverage(...allAvailableDirections);
     }
-    getBestDirectionToTarget(startingPosition, neighborDirections) {
+    _getBestDirectionToTarget(startingPosition, neighborDirections) {
         let bestDirections = neighborDirections
-            .filter(neighbor => this.weightGrid.getOrFail(neighbor.position) < this.highestWeight)
+            .filter(neighbor => this._weightGrid.getOrFail(neighbor.position) < this._highestWeight)
             .reduce((acc, neighbor) => {
-            let newWeight = this.weightGrid.getOrFail(neighbor.position) + neighbor.distance;
+            let newWeight = this._weightGrid.getOrFail(neighbor.position) + neighbor.distance;
             if (newWeight < acc.bestWeight) {
                 acc.bestDirections = [neighbor.direction];
                 acc.bestWeight = newWeight;
@@ -83,13 +83,13 @@ class VectorFieldPathFinder {
                 acc.bestDirections.push(neighbor.direction);
             }
             return acc;
-        }, { bestDirections: [], bestWeight: this.highestWeight }).bestDirections;
-        return this.getTheResultFromBestDirections(bestDirections, startingPosition);
+        }, { bestDirections: [], bestWeight: this._highestWeight }).bestDirections;
+        return this._getTheResultFromBestDirections(bestDirections, startingPosition);
     }
-    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)) {
+            if (sumVector.isZero() || !this._isNextPositionAvailable(startingPosition, sumVector)) {
                 return helpers_lib_1.Random.pickRandomElement(bestDirections).radian;
             }
             else if (bestDirections.length >= 1) {
@@ -97,18 +97,18 @@ class VectorFieldPathFinder {
             }
         }
     }
-    isNextPositionAvailable(position, direction) {
-        let nextPosition = position.add(this.vectorToNeighborDirection(direction));
-        return this.availabilityGrid.isPointWithinBounds(nextPosition) && this.availabilityGrid.getOrFail(nextPosition);
+    _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 => ({
+    _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) {
+    _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++) {
@@ -117,11 +117,11 @@ class VectorFieldPathFinder {
         }
         return positions;
     }
-    vectorToNeighborDirection(vector) {
+    _vectorToNeighborDirection(vector) {
         let roundedVector = vector.normalize().round();
         return new helpers_lib_1.Vector(roundedVector.x, roundedVector.y);
     }
-    getHighestWeight(size) {
+    _getHighestWeight(size) {
         return (size.x + size.y) * 20;
     }
 }

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

@@ -9,7 +9,7 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
             let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(1, 1), defaultValue: true });
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
         });
         (0, vitest_1.test)('basic 2', () => {
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
@@ -18,10 +18,10 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
                 [true, true]
             ]);
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 0))).toBe(0);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 1))).toBe(0);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 1))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(1, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(0, 1))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(1, 1))).toBe(0);
         });
         (0, vitest_1.test)('sample 1', () => {
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
@@ -30,16 +30,16 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
                 [true, true]
             ]);
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 0))).toBe(10);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 1))).toBe(10);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 1))).toBe(14);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(1, 0))).toBe(10);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(0, 1))).toBe(10);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(1, 1))).toBe(14);
         });
         (0, vitest_1.test)('sample 2', () => {
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
             let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(3, 3), defaultValue: true });
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+            (0, vitest_1.expect)(pathFinder['_weightGrid']['_grid']).toEqual([
                 [0, 0, 10],
                 [0, 0, 10],
                 [10, 10, 14]
@@ -49,7 +49,7 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 1, y: 1 }, bottomRight: { x: 2, y: 2 } });
             let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(3, 3), defaultValue: true });
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+            (0, vitest_1.expect)(pathFinder['_weightGrid']['_grid']).toEqual([
                 [14, 10, 10],
                 [10, 0, 0],
                 [10, 0, 0]
@@ -64,8 +64,8 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
                 [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([
+            let h = pathFinder['_getHighestWeight'](availabilityGrid.size);
+            (0, vitest_1.expect)(pathFinder['_weightGrid']['_grid']).toEqual([
                 [0, h, 28],
                 [10, 14, 24],
                 [h, h, 28],
@@ -80,8 +80,8 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
                 [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([
+            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]
@@ -96,8 +96,8 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
                 [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([
+            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],
@@ -114,8 +114,8 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
                 [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([
+            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],
@@ -173,13 +173,13 @@ const vector_field_path_finder_1 = require("./vector-field-path-finder");
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
             let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(1, 1), defaultValue: false });
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['_weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
         });
         (0, vitest_1.test)('should select closest grid cells if the target is outside of the grid', () => {
             let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 3, y: -1 }, bottomRight: { x: 3, y: 1 } });
             let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(3, 3), defaultValue: true });
             let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+            (0, vitest_1.expect)(pathFinder['_weightGrid']['_grid']).toEqual([
                 [20, 10, 0],
                 [20, 10, 0],
                 [24, 14, 10]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bard-legends-framework",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Bard Legends Framework",
   "main": "dist/index.js",
   "files": [
@@ -25,7 +25,8 @@
     "clean-install": "cls && rm -rf node_modules && rm -rf package-lock.json && npm run i",
     "i": "npm cache clean --force && npm install",
     "pretest": "cls",
-    "test": "vitest run",
+    "test": "vitest run --mode=quick",
+    "test-full": "vitest run",
     "build": "tsc",
     "lint": "biome check . --write --max-diagnostics=1",
     "deploy": "npm i && vitest run && npm run build && npm publish",
@@ -38,12 +39,13 @@
     "reflect-metadata": "0.2.2"
   },
   "peerDependencies": {
-    "actions-lib": "^2.0.0",
-    "helpers-lib": "^1.13.10",
-    "script-engine-lib": "^0.4.3"
+    "actions-lib": "^3.0.0-rc1",
+    "helpers-lib": "^1.14.0",
+    "script-engine-lib": "^1.0.0-rc2"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.4",
+    "@memlab/core": "1.1.43",
     "@types/node": "20.12.11",
     "@types/p2": "0.7.44",
     "rollup-plugin-swc": "0.2.1",