bard-legends-framework 0.9.6 → 0.9.7

package/dist/physics/entitity-types/physics-entity.js

@@ -1,97 +1,106 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsEntity = void 0;
-const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
-const physics_world_1 = require("../physics-world");
-const p2js_helper_1 = require("../helpers/p2js.helper");
-const shape_factory_1 = require("../helpers/shape-factory");
-const game_entities_1 = require("../../game-entities");
-const update_cycle_1 = require("../../game-entities/update-cycle");
+const actions_lib_1 = require('actions-lib');
+const helpers_lib_1 = require('helpers-lib');
+const physics_world_1 = require('../physics-world');
+const p2js_helper_1 = require('../helpers/p2js.helper');
+const shape_factory_1 = require('../helpers/shape-factory');
+const game_entities_1 = require('../../game-entities');
+const update_cycle_1 = require('../../game-entities/update-cycle');
 class PhysicsEntity extends game_entities_1.Entity {
-    static { this.p2BodyIdToPhysicsBody = new Map(); }
-    static { this.physicsEntities = new Map(); }
-    static getFromP2BodyId(p2BodyId) {
-        return PhysicsEntity.p2BodyIdToPhysicsBody.get(p2BodyId);
+  static {
+    PhysicsEntity.p2BodyIdToPhysicsBody = new Map();
+  }
+  static {
+    PhysicsEntity.physicsEntities = new Map();
+  }
+  static getFromP2BodyId(p2BodyId) {
+    return PhysicsEntity.p2BodyIdToPhysicsBody.get(p2BodyId);
+  }
+  static getFromP2BodyIdOrFail(p2BodyId) {
+    const physicsBody = PhysicsEntity.p2BodyIdToPhysicsBody.get(p2BodyId);
+    if (!physicsBody) {
+      throw new Error(`PhysicsEntity with p2BodyId ${p2BodyId} not found`);
     }
-    static getFromP2BodyIdOrFail(p2BodyId) {
-        let physicsBody = PhysicsEntity.p2BodyIdToPhysicsBody.get(p2BodyId);
-        if (!physicsBody) {
-            throw new Error(`PhysicsEntity with p2BodyId ${p2BodyId} not found`);
-        }
-        return physicsBody;
+    return physicsBody;
+  }
+  static getPhysicsInstanceOrFail(id) {
+    const physicsEntity = PhysicsEntity.physicsEntities.get(id);
+    if (!physicsEntity) {
+      throw new Error(`PhysicsEntity with id ${id} not found`);
     }
-    static getPhysicsInstanceOrFail(id) {
-        let physicsEntity = PhysicsEntity.physicsEntities.get(id);
-        if (!physicsEntity) {
-            throw new Error(`PhysicsEntity with id ${id} not found`);
-        }
-        return physicsEntity;
+    return physicsEntity;
+  }
+  static getPhysicsEntities() {
+    return Array.from(PhysicsEntity.physicsEntities.values());
+  }
+  get area() {
+    return this._area;
+  }
+  get mass() {
+    return this._mass;
+  }
+  get collisions() {
+    return this._collisions;
+  }
+  constructor(physicsWorld, physicsEntityDefinition, type) {
+    super();
+    this.onCollision = new actions_lib_1.Action();
+    this.type = 'dynamic';
+    this.physicsDestroy = () => {
+      this.physicsWorld.removeBody(this.p2Body);
+      PhysicsEntity.p2BodyIdToPhysicsBody.delete(this.p2Body.id);
+      PhysicsEntity.physicsEntities.delete(this.id);
+    };
+    this._area = 0;
+    this._mass = 0;
+    this._collisions = [];
+    if (helpers_lib_1.Comparator.isString(physicsWorld)) {
+      this.physicsWorld = physics_world_1.PhysicsWorld.getInstanceByIdOrFail(physicsWorld);
+    } else {
+      this.physicsWorld = physicsWorld;
     }
-    static getPhysicsEntities() {
-        return Array.from(PhysicsEntity.physicsEntities.values());
+    const material = this.physicsWorld.physicsMaterials.getMaterial(physicsEntityDefinition.shapeDefinition.materialName);
+    const materialDefinition = this.physicsWorld.physicsMaterials.getMaterialDefinition(
+      physicsEntityDefinition.shapeDefinition.materialName
+    );
+    this.type = type;
+    this.physicsBodyGroup = physicsEntityDefinition.shapeDefinition.group;
+    this.includeInPathfinding = physicsEntityDefinition.includeOnPathfinding;
+    this.p2Body = shape_factory_1.ShapeFactory.createBody(physicsEntityDefinition, material, materialDefinition, this.type);
+    this._area = this.p2Body.getArea();
+    this._mass = this.p2Body.mass;
+    this.p2Body.position = p2js_helper_1.P2JSHelper.vectorToArray(physicsEntityDefinition.position);
+    this.p2Body.angle = physicsEntityDefinition.rotation;
+    const addedToTheWorld = this.physicsWorld.addBody(
+      this.p2Body,
+      physicsEntityDefinition.addInEmptySpace,
+      physicsEntityDefinition.shapeDefinition.group,
+      physicsEntityDefinition.includeOnPathfinding
+    );
+    if (!addedToTheWorld) {
+      throw new Error('PhysicsEntity was not able to be added to the world!');
     }
-    get area() {
-        return this._area;
-    }
-    get mass() {
-        return this._mass;
-    }
-    get collisions() {
-        return this._collisions;
-    }
-    constructor(physicsWorld, physicsEntityDefinition, type) {
-        super();
-        this.onCollision = new actions_lib_1.Action();
-        this.type = 'dynamic';
-        this.physicsDestroy = () => {
-            this.physicsWorld.removeBody(this.p2Body);
-            PhysicsEntity.p2BodyIdToPhysicsBody.delete(this.p2Body.id);
-            PhysicsEntity.physicsEntities.delete(this.id);
-        };
-        this._area = 0;
-        this._mass = 0;
-        this._collisions = [];
-        if (helpers_lib_1.Comparator.isString(physicsWorld)) {
-            this.physicsWorld = physics_world_1.PhysicsWorld.getInstanceByIdOrFail(physicsWorld);
-        }
-        else {
-            this.physicsWorld = physicsWorld;
-        }
-        let material = this.physicsWorld.physicsMaterials.getMaterial(physicsEntityDefinition.shapeDefinition.materialName);
-        let materialDefinition = this.physicsWorld.physicsMaterials.getMaterialDefinition(physicsEntityDefinition.shapeDefinition.materialName);
-        this.type = type;
-        this.physicsBodyGroup = physicsEntityDefinition.shapeDefinition.group;
-        this.includeInPathfinding = physicsEntityDefinition.includeOnPathfinding;
-        this.p2Body = shape_factory_1.ShapeFactory.createBody(physicsEntityDefinition, material, materialDefinition, this.type);
-        this._area = this.p2Body.getArea();
-        this._mass = this.p2Body.mass;
-        this.p2Body.position = p2js_helper_1.P2JSHelper.vectorToArray(physicsEntityDefinition.position);
-        this.p2Body.angle = physicsEntityDefinition.rotation;
-        let addedToTheWorld = this.physicsWorld.addBody(this.p2Body, physicsEntityDefinition.addInEmptySpace, physicsEntityDefinition.shapeDefinition.group, physicsEntityDefinition.includeOnPathfinding);
-        if (!addedToTheWorld) {
-            throw new Error('PhysicsEntity was not able to be added to the world!');
-        }
-        PhysicsEntity.p2BodyIdToPhysicsBody.set(this.p2Body.id, this);
-        PhysicsEntity.physicsEntities.set(this.id, this);
-        this.destroy = function () {
-            update_cycle_1.UpdateCycle.waitUntilDestroyPhase(() => {
-                this.destroyed = true;
-                this.attachableDestroy();
-                this.entityDestroy();
-                this.physicsDestroy();
-                this.childDestroy();
-            });
-        };
-    }
-    destroy() { }
-    // Managed by PhysicsCollision
-    setCollisionReports(collisionReports) {
-        this._collisions = collisionReports;
-        if (collisionReports.length > 0) {
-            this.onCollision.trigger(collisionReports);
-        }
+    PhysicsEntity.p2BodyIdToPhysicsBody.set(this.p2Body.id, this);
+    PhysicsEntity.physicsEntities.set(this.id, this);
+    this.destroy = function () {
+      update_cycle_1.UpdateCycle.waitUntilDestroyPhase(() => {
+        this.destroyed = true;
+        this.attachableDestroy();
+        this.entityDestroy();
+        this.physicsDestroy();
+        this.childDestroy();
+      });
+    };
+  }
+  destroy() {}
+  // Managed by PhysicsCollision
+  setCollisionReports(collisionReports) {
+    this._collisions = collisionReports;
+    if (collisionReports.length > 0) {
+      this.onCollision.trigger(collisionReports);
     }
+  }
 }
 exports.PhysicsEntity = PhysicsEntity;
-//# sourceMappingURL=physics-entity.js.map
+//# sourceMappingURL=physics-entity.js.map

package/dist/physics/helpers/closest-available-space.helper.d.ts

@@ -1,19 +1,19 @@
 import { Rectangle, Vec2 } from 'helpers-lib';
 export declare class ClosestAvailableSpaceHelper {
-    private grid;
-    private worldWidth;
-    private worldHeight;
-    private cellSize;
-    constructor(worldWidth: number, worldHeight: number, cellSize: number);
-    markObjectOnGrid(object: Rectangle): void;
-    /**
-     * @param newObject The object to find a closest available position for
-     * @returns the needed position change vector to the closest available position,
-     *  zero vector if the location is available by itself,
-     *  or undefined if no available space found
-     */
-    findClosestAvailableSpace(newObject: Rectangle): Vec2 | undefined;
-    private canPlaceObject;
-    private isWithinBounds;
-    private fitInsideWorld;
+  private grid;
+  private worldWidth;
+  private worldHeight;
+  private cellSize;
+  constructor(worldWidth: number, worldHeight: number, cellSize: number);
+  markObjectOnGrid(object: Rectangle): void;
+  /**
+   * @param newObject The object to find a closest available position for
+   * @returns the needed position change vector to the closest available position,
+   *  zero vector if the location is available by itself,
+   *  or undefined if no available space found
+   */
+  findClosestAvailableSpace(newObject: Rectangle): Vec2 | undefined;
+  private canPlaceObject;
+  private isWithinBounds;
+  private fitInsideWorld;
 }

package/dist/physics/helpers/closest-available-space.helper.js

@@ -1,107 +1,109 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.ClosestAvailableSpaceHelper = void 0;
-const p2js_helper_1 = require("./p2js.helper");
+const p2js_helper_1 = require('./p2js.helper');
 class ClosestAvailableSpaceHelper {
-    constructor(worldWidth, worldHeight, cellSize) {
-        this.worldWidth = worldWidth;
-        this.worldHeight = worldHeight;
-        this.cellSize = cellSize;
-        this.grid = Array(Math.floor(worldHeight / cellSize))
-            .fill(undefined)
-            .map(() => Array(Math.floor(worldWidth / cellSize)).fill(false));
+  constructor(worldWidth, worldHeight, cellSize) {
+    this.worldWidth = worldWidth;
+    this.worldHeight = worldHeight;
+    this.cellSize = cellSize;
+    this.grid = Array(Math.floor(worldHeight / cellSize))
+      .fill(undefined)
+      .map(() => Array(Math.floor(worldWidth / cellSize)).fill(false));
+  }
+  markObjectOnGrid(object) {
+    object = this.fitInsideWorld(object);
+    const startX = Math.floor(object.topLeft.x / this.cellSize);
+    const startY = Math.floor(object.topLeft.y / this.cellSize);
+    const endX = Math.ceil(object.bottomRight.x / this.cellSize);
+    const endY = Math.ceil(object.bottomRight.y / this.cellSize);
+    for (let y = startY; y < endY && y < this.grid.length; y++) {
+      for (let x = startX; x < endX && x < this.grid[y].length; x++) {
+        this.grid[y][x] = true;
+      }
     }
-    markObjectOnGrid(object) {
-        object = this.fitInsideWorld(object);
-        let startX = Math.floor(object.topLeft.x / this.cellSize);
-        let startY = Math.floor(object.topLeft.y / this.cellSize);
-        let endX = Math.ceil(object.bottomRight.x / this.cellSize);
-        let endY = Math.ceil(object.bottomRight.y / this.cellSize);
-        for (let y = startY; y < endY && y < this.grid.length; y++) {
-            for (let x = startX; x < endX && x < this.grid[y].length; x++) {
-                this.grid[y][x] = true;
-            }
-        }
+  }
+  /**
+   * @param newObject The object to find a closest available position for
+   * @returns the needed position change vector to the closest available position,
+   *  zero vector if the location is available by itself,
+   *  or undefined if no available space found
+   */
+  findClosestAvailableSpace(newObject) {
+    const newObjectWidth = newObject.bottomRight.x - newObject.topLeft.x;
+    const newObjectHeight = newObject.bottomRight.y - newObject.topLeft.y;
+    const visited = new Set();
+    const targetWidthCells = Math.ceil(newObjectWidth / this.cellSize);
+    const targetHeightCells = Math.ceil(newObjectHeight / this.cellSize);
+    const newObjectInsideWorld = this.fitInsideWorld(newObject);
+    const firstQueueItem = {
+      x: Math.floor(newObjectInsideWorld.topLeft.x / this.cellSize),
+      y: Math.floor(newObjectInsideWorld.topLeft.y / this.cellSize)
+    };
+    const queue = [firstQueueItem];
+    if (p2js_helper_1.P2JSHelper.isEqualBoundingBox(newObject, newObjectInsideWorld)) {
+      const startingColumn = Math.floor(newObjectInsideWorld.topLeft.x / this.cellSize);
+      const endingColumn = Math.floor(newObjectInsideWorld.bottomRight.x / this.cellSize);
+      const startingRow = Math.floor(newObjectInsideWorld.topLeft.y / this.cellSize);
+      const endingRow = Math.floor(newObjectInsideWorld.bottomRight.y / this.cellSize);
+      if (this.canPlaceObject(firstQueueItem, endingColumn - startingColumn + 1, endingRow - startingRow + 1)) {
+        return { x: 0, y: 0 };
+      }
     }
-    /**
-     * @param newObject The object to find a closest available position for
-     * @returns the needed position change vector to the closest available position,
-     *  zero vector if the location is available by itself,
-     *  or undefined if no available space found
-     */
-    findClosestAvailableSpace(newObject) {
-        let newObjectWidth = newObject.bottomRight.x - newObject.topLeft.x;
-        let newObjectHeight = newObject.bottomRight.y - newObject.topLeft.y;
-        let visited = new Set();
-        let targetWidthCells = Math.ceil(newObjectWidth / this.cellSize);
-        let targetHeightCells = Math.ceil(newObjectHeight / this.cellSize);
-        let newObjectInsideWorld = this.fitInsideWorld(newObject);
-        let firstQueueItem = {
-            x: Math.floor(newObjectInsideWorld.topLeft.x / this.cellSize),
-            y: Math.floor(newObjectInsideWorld.topLeft.y / this.cellSize)
-        };
-        let queue = [firstQueueItem];
-        if (p2js_helper_1.P2JSHelper.isEqualBoundingBox(newObject, newObjectInsideWorld)) {
-            let startingColumn = Math.floor(newObjectInsideWorld.topLeft.x / this.cellSize);
-            let endingColumn = Math.floor(newObjectInsideWorld.bottomRight.x / this.cellSize);
-            let startingRow = Math.floor(newObjectInsideWorld.topLeft.y / this.cellSize);
-            let endingRow = Math.floor(newObjectInsideWorld.bottomRight.y / this.cellSize);
-            if (this.canPlaceObject(firstQueueItem, endingColumn - startingColumn + 1, endingRow - startingRow + 1)) {
-                return { x: 0, y: 0 };
-            }
+    while (queue.length > 0) {
+      const shiftedPoint = queue.shift();
+      if (shiftedPoint) {
+        const currentPoint = shiftedPoint;
+        const key = `${currentPoint.x},${currentPoint.y}`;
+        if (visited.has(key)) {
+          continue;
         }
-        while (queue.length > 0) {
-            let shiftedPoint = queue.shift();
-            if (shiftedPoint) {
-                let currentPoint = shiftedPoint;
-                let key = `${currentPoint.x},${currentPoint.y}`;
-                if (visited.has(key)) {
-                    continue;
-                }
-                visited.add(key);
-                if (this.canPlaceObject(currentPoint, targetWidthCells, targetHeightCells)) {
-                    return {
-                        x: currentPoint.x * this.cellSize + (targetWidthCells * this.cellSize - newObjectWidth) / 2 - newObject.topLeft.x,
-                        y: currentPoint.y * this.cellSize + (targetHeightCells * this.cellSize - newObjectHeight) / 2 - newObject.topLeft.y
-                    };
-                }
-                // Add neighboring cells to the queue
-                [
-                    [1, 0],
-                    [0, 1],
-                    [-1, 0],
-                    [0, -1]
-                ].forEach(([dx, dy]) => {
-                    let nextPoint = { x: currentPoint.x + dx, y: currentPoint.y + dy };
-                    if (this.isWithinBounds(nextPoint) && !visited.has(`${nextPoint.x},${nextPoint.y}`)) {
-                        queue.push(nextPoint);
-                    }
-                });
-            }
+        visited.add(key);
+        if (this.canPlaceObject(currentPoint, targetWidthCells, targetHeightCells)) {
+          return {
+            x: currentPoint.x * this.cellSize + (targetWidthCells * this.cellSize - newObjectWidth) / 2 - newObject.topLeft.x,
+            y: currentPoint.y * this.cellSize + (targetHeightCells * this.cellSize - newObjectHeight) / 2 - newObject.topLeft.y
+          };
         }
-        return undefined; // No available space found
+        // Add neighboring cells to the queue
+        [
+          [1, 0],
+          [0, 1],
+          [-1, 0],
+          [0, -1]
+        ].forEach(([dx, dy]) => {
+          const nextPoint = { x: currentPoint.x + dx, y: currentPoint.y + dy };
+          if (this.isWithinBounds(nextPoint) && !visited.has(`${nextPoint.x},${nextPoint.y}`)) {
+            queue.push(nextPoint);
+          }
+        });
+      }
     }
-    canPlaceObject(point, widthCells, heightCells) {
-        for (let y = point.y; y < point.y + heightCells; y++) {
-            for (let x = point.x; x < point.x + widthCells; x++) {
-                if (!this.isWithinBounds({ x, y }) || this.grid[y][x]) {
-                    return false;
-                }
-            }
+    return undefined; // No available space found
+  }
+  canPlaceObject(point, widthCells, heightCells) {
+    for (let y = point.y; y < point.y + heightCells; y++) {
+      for (let x = point.x; x < point.x + widthCells; x++) {
+        if (!this.isWithinBounds({ x, y }) || this.grid[y][x]) {
+          return false;
         }
-        return true;
-    }
-    isWithinBounds(point) {
-        return point.x >= 0 && point.y >= 0 && point.x < this.grid[0]?.length && point.y < this.grid.length;
-    }
-    fitInsideWorld(object) {
-        let topLeft = { x: Math.max(0, object.topLeft.x), y: Math.max(0, object.topLeft.y) };
-        let bottomRight = {
-            x: Math.min(this.worldWidth, object.bottomRight.x),
-            y: Math.min(this.worldHeight, object.bottomRight.y)
-        };
-        return { topLeft, bottomRight };
+      }
     }
+    return true;
+  }
+  isWithinBounds(point) {
+    return point.x >= 0 && point.y >= 0 && point.x < this.grid[0]?.length && point.y < this.grid.length;
+  }
+  fitInsideWorld(object) {
+    const topLeft = {
+      x: Math.max(0, object.topLeft.x),
+      y: Math.max(0, object.topLeft.y)
+    };
+    const bottomRight = {
+      x: Math.min(this.worldWidth, object.bottomRight.x),
+      y: Math.min(this.worldHeight, object.bottomRight.y)
+    };
+    return { topLeft, bottomRight };
+  }
 }
 exports.ClosestAvailableSpaceHelper = ClosestAvailableSpaceHelper;
-//# sourceMappingURL=closest-available-space.helper.js.map
+//# sourceMappingURL=closest-available-space.helper.js.map

package/dist/physics/helpers/closest-available-space.helper.spec.js

@@ -1,71 +1,118 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const closest_available_space_helper_1 = require("./closest-available-space.helper");
+Object.defineProperty(exports, '__esModule', { value: true });
+const closest_available_space_helper_1 = require('./closest-available-space.helper');
 describe('findClosestAvailableSpace', () => {
-    let helper;
-    let newObject;
-    beforeEach(() => {
-        helper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(100, 100, 10);
-    });
-    it('should return no change vector if the location is available', () => {
-        newObject = { topLeft: { x: 50, y: 50 }, bottomRight: { x: 60, y: 60 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 0, y: 0 });
-    });
-    it('should support object positions outside of the world size', () => {
-        newObject = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 5, y: 5 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 5, y: 5 });
-        newObject = { topLeft: { x: 95, y: 95 }, bottomRight: { x: 105, y: 105 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: -5, y: -5 });
-    });
-    it('should find the no change vector space next to an existing object', () => {
-        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } });
-        newObject = { topLeft: { x: 10, y: 10 }, bottomRight: { x: 20, y: 20 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 0, y: 0 });
-    });
-    it('should find the closest available space if trying to spawn in occupied space', () => {
-        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 20, y: 20 } });
-        newObject = { topLeft: { x: 5, y: 5 }, bottomRight: { x: 15, y: 15 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 15, y: -5 });
-    });
-    it('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 □ □ □ □
-        helper.markObjectOnGrid({ topLeft: { x: 12, y: 5 }, bottomRight: { x: 35, y: 25 } });
-        helper.markObjectOnGrid({ topLeft: { x: 45, y: 5 }, bottomRight: { x: 52, y: 25 } });
-        helper.markObjectOnGrid({ topLeft: { x: -2, y: 32 }, bottomRight: { x: 12, y: 35 } });
-        helper.markObjectOnGrid({ topLeft: { x: 22, y: 55 }, bottomRight: { x: 28, y: 62 } });
-        helper.markObjectOnGrid({ topLeft: { x: 35, y: 65 }, bottomRight: { x: 52, y: 75 } });
-        helper.markObjectOnGrid({ topLeft: { x: 74, y: 42 }, bottomRight: { x: 95, y: 48 } });
-        newObject = { topLeft: { x: 10, y: 20 }, bottomRight: { x: 40, y: 50 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 20, y: 10 });
-    });
-    it('should not fooled by initial position occupying more space in grid and find narrower gap', () => {
-        helper.markObjectOnGrid({ topLeft: { x: 10, y: 0 }, bottomRight: { x: 40, y: 30 } });
-        newObject = { topLeft: { x: 4, y: 2 }, bottomRight: { x: 12, y: 20 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: -3, y: -1 });
-    });
-    it('should not fooled by initial position occupying more space in grid and find narrower gap negative starting point', () => {
-        helper.markObjectOnGrid({ topLeft: { x: 10, y: 0 }, bottomRight: { x: 40, y: 30 } });
-        newObject = { topLeft: { x: -6, y: -8 }, bottomRight: { x: 2, y: 10 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 7, y: 9 });
-    });
-    it('should not suggest a location at the edge of the map', () => {
-        helper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(10, 10, 9);
-        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 9, y: 9 } });
-        newObject = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toBeUndefined();
-    });
-    it('should return undefined if there is no available space', () => {
-        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 100, y: 100 } });
-        newObject = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } };
-        expect(helper.findClosestAvailableSpace(newObject)).toBeUndefined();
+  let helper;
+  let newObject;
+  beforeEach(() => {
+    helper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(100, 100, 10);
+  });
+  it('should return no change vector if the location is available', () => {
+    newObject = { topLeft: { x: 50, y: 50 }, bottomRight: { x: 60, y: 60 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 0, y: 0 });
+  });
+  it('should support object positions outside of the world size', () => {
+    newObject = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 5, y: 5 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 5, y: 5 });
+    newObject = { topLeft: { x: 95, y: 95 }, bottomRight: { x: 105, y: 105 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({
+      x: -5,
+      y: -5
     });
+  });
+  it('should find the no change vector space next to an existing object', () => {
+    helper.markObjectOnGrid({
+      topLeft: { x: 0, y: 0 },
+      bottomRight: { x: 10, y: 10 }
+    });
+    newObject = { topLeft: { x: 10, y: 10 }, bottomRight: { x: 20, y: 20 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 0, y: 0 });
+  });
+  it('should find the closest available space if trying to spawn in occupied space', () => {
+    helper.markObjectOnGrid({
+      topLeft: { x: 0, y: 0 },
+      bottomRight: { x: 20, y: 20 }
+    });
+    newObject = { topLeft: { x: 5, y: 5 }, bottomRight: { x: 15, y: 15 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({
+      x: 15,
+      y: -5
+    });
+  });
+  it('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 □ □ □ □
+    helper.markObjectOnGrid({
+      topLeft: { x: 12, y: 5 },
+      bottomRight: { x: 35, y: 25 }
+    });
+    helper.markObjectOnGrid({
+      topLeft: { x: 45, y: 5 },
+      bottomRight: { x: 52, y: 25 }
+    });
+    helper.markObjectOnGrid({
+      topLeft: { x: -2, y: 32 },
+      bottomRight: { x: 12, y: 35 }
+    });
+    helper.markObjectOnGrid({
+      topLeft: { x: 22, y: 55 },
+      bottomRight: { x: 28, y: 62 }
+    });
+    helper.markObjectOnGrid({
+      topLeft: { x: 35, y: 65 },
+      bottomRight: { x: 52, y: 75 }
+    });
+    helper.markObjectOnGrid({
+      topLeft: { x: 74, y: 42 },
+      bottomRight: { x: 95, y: 48 }
+    });
+    newObject = { topLeft: { x: 10, y: 20 }, bottomRight: { x: 40, y: 50 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({
+      x: 20,
+      y: 10
+    });
+  });
+  it('should not fooled by initial position occupying more space in grid and find narrower gap', () => {
+    helper.markObjectOnGrid({
+      topLeft: { x: 10, y: 0 },
+      bottomRight: { x: 40, y: 30 }
+    });
+    newObject = { topLeft: { x: 4, y: 2 }, bottomRight: { x: 12, y: 20 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({
+      x: -3,
+      y: -1
+    });
+  });
+  it('should not fooled by initial position occupying more space in grid and find narrower gap negative starting point', () => {
+    helper.markObjectOnGrid({
+      topLeft: { x: 10, y: 0 },
+      bottomRight: { x: 40, y: 30 }
+    });
+    newObject = { topLeft: { x: -6, y: -8 }, bottomRight: { x: 2, y: 10 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 7, y: 9 });
+  });
+  it('should not suggest a location at the edge of the map', () => {
+    helper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(10, 10, 9);
+    helper.markObjectOnGrid({
+      topLeft: { x: 0, y: 0 },
+      bottomRight: { x: 9, y: 9 }
+    });
+    newObject = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toBeUndefined();
+  });
+  it('should return undefined if there is no available space', () => {
+    helper.markObjectOnGrid({
+      topLeft: { x: 0, y: 0 },
+      bottomRight: { x: 100, y: 100 }
+    });
+    newObject = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } };
+    expect(helper.findClosestAvailableSpace(newObject)).toBeUndefined();
+  });
 });
-//# sourceMappingURL=closest-available-space.helper.spec.js.map
+//# sourceMappingURL=closest-available-space.helper.spec.js.map

package/dist/physics/helpers/p2js.helper.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="p2" />
 import { Rectangle, Vector } from 'helpers-lib';
 export declare class P2JSHelper {
-    static aabbToBoundingBox(aabb: p2.AABB): Rectangle;
-    static arrayToVector(array: [number, number]): Vector;
-    static vectorToArray(vector: Vector): [number, number];
+  static aabbToBoundingBox(aabb: p2.AABB): Rectangle;
+  static arrayToVector(array: [number, number]): Vector;
+  static vectorToArray(vector: Vector): [number, number];
 }