bard-legends-framework 0.12.0 → 1.0.0-rc0

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

@@ -1,220 +0,0 @@
-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(new helpers_lib_1.Vector(3, 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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(1, 1)), false);
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 0))).toBeFalsy();
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 1))).toBeFalsy();
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 0))).toBeFalsy();
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 1))).toBeFalsy();
-  });
-  (0, vitest_1.test)('should throw an error if area is outside of the grid', () => {
-    (0, vitest_1.expect)(() =>
-      grid.setArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)), false)
-    ).toThrow();
-  });
-  (0, vitest_1.test)('should crop area outside of the grid 1', () => {
-    (0, vitest_1.expect)(
-      grid
-        .cropPartsOutsideOfTheGrid(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(-1, -1), new helpers_lib_1.Vector(3, 3)))
-        .toRect()
-    ).toStrictEqual({
-      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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(3, 3), new helpers_lib_1.Vector(4, 4)))
-        .toRect()
-    ).toStrictEqual({
-      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(
-          new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(-1, -1), new helpers_lib_1.Vector(-1, -1))
-        )
-        .toRect()
-    ).toStrictEqual({
-      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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(1, 1)))
-    ).toBeTruthy();
-    (0, vitest_1.expect)(
-      grid.isAreaWithinBounds(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)))
-    ).toBeFalsy();
-  });
-  (0, vitest_1.test)('should check if point is within bounds', () => {
-    (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(0, 0))).toBeTruthy();
-    (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(1, 1))).toBeTruthy();
-    (0, vitest_1.expect)(grid.isPointWithinBounds(new helpers_lib_1.Vector(3, 3))).toBeFalsy();
-  });
-  (0, vitest_1.test)('should set area within bounds', () => {
-    grid.safeSetArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(0, 0), new helpers_lib_1.Vector(3, 3)), false);
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 0))).toBeFalsy();
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(0, 1))).toBeFalsy();
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 0))).toBeFalsy();
-    (0, vitest_1.expect)(grid.get(new helpers_lib_1.Vector(1, 1))).toBeFalsy();
-  });
-  (0, vitest_1.test)('should return neighbor positions only adjacent', () => {
-    (0, vitest_1.expect)(grid.getNeighborPositions(new helpers_lib_1.Vector(1, 1)).map(item => item.toVec2())).toStrictEqual([
-      { 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(new helpers_lib_1.Vector(1, 1), {
-          includeDiagonals: true
-        })
-        .map(item => item.toVec2())
-    ).toStrictEqual([
-      { 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(new helpers_lib_1.Vector(2, 2)).map(item => item.toVec2())).toStrictEqual([
-      { 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(new helpers_lib_1.Vector(0, 0), {
-          includeDiagonals: true
-        })
-        .map(item => item.toVec2())
-    ).toStrictEqual([
-      { x: 0, y: 1 },
-      { x: 1, y: 0 },
-      { x: 1, y: 1 }
-    ]);
-  });
-  (0, vitest_1.test)('should iterate over all values', () => {
-    grid.setArea(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(1, 0), new helpers_lib_1.Vector(1, 1)), false);
-    const values = [];
-    grid.forEach((value, position) => values.push({ value, position }));
-    (0, vitest_1.expect)(
-      values.map(item => ({
-        value: item.value,
-        position: item.position.toVec2()
-      }))
-    ).toStrictEqual([
-      { 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(new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(1, 0), new helpers_lib_1.Vector(1, 1)), false);
-    const newGrid = grid.map((value, position) => (position.x + position.y) * (value ? 1 : -1));
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 0))).toBe(0);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 0))).toBe(-1);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 0))).toBe(2);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 1))).toBe(1);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 1))).toBe(-2);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 1))).toBe(3);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(0, 2))).toBe(2);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(1, 2))).toBe(3);
-    (0, vitest_1.expect)(newGrid.get(new helpers_lib_1.Vector(2, 2))).toBe(4);
-    (0, vitest_1.expect)(newGrid.size.toVec2()).toStrictEqual({ x: 3, y: 3 });
-  });
-  (0, vitest_1.test)('should find the neighbor direction from a vector', () => {
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, 1)).toVec2()).toStrictEqual({
-      x: 0,
-      y: 1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 0)).toVec2()).toStrictEqual({
-      x: 1,
-      y: 0
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, -1)).toVec2()).toStrictEqual({
-      x: 0,
-      y: -1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-1, 0)).toVec2()).toStrictEqual({
-      x: -1,
-      y: 0
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0.5, 2)).toVec2()).toStrictEqual({
-      x: 0,
-      y: 1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(2, -0.5)).toVec2()).toStrictEqual({
-      x: 1,
-      y: -0
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0.5, -2)).toVec2()).toStrictEqual({
-      x: 0,
-      y: -1
-    });
-    (0, vitest_1.expect)(grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-2, -0.5)).toVec2()).toStrictEqual({
-      x: -1,
-      y: -0
-    });
-    const middle = grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 1));
-    (0, vitest_1.expect)(
-      helpers_lib_1.Vector.isEqual(middle, new helpers_lib_1.Vector(0, 1)) ||
-        helpers_lib_1.Vector.isEqual(middle, new helpers_lib_1.Vector(1, 0))
-    ).toBeTruthy();
-  });
-  (0, vitest_1.test)('should find the neighbor direction with diagonals from a vector', () => {
-    (0, vitest_1.expect)(
-      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(0, 1), {
-        includeDiagonals: true
-      }).toVec2()
-    ).toStrictEqual({ x: 0, y: 1 });
-    (0, vitest_1.expect)(
-      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(1, 1), {
-        includeDiagonals: true
-      }).toVec2()
-    ).toStrictEqual({ x: 1, y: 1 });
-    (0, vitest_1.expect)(
-      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(-1, -1), { includeDiagonals: true }).toVec2()
-    ).toStrictEqual({
-      x: -1,
-      y: -1
-    });
-    (0, vitest_1.expect)(
-      grid_1.Grid.vectorToNeighborDirection(new helpers_lib_1.Vector(2, 1), {
-        includeDiagonals: true
-      }).toVec2()
-    ).toStrictEqual({ x: 1, y: 0 });
-  });
-});
-//# sourceMappingURL=grid.test.js.map

package/dist/utilities/libraries/data-structures/grid/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/data-structures/grid/position-to-grid-position-converter.js

@@ -1,19 +0,0 @@
-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(
-      PositionToGridPositionConverter.positionToGridPosition(boundingBox.topLeft, cellSize),
-      PositionToGridPositionConverter.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/data-structures/queue/queue.d.ts

@@ -1,23 +0,0 @@
-export declare class Queue<T> {
-  private start;
-  private end;
-  get isEmpty(): boolean;
-  constructor(firstNode?: T | undefined);
-  /**
-   * @param args The values to add to end of the queue
-   */
-  add(...args: T[]): void;
-  /**
-   * @returns The value of the first element in the queue
-   */
-  pop(): T | undefined;
-  /**
-   * @returns The value of the first element in the queue without removing it
-   */
-  peek(): T | undefined;
-  /**
-   * @param deepCopyItem An optional function that takes an item and returns a deep copy of it
-   * @returns The duplicated queue
-   */
-  duplicate(deepCopyItem?: (item: T) => T): Queue<T>;
-}

package/dist/utilities/libraries/data-structures/queue/queue.js

@@ -1,72 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.Queue = void 0;
-class DoublyLinkedListNode {
-  constructor(value) {
-    this.value = value;
-  }
-}
-class Queue {
-  get isEmpty() {
-    return this.start === undefined;
-  }
-  constructor(firstNode) {
-    if (firstNode) {
-      const firstNodeInstance = new DoublyLinkedListNode(firstNode);
-      this.start = firstNodeInstance;
-      this.end = firstNodeInstance;
-    }
-  }
-  /**
-   * @param args The values to add to end of the queue
-   */
-  add(...args) {
-    args.forEach(value => {
-      const newNode = new DoublyLinkedListNode(value);
-      if (this.start) {
-        newNode.previous = this.end;
-        this.end.next = newNode;
-        this.end = newNode;
-      } else {
-        this.start = newNode;
-        this.end = newNode;
-      }
-    });
-  }
-  /**
-   * @returns The value of the first element in the queue
-   */
-  pop() {
-    if (this.start) {
-      const value = this.start.value;
-      this.start = this.start.next;
-      if (this.start) {
-        this.start.previous = undefined;
-      } else {
-        this.end = undefined;
-      }
-      return value;
-    }
-  }
-  /**
-   * @returns The value of the first element in the queue without removing it
-   */
-  peek() {
-    return this.start?.value;
-  }
-  /**
-   * @param deepCopyItem An optional function that takes an item and returns a deep copy of it
-   * @returns The duplicated queue
-   */
-  duplicate(deepCopyItem) {
-    const newQueue = new Queue();
-    let current = this.start;
-    while (current) {
-      const value = deepCopyItem ? deepCopyItem(current.value) : current.value;
-      newQueue.add(value);
-      current = current.next;
-    }
-    return newQueue;
-  }
-}
-exports.Queue = Queue;
-//# sourceMappingURL=queue.js.map

package/dist/utilities/libraries/data-structures/queue/queue.test.d.ts

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

package/dist/utilities/libraries/data-structures/queue/queue.test.js

@@ -1,57 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-const vitest_1 = require('vitest');
-const queue_1 = require('./queue');
-(0, vitest_1.describe)('Queue', () => {
-  (0, vitest_1.describe)('Basic', () => {
-    (0, vitest_1.test)('should return undefined when queue is empty', () => {
-      const queue = new queue_1.Queue();
-      (0, vitest_1.expect)(queue.pop()).toBe(undefined);
-    });
-    (0, vitest_1.test)('should return false when queue is not empty', () => {
-      const queue = new queue_1.Queue(1);
-      (0, vitest_1.expect)(queue.isEmpty).toBe(false);
-    });
-    (0, vitest_1.test)('should add elements to the queue', () => {
-      const queue = new queue_1.Queue();
-      queue.add(1, 2, 3);
-      (0, vitest_1.expect)(queue.pop()).toBe(1);
-      (0, vitest_1.expect)(queue.pop()).toBe(2);
-      (0, vitest_1.expect)(queue.pop()).toBe(3);
-    });
-    (0, vitest_1.test)('should add elements to the queue with first element', () => {
-      const queue = new queue_1.Queue(1);
-      queue.add(2, 3);
-      (0, vitest_1.expect)(queue.pop()).toBe(1);
-      (0, vitest_1.expect)(queue.pop()).toBe(2);
-      (0, vitest_1.expect)(queue.pop()).toBe(3);
-    });
-    (0, vitest_1.test)('peek should return the first element in the queue without removing it', () => {
-      const queue = new queue_1.Queue(1);
-      (0, vitest_1.expect)(queue.peek()).toBe(1);
-      (0, vitest_1.expect)(queue.pop()).toBe(1);
-    });
-  });
-  (0, vitest_1.describe)('Duplicate', () => {
-    (0, vitest_1.test)('empty queue', () => {
-      const queue = new queue_1.Queue();
-      const duplicate = queue.duplicate();
-      (0, vitest_1.expect)(duplicate.pop()).toBe(undefined);
-    });
-    (0, vitest_1.test)('queue with elements', () => {
-      const queue = new queue_1.Queue(1);
-      queue.add(2, 3);
-      const duplicate = queue.duplicate();
-      (0, vitest_1.expect)(duplicate.pop()).toBe(1);
-      (0, vitest_1.expect)(duplicate.pop()).toBe(2);
-      (0, vitest_1.expect)(duplicate.pop()).toBe(3);
-    });
-    (0, vitest_1.test)('duplicate with deep copy', () => {
-      const queue = new queue_1.Queue({ value: 1 });
-      const duplicate = queue.duplicate(item => ({ value: item.value }));
-      (0, vitest_1.expect)(duplicate.peek()).toStrictEqual({ value: 1 });
-      (0, vitest_1.expect)(queue.peek()).toStrictEqual({ value: 1 });
-      (0, vitest_1.expect)(duplicate.peek() !== queue.peek()).toBeTruthy();
-    });
-  });
-});
-//# sourceMappingURL=queue.test.js.map

package/dist/utilities/libraries/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/libraries/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/libraries/delta-time/delta-time.d.ts

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

package/dist/utilities/libraries/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/libraries/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/libraries/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.isEmpty) {
-            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/libraries/grid-algorithms/closest-available-space/closest-available-space.helper.spec.d.ts

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

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

@@ -1,124 +0,0 @@
-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', () => {
-    const 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);
-    const 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);
-    const 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
-    const 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);
-    const 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);
-    const 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);
-    const 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/closest-available-space/closest-available-space.helper.test.d.ts

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