bard-legends-framework 0.12.1 → 1.0.0-rc1

package/dist/utilities/animator/state-animation/visit-disappear-state-animation.test.js

@@ -1,431 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const game_entities_1 = require("../../../game-entities");
-const visit_disappear_state_animation_1 = require("./visit-disappear-state-animation");
-(0, vitest_1.describe)('VisitDisappearStateAnimation', () => {
-    let heap = [];
-    let stateAnimation;
-    (0, vitest_1.beforeEach)(async () => {
-        if (stateAnimation) {
-            stateAnimation.destroy();
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-        }
-        heap = [];
-        stateAnimation = new visit_disappear_state_animation_1.VisitDisappearStateAnimation({ duration: 4 })
-            .onStateChange(state => heap.push(state))
-            .onValueChange(value => heap.push(value))
-            .attachToRoot();
-    });
-    (0, vitest_1.describe)('Appearing', () => {
-        (0, vitest_1.test)('default values', () => {
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: undefined,
-                queuedState: undefined,
-                animationState: 'hidden'
-            });
-        });
-        (0, vitest_1.test)('initial values', () => {
-            stateAnimation.setState('A');
-            (0, vitest_1.expect)(heap).toEqual(['A']);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('animation in the middle', async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(heap).toEqual(['A', 0.25]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.25,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('animation end', async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            (0, vitest_1.expect)(heap).toEqual(['A', 1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('instant once', async () => {
-            stateAnimation.setState('A', { instant: true });
-            (0, vitest_1.expect)(heap).toEqual(['A', 1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('instant twice', async () => {
-            stateAnimation.setState('A', { instant: true });
-            heap = [];
-            stateAnimation.setState('A', { instant: true });
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-    });
-    (0, vitest_1.describe)('Disappearing', () => {
-        (0, vitest_1.beforeEach)(async () => {
-            stateAnimation.setState('A', { instant: true });
-            heap = [];
-        });
-        (0, vitest_1.test)('initial values', async () => {
-            stateAnimation.setState(undefined);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'disappearing'
-            });
-        });
-        (0, vitest_1.test)('animation in the middle', async () => {
-            stateAnimation.setState(undefined);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(heap).toEqual([0.75]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.75,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'disappearing'
-            });
-        });
-        (0, vitest_1.test)('animation end', async () => {
-            stateAnimation.setState(undefined);
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: undefined,
-                queuedState: undefined,
-                animationState: 'hidden'
-            });
-        });
-        (0, vitest_1.test)('instant', async () => {
-            stateAnimation.setState(undefined, { instant: true });
-            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: undefined,
-                queuedState: undefined,
-                animationState: 'hidden'
-            });
-        });
-    });
-    (0, vitest_1.describe)('Cancel appearing', () => {
-        (0, vitest_1.beforeEach)(async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-        });
-        (0, vitest_1.test)('initial values', () => {
-            stateAnimation.setState(undefined);
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.5,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'disappearing'
-            });
-        });
-        (0, vitest_1.test)('animation end', async () => {
-            stateAnimation.setState(undefined);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: undefined,
-                queuedState: undefined,
-                animationState: 'hidden'
-            });
-        });
-        (0, vitest_1.test)('instant', async () => {
-            stateAnimation.setState(undefined, { instant: true });
-            (0, vitest_1.expect)(heap).toEqual([undefined, 0]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: undefined,
-                queuedState: undefined,
-                animationState: 'hidden'
-            });
-        });
-    });
-    (0, vitest_1.describe)('Cancel disappearing', () => {
-        (0, vitest_1.beforeEach)(async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            stateAnimation.setState(undefined);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-        });
-        (0, vitest_1.test)('initial values', () => {
-            stateAnimation.setState('A');
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.5,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('animation end', async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            (0, vitest_1.expect)(heap).toEqual([1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('instant', async () => {
-            stateAnimation.setState('A', { instant: true });
-            (0, vitest_1.expect)(heap).toEqual([1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('callbacks', async () => {
-            let stateChangeCalledWith = 'unset';
-            let valueChangeCalledWith = 'unset';
-            stateAnimation
-                .onStateChange(state => {
-                stateChangeCalledWith = state;
-            })
-                .onValueChange(value => {
-                valueChangeCalledWith = value;
-            });
-            stateAnimation.setState('A');
-            (0, vitest_1.expect)(stateChangeCalledWith).toBe('unset');
-            (0, vitest_1.expect)(valueChangeCalledWith).toBe('unset');
-            stateChangeCalledWith = 'unset';
-            valueChangeCalledWith = 'unset';
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateChangeCalledWith).toBe('unset');
-            (0, vitest_1.expect)(valueChangeCalledWith).toBe(0.75);
-            stateChangeCalledWith = 'unset';
-            valueChangeCalledWith = 'unset';
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(stateChangeCalledWith).toBe('unset');
-            (0, vitest_1.expect)(valueChangeCalledWith).toBe(1);
-        });
-    });
-    (0, vitest_1.describe)('Disappear to change', () => {
-        (0, vitest_1.beforeEach)(async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            heap = [];
-        });
-        (0, vitest_1.test)('initial values', async () => {
-            stateAnimation.setState('B');
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: 'B',
-                animationState: 'disappearToChange'
-            });
-        });
-        (0, vitest_1.test)('dissapear animation in the middle', async () => {
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(heap).toEqual([0.75]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.75,
-                state: 'A',
-                queuedState: 'B',
-                animationState: 'disappearToChange'
-            });
-        });
-        (0, vitest_1.test)('dissapear animation end', async () => {
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            (0, vitest_1.expect)(heap).toEqual(['B', 0]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: 'B',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('appear animation in the middle', async () => {
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(heap).toEqual(['B', 0, 0.25]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.25,
-                state: 'B',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('appear animation end', async () => {
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            (0, vitest_1.expect)(heap).toEqual(['B', 0, 1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'B',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('returning back to the original state', async () => {
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(heap).toEqual([0.75, 1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('edge case, changing the decition back at the moment of re-appearing', async () => {
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(1);
-            (0, vitest_1.expect)(heap).toEqual(['B', 0, 'A', 0.25]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.25,
-                state: 'A',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('instant', async () => {
-            stateAnimation.setState('B', { instant: true });
-            (0, vitest_1.expect)(heap).toEqual(['B', 1]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'B',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-    });
-    (0, vitest_1.describe)('Nullish State', () => {
-        (0, vitest_1.test)('initial values', () => {
-            stateAnimation.setState('');
-            (0, vitest_1.expect)(heap).toEqual(['']);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0,
-                state: '',
-                queuedState: undefined,
-                animationState: 'appearing'
-            });
-        });
-        (0, vitest_1.test)('instant', () => {
-            stateAnimation.setState('', { instant: true });
-            // expect(heap).toEqual(['', 0]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: '',
-                queuedState: undefined,
-                animationState: 'visible'
-            });
-        });
-        (0, vitest_1.test)('Cancel appearing', async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setState('');
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.5,
-                state: 'A',
-                queuedState: '',
-                animationState: 'disappearToChange'
-            });
-        });
-        (0, vitest_1.test)('Cancel disappearing', async () => {
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            stateAnimation.setState(undefined);
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setState('');
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.5,
-                state: 'A',
-                queuedState: '',
-                animationState: 'disappearToChange'
-            });
-        });
-        (0, vitest_1.test)('Disappear to change', () => {
-            stateAnimation.setState('A', { instant: true });
-            heap = [];
-            stateAnimation.setState('');
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 1,
-                state: 'A',
-                queuedState: '',
-                animationState: 'disappearToChange'
-            });
-        });
-        (0, vitest_1.test)('Change disappear to change', async () => {
-            stateAnimation.setState('A', { instant: true });
-            stateAnimation.setState('B');
-            game_entities_1.UpdateCycle.triggerUpdateTick(2);
-            heap = [];
-            stateAnimation.setState('');
-            (0, vitest_1.expect)(heap).toEqual([]);
-            (0, vitest_1.expect)(stateAnimation.currentState).toEqual({
-                value: 0.5,
-                state: 'A',
-                queuedState: '',
-                animationState: 'disappearToChange'
-            });
-        });
-    });
-    (0, vitest_1.describe)('Error Cases:', () => {
-        (0, vitest_1.test)('completion on hidden state', async () => {
-            let consoleErrorSpy = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
-            stateAnimation.setState('A');
-            stateAnimation.setState(undefined);
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            (0, vitest_1.expect)(consoleErrorSpy).not.toBeCalled();
-            consoleErrorSpy.mockRestore();
-        });
-        (0, vitest_1.test)('completion on visible state', async () => {
-            let consoleErrorSpy = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            stateAnimation.setState(undefined);
-            stateAnimation.setState('A');
-            game_entities_1.UpdateCycle.triggerUpdateTick(4);
-            (0, vitest_1.expect)(consoleErrorSpy).not.toBeCalled();
-            consoleErrorSpy.mockRestore();
-        });
-    });
-});
-//# sourceMappingURL=visit-disappear-state-animation.test.js.map

package/dist/utilities/data-structures/vector-set/vector-set.d.ts

@@ -1,7 +0,0 @@
-import { Vector } from 'helpers-lib';
-export declare class VectorSet {
-    private _values;
-    add(vector: Vector): void;
-    has(vector: Vector): boolean;
-    delete(vector: Vector): boolean;
-}

package/dist/utilities/data-structures/vector-set/vector-set.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorSet = void 0;
-class VectorSet {
-    constructor() {
-        this._values = new Map();
-    }
-    add(vector) {
-        let set = this._values.get(vector.x);
-        if (!set) {
-            set = new Set();
-            this._values.set(vector.x, set);
-        }
-        set.add(vector.y);
-    }
-    has(vector) {
-        let set = this._values.get(vector.x);
-        return set ? set.has(vector.y) : false;
-    }
-    delete(vector) {
-        let set = this._values.get(vector.x);
-        return set ? set.delete(vector.y) : false;
-    }
-}
-exports.VectorSet = VectorSet;
-//# sourceMappingURL=vector-set.js.map

package/dist/utilities/delta-time/delta-time.d.ts

@@ -1,3 +0,0 @@
-export declare class DeltaTime {
-    static adjustMultiplier(multiplier: number, delta: number): number;
-}

package/dist/utilities/delta-time/delta-time.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeltaTime = void 0;
-class DeltaTime {
-    static adjustMultiplier(multiplier, delta) {
-        return Math.pow(multiplier, delta);
-    }
-}
-exports.DeltaTime = DeltaTime;
-//# sourceMappingURL=delta-time.js.map

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

@@ -1,6 +0,0 @@
-import { Grid, Rectangle, Vector } from 'helpers-lib';
-export declare class ClosestAvailableSpaceHelper {
-    static findByConvertingGridSpace(grid: Grid<boolean>, boundingBox: Rectangle, cellSize: number): Vector | undefined;
-    static find(availabilityGrid: Grid<boolean>, desiredPosition: Vector, objectSize: Vector): Vector | undefined;
-    private static _canPlaceObject;
-}

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

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClosestAvailableSpaceHelper = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const vector_set_1 = require("../../data-structures/vector-set/vector-set");
-const position_to_grid_position_converter_1 = require("../position-to-grid-position-converter");
-class ClosestAvailableSpaceHelper {
-    static findByConvertingGridSpace(grid, boundingBox, cellSize) {
-        let objectGridSize = new helpers_lib_1.Vector(Math.ceil(boundingBox.size.x / cellSize) - 1, Math.ceil(boundingBox.size.y / cellSize) - 1);
-        let objectGridArea = position_to_grid_position_converter_1.PositionToGridPositionConverter.areaToGridArea(boundingBox, cellSize);
-        if (this._canPlaceObject(grid, objectGridArea)) {
-            return helpers_lib_1.Vector.zero;
-        }
-        let movePointInsideGrid = grid.movePositionInsideGrid(objectGridArea.topLeft);
-        let change = helpers_lib_1.Vector.fromTo(objectGridArea.topLeft, movePointInsideGrid);
-        let relativeGridSpace = this.find(grid, movePointInsideGrid, objectGridSize);
-        if (relativeGridSpace) {
-            let totalChange = relativeGridSpace.add(change);
-            let distanceToTopLeftGridCorner = helpers_lib_1.Vector.fromTo(objectGridArea.topLeft.multiplyNumber(cellSize), boundingBox.topLeft);
-            return new helpers_lib_1.Vector(totalChange.x * cellSize + ((objectGridSize.x + 1) * cellSize - boundingBox.size.x) / 2 - distanceToTopLeftGridCorner.x, totalChange.y * cellSize + ((objectGridSize.y + 1) * cellSize - boundingBox.size.y) / 2 - distanceToTopLeftGridCorner.y);
-        }
-    }
-    static find(availabilityGrid, desiredPosition, objectSize) {
-        let closedPositions = new vector_set_1.VectorSet();
-        let queue = new helpers_lib_1.Queue(desiredPosition);
-        while (queue.notEmpty) {
-            let currentPoint = queue.pop();
-            closedPositions.add(currentPoint);
-            let currentArea = new helpers_lib_1.Rectangle(currentPoint, currentPoint.add(objectSize));
-            if (this._canPlaceObject(availabilityGrid, currentArea)) {
-                return helpers_lib_1.Vector.fromTo(desiredPosition, currentPoint);
-            }
-            availabilityGrid.getNeighborPositions(currentPoint, helpers_lib_1.GridNeighborType.Ortogonal).forEach(nextPoint => {
-                if (!closedPositions.has(nextPoint)) {
-                    queue.add(nextPoint);
-                }
-            });
-        }
-    }
-    static _canPlaceObject(grid, area) {
-        if (!grid.isAreaWithinBounds(area)) {
-            return false;
-        }
-        for (let y = area.topLeft.y; y <= area.bottomRight.y; y++) {
-            for (let x = area.topLeft.x; x <= area.bottomRight.x; x++) {
-                if (!grid.get(new helpers_lib_1.Vector(x, y))) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-}
-exports.ClosestAvailableSpaceHelper = ClosestAvailableSpaceHelper;
-//# sourceMappingURL=closest-available-space.helper.js.map

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

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

package/dist/utilities/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/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;
-}