bard-legends-framework 0.12.1 → 1.0.0-rc1

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

@@ -1,254 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_lib_1 = require("helpers-lib");
-const vitest_1 = require("vitest");
-const vector_field_path_finder_1 = require("./vector-field-path-finder");
-(0, vitest_1.describe)('VectorFieldPathFinder', () => {
-    (0, vitest_1.describe)('weight grid', () => {
-        (0, vitest_1.test)('basic 1', () => {
-            let targetArea = 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.test)('basic 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([
-                [true, true],
-                [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.test)('sample 1', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true],
-                [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.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, 0, 10],
-                [0, 0, 10],
-                [10, 10, 14]
-            ]);
-        });
-        (0, vitest_1.test)('sample 3', () => {
-            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([
-                [14, 10, 10],
-                [10, 0, 0],
-                [10, 0, 0]
-            ]);
-        });
-        (0, vitest_1.test)('complex 1', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, false, true],
-                [true, true, true],
-                [false, false, true],
-                [false, false, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-                [0, h, 28],
-                [10, 14, 24],
-                [h, h, 28],
-                [h, h, 38]
-            ]);
-        });
-        (0, vitest_1.test)('complex 2', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true, false, true],
-                [true, true, false, true],
-                [false, false, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-                [0, 0, h, 38],
-                [0, 0, h, 28],
-                [h, h, 14, 24]
-            ]);
-        });
-        (0, vitest_1.test)('complex 3', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 2, y: 2 }, bottomRight: { x: 3, y: 3 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true, false, true],
-                [true, true, false, true],
-                [false, false, true, true],
-                [false, false, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-                [28, 24, h, 20],
-                [24, 14, h, 10],
-                [h, h, 0, 0],
-                [h, h, 0, 0]
-            ]);
-        });
-        (0, vitest_1.test)('unreachable area 1', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, false, true, false, true],
-                [true, false, true, false, true],
-                [true, false, false, false, true],
-                [true, false, false, false, true],
-                [true, true, true, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
-            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
-                [0, h, h, h, 108],
-                [10, h, h, h, 98],
-                [20, h, h, h, 88],
-                [30, h, h, h, 78],
-                [40, 44, 54, 64, 74]
-            ]);
-        });
-    });
-    (0, vitest_1.describe)('getDirectionToTarget', () => {
-        (0, vitest_1.test)('sample 1', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true],
-                [true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(1, 1))?.value).toEqual(helpers_lib_1.Radian.get315.value);
-        });
-        (0, vitest_1.test)('sample 2', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true, true],
-                [false, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 1))?.value).toEqual(new helpers_lib_1.Vector(-2, -1).radian.value);
-        });
-        (0, vitest_1.test)('sample 3', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, false, true],
-                [true, false, true],
-                [true, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 0))?.value).toEqual(helpers_lib_1.Radian.get180.value);
-        });
-        (0, vitest_1.test)('sample 4', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, false, false],
-                [true, false, false]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 0))).toBeUndefined();
-        });
-    });
-    (0, vitest_1.describe)('edge cases', () => {
-        (0, vitest_1.test)('should create an instance', () => {
-            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 });
-            (0, vitest_1.expect)(new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid)).toBeTruthy();
-        });
-        (0, vitest_1.test)('should activate unavailable target cells of the target area', () => {
-            let targetArea = 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.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([
-                [20, 10, 0],
-                [20, 10, 0],
-                [24, 14, 10]
-            ]);
-        });
-        (0, vitest_1.test)('should return undefined if starting position and its neighbors are unreachable', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, false, false],
-                [true, false, false]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 1))).toBeUndefined();
-        });
-        (0, vitest_1.test)('should find the direction if starting position is unreachable but there is a reachable neighbor', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true, false],
-                [true, false, false]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 1))?.value).toEqual(helpers_lib_1.Radian.get315.value);
-        });
-        (0, vitest_1.test)('should return undefined if starting point is inside target area', () => {
-            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(2, 2), defaultValue: true });
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(0, 0))).toBeUndefined();
-        });
-        (0, vitest_1.test)('should return closest cell result if starting point is outside of the grid', () => {
-            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(2, 1), defaultValue: true });
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 0))?.value).toEqual(helpers_lib_1.Radian.get270.value);
-        });
-        (0, vitest_1.test)('if average direction is pointing blocked path, it should pick random available direction', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true, true],
-                [true, false, true],
-                [true, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let result = pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 2));
-            (0, vitest_1.expect)(result?.value === helpers_lib_1.Radian.get270.value || result?.value === 0).toBeTruthy();
-        });
-        (0, vitest_1.test)('finding path from unavailable space should point the direction away from the obstacle', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, true, true, true],
-                [true, false, false, true],
-                [true, false, false, true],
-                [true, true, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let result = pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 2));
-            (0, vitest_1.expect)(result?.value).toEqual(helpers_lib_1.Radian.get135.value);
-        });
-        (0, vitest_1.test)('finding path from unavailable space should point the direction to the best neighbor if all neighbors are available', () => {
-            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
-            let availabilityGrid = new helpers_lib_1.Grid([
-                [true, false, true, false],
-                [true, false, true, true],
-                [true, true, true, true]
-            ]);
-            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
-            let result = pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(3, 0));
-            (0, vitest_1.expect)(result?.value).toEqual(-helpers_lib_1.Radian.get135.value);
-        });
-    });
-});
-//# sourceMappingURL=vector-field-path-finder.test.js.map

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

@@ -1,12 +0,0 @@
-import { Vec2 } from 'helpers-lib';
-export interface PathFinderResult {
-  directPathAvailable: boolean;
-  path: Vec2[];
-}
-export declare class PathFinder {
-  /**
-   * Time Complexity: O(grid.height * grid.width)
-   * Space Complexity: O(grid.height * grid.width)
-   */
-  static findPath(gridValues: boolean[][], startingPosition: Vec2, targetPosition: Vec2): PathFinderResult;
-}

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

@@ -1,127 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PathFinder = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const binary_heap_1 = require('../binary-heap/binary-heap');
-const DIRECTIONS = [
-  { x: -1, y: -1 },
-  { x: -1, y: 0 },
-  { x: -1, y: 1 },
-  { x: 0, y: -1 },
-  { x: 0, y: 1 },
-  { x: 1, y: -1 },
-  { x: 1, y: 0 },
-  { x: 1, y: 1 }
-];
-class Node {
-  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 this.position.x === targetPosition.x && this.position.y === targetPosition.y;
-  }
-  createSolutionPath(directPathAvailable) {
-    const 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 helpers_lib_1.Vector.getDistance(this.position, targetPosition);
-  }
-}
-class Grid {
-  constructor(grid, startingPosition) {
-    this.grid = grid;
-    this.startingPosition = startingPosition;
-    this.nodes = new Map();
-    this.openMinBinaryHeap = new binary_heap_1.BinaryHeap('min');
-    this.closedSet = [];
-    this.width = grid[0].length;
-    this.height = grid.length;
-    const startingNode = new Node(this.startingPosition, 0, Number.MAX_SAFE_INTEGER);
-    this.openMinBinaryHeap.add(startingNode.pathLength, startingNode);
-  }
-  get hasOpenNodes() {
-    return this.openMinBinaryHeap.size > 0;
-  }
-  getNeighbors(node) {
-    return DIRECTIONS.map(direction => ({
-      x: node.position.x + direction.x,
-      y: node.position.y + direction.y
-    }))
-      .filter(neighborPosition => this.isPositionInsideGrid(neighborPosition) && this.isWalkable(neighborPosition))
-      .map(
-        neighborPosition => this.nodes.get(neighborPosition.x)?.get(neighborPosition.y) || this.createNewNode(neighborPosition)
-      );
-  }
-  popLowestPathCostNode() {
-    const lowestPathNode = this.openMinBinaryHeap.pop();
-    this.openMinBinaryHeap.delete(lowestPathNode);
-    lowestPathNode.closed = true;
-    this.closedSet.push(lowestPathNode);
-    return lowestPathNode;
-  }
-  getBestClosedNode() {
-    return this.closedSet.reduce((prev, current) => (prev.distanceToEnd < current.distanceToEnd ? prev : current));
-  }
-  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);
-  }
-  createNewNode(position) {
-    const node = new Node(position, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-    if (!this.nodes.get(position.x)) {
-      this.nodes.set(position.x, new Map());
-    }
-    this.nodes.get(position.x)?.set(position.y, node);
-    this.openMinBinaryHeap.add(node.pathLength, node);
-    return node;
-  }
-  isWalkable(position) {
-    return this.grid[position.y][position.x];
-  }
-  isPositionInsideGrid(position) {
-    return position.x >= 0 && position.x < this.width && position.y >= 0 && position.y < this.height;
-  }
-}
-class PathFinder {
-  /**
-   * Time Complexity: O(grid.height * grid.width)
-   * Space Complexity: O(grid.height * grid.width)
-   */
-  static findPath(gridValues, startingPosition, targetPosition) {
-    const grid = new Grid(gridValues, startingPosition);
-    while (grid.hasOpenNodes) {
-      const currentNode = grid.popLowestPathCostNode();
-      if (currentNode.isEqual(targetPosition)) {
-        return currentNode.createSolutionPath(true);
-      }
-      const neighbors = grid.getNeighbors(currentNode);
-      for (const neighbor of neighbors) {
-        if (!neighbor.closed) {
-          const distanceFromStart = currentNode.distanceFromStart + currentNode.getDistance(neighbor.position);
-          if (distanceFromStart < neighbor.distanceFromStart) {
-            grid.changeNodeCost(neighbor, distanceFromStart, targetPosition, currentNode);
-          }
-        }
-      }
-    }
-    return grid.getBestClosedNode().createSolutionPath(false);
-  }
-}
-exports.PathFinder = PathFinder;
-//# sourceMappingURL=path-finder.js.map

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

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

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

@@ -1,158 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-const path_finder_1 = require('./path-finder');
-describe('PATH_FINDER', () => {
-  test('basic 1', () => {
-    const result = path_finder_1.PathFinder.findPath([[true]], { x: 0, y: 0 }, { x: 0, y: 0 });
-    expect(result).toEqual({
-      directPathAvailable: true,
-      path: [{ x: 0, y: 0 }]
-    });
-  });
-  test('basic 2', () => {
-    const result = path_finder_1.PathFinder.findPath([[false]], { x: 0, y: 0 }, { x: 0, y: 0 });
-    expect(result).toEqual({
-      directPathAvailable: true,
-      path: [{ x: 0, y: 0 }]
-    });
-  });
-  test('should give the shortest path 1', () => {
-    const result = path_finder_1.PathFinder.findPath(
-      [
-        [true, true, true, true],
-        [true, false, false, true],
-        [true, false, false, true],
-        [true, false, false, true]
-      ],
-      { x: 0, y: 0 },
-      { x: 3, y: 3 }
-    );
-    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 }
-      ]
-    });
-  });
-  test('should give the shortest path 2', () => {
-    const result = path_finder_1.PathFinder.findPath(
-      [
-        [true, true, true, false],
-        [true, false, false, false],
-        [true, true, false, true],
-        [true, false, true, true]
-      ],
-      { x: 0, y: 0 },
-      { x: 3, y: 3 }
-    );
-    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 }
-      ]
-    });
-  });
-  test('should give the shortest path 3', () => {
-    const result = path_finder_1.PathFinder.findPath(
-      [
-        [true, false, false, true, false],
-        [true, false, true, false, true],
-        [true, false, true, false, true],
-        [false, true, false, false, true]
-      ],
-      { x: 0, y: 0 },
-      { x: 4, y: 3 }
-    );
-    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 }
-      ]
-    });
-  });
-  test('should give the shortest path backwards 3', () => {
-    const result = path_finder_1.PathFinder.findPath(
-      [
-        [true, false, false, true, false],
-        [true, false, true, false, true],
-        [true, false, true, false, true],
-        [false, true, false, false, true]
-      ],
-      { x: 4, y: 3 },
-      { x: 0, y: 0 }
-    );
-    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 }
-      ]
-    });
-  });
-  test('should give the shortest path to closest position', () => {
-    const result = path_finder_1.PathFinder.findPath(
-      [
-        [true, true, true, false],
-        [true, false, false, false],
-        [true, false, false, false],
-        [true, true, false, true]
-      ],
-      { x: 0, y: 0 },
-      { x: 3, y: 3 }
-    );
-    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 = 1600;
-      let centerPos = { x: Math.floor(size / 2), y: Math.floor(size / 2) };
-  
-      let bigGrid: boolean[][] = [];
-      for (let x = 0; x < size; x++) {
-        bigGrid[x] = [];
-        for (let y = 0; y < size; y++) {
-          bigGrid[x][y] = Vector.getDistance(centerPos, { x, y }) >= size / 4;
-        }
-      }
-  
-      let start = new Date();
-      PathFinder.findPath(bigGrid, { x: 0, y: 0 }, { x: size - 1, y: size - 1 });
-      let end = new Date();
-  
-      console.log(end.getTime() - start.getTime());
-    });*/
-});
-//# sourceMappingURL=path-finder.spec.js.map

package/dist/utilities/services/keyboard/keyboard.d.ts

@@ -1,7 +0,0 @@
-import { Action } from 'actions-lib';
-export declare class KeyboardService {
-  readonly keyPressed: Action<string>;
-  private listOfPressedKeys;
-  constructor();
-  isKeyDown(key: string): boolean;
-}

package/dist/utilities/services/keyboard/keyboard.js

@@ -1,47 +0,0 @@
-var __decorate =
-  (this && this.__decorate) ||
-  ((decorators, target, key, desc) => {
-    var c = arguments.length,
-      r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
-      d;
-    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
-      r = Reflect.decorate(decorators, target, key, desc);
-    else
-      for (var i = decorators.length - 1; i >= 0; i--)
-        if ((d = decorators[i])) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-  });
-var __metadata =
-  (this && this.__metadata) ||
-  ((k, v) => {
-    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') return Reflect.metadata(k, v);
-  });
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.KeyboardService = void 0;
-const actions_lib_1 = require('actions-lib');
-const service_1 = require('../../../game-entities/service/service');
-let KeyboardService = class KeyboardService {
-  constructor() {
-    this.keyPressed = new actions_lib_1.Action();
-    this.listOfPressedKeys = new Set();
-    window.addEventListener('keydown', event => {
-      this.listOfPressedKeys.add(event.key);
-      !event.repeat && this.keyPressed.trigger(event.key);
-    });
-    window.addEventListener('keyup', event => {
-      this.listOfPressedKeys.delete(event.key);
-    });
-    window.addEventListener('blur', () => {
-      this.listOfPressedKeys.clear();
-    });
-  }
-  isKeyDown(key) {
-    return this.listOfPressedKeys.has(key);
-  }
-};
-exports.KeyboardService = KeyboardService;
-exports.KeyboardService = KeyboardService = __decorate(
-  [(0, service_1.ServiceDecorator)(), __metadata('design:paramtypes', [])],
-  KeyboardService
-);
-//# sourceMappingURL=keyboard.js.map

package/dist/utilities/services/mouse/helpers/mouse-position.helper.d.ts

@@ -1,4 +0,0 @@
-import { Vector } from 'helpers-lib';
-export declare class MousePositionHelper {
-  static includeScaleInScreenPosition(screenPosition: Vector, gameInstanceScale: number, screenSizeCenter: Vector): Vector;
-}

package/dist/utilities/services/mouse/helpers/mouse-position.helper.js

@@ -1,17 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.MousePositionHelper = void 0;
-const helpers_lib_1 = require('helpers-lib');
-class MousePositionHelper {
-  static includeScaleInScreenPosition(screenPosition, gameInstanceScale, screenSizeCenter) {
-    if (gameInstanceScale !== 1) {
-      const centerToScaledScreenPosition = helpers_lib_1.Vector.fromTo(screenSizeCenter, screenPosition).multiply(
-        1 / gameInstanceScale
-      );
-      return screenSizeCenter.add(centerToScaledScreenPosition);
-    } else {
-      return screenPosition;
-    }
-  }
-}
-exports.MousePositionHelper = MousePositionHelper;
-//# sourceMappingURL=mouse-position.helper.js.map

package/dist/utilities/services/mouse/helpers/mouse-position.helper.test.d.ts

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