bard-legends-framework 0.12.1 → 1.0.0-rc1

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

@@ -1,106 +0,0 @@
-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');
-class PhysicsEntity extends game_entities_1.Entity {
-  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`);
-    }
-    return physicsBody;
-  }
-  static getPhysicsInstanceOrFail(id) {
-    const physicsEntity = PhysicsEntity.physicsEntities.get(id);
-    if (!physicsEntity) {
-      throw new Error(`PhysicsEntity with id ${id} not found`);
-    }
-    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;
-    }
-    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!');
-    }
-    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

package/dist/physics/entity-types/immovable-physics-entity.d.ts

@@ -1,9 +0,0 @@
-import { Radian, Vector } from 'helpers-lib';
-import { PhysicsBodyDTO, PhysicsEntityDefinition } from '../interfaces';
-import { PhysicsEntity } from './physics-entity';
-export declare abstract class ImmovablePhysicsEntity extends PhysicsEntity {
-    readonly position: Vector;
-    readonly rotation: Radian;
-    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
-    convertToDTO(): PhysicsBodyDTO;
-}

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

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImmovablePhysicsEntity = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const p2js_helper_1 = require("../libs/p2js.helper");
-const physics_entity_1 = require("./physics-entity");
-class ImmovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
-    constructor(physicsWorldID, physicsEntityDefinition) {
-        super(physicsWorldID, physicsEntityDefinition, 'static');
-        this.position = p2js_helper_1.P2JSHelper.arrayToVector(this.p2Body.position);
-        this.rotation = new helpers_lib_1.Radian(this.p2Body.angle);
-    }
-    convertToDTO() {
-        return {
-            entityID: this.id,
-            classID: this.classID,
-            position: this.position,
-            rotation: this.rotation,
-            velocity: helpers_lib_1.Vector.zero,
-            rotationalSpeed: 0
-        };
-    }
-}
-exports.ImmovablePhysicsEntity = ImmovablePhysicsEntity;
-//# sourceMappingURL=immovable-physics-entity.js.map

package/dist/physics/entity-types/movable-entity.d.ts

@@ -1,11 +0,0 @@
-import { Variable } from 'actions-lib';
-import { Radian, Vector } from 'helpers-lib';
-import { Entity } from '../../game-entities';
-export declare abstract class MovableEntity extends Entity {
-    readonly position: Variable<Vector>;
-    readonly rotation: Variable<Radian>;
-    readonly velocity: Variable<Vector>;
-    readonly rotationalSpeed: Variable<number>;
-    constructor();
-    private _step;
-}

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

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MovableEntity = void 0;
-const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
-const game_entities_1 = require("../../game-entities");
-class MovableEntity extends game_entities_1.Entity {
-    constructor() {
-        super();
-        this.position = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
-        this.rotation = new actions_lib_1.Variable(helpers_lib_1.Radian.get0);
-        this.velocity = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
-        this.rotationalSpeed = new actions_lib_1.Variable(0);
-        game_entities_1.UpdateCycle.beforeSceneUpdateAction
-            .subscribe(({ time, delta }) => {
-            this._step(time, delta);
-        })
-            .attach(this);
-    }
-    _step(time, delta) {
-        this.position.value = this.position.value.add(this.velocity.value.multiplyNumber(delta));
-        this.rotation.value = new helpers_lib_1.Radian(this.rotation.value.value + this.rotationalSpeed.value * delta);
-    }
-}
-exports.MovableEntity = MovableEntity;
-//# sourceMappingURL=movable-entity.js.map

package/dist/physics/entity-types/movable-physics-entity.d.ts

@@ -1,19 +0,0 @@
-import { Variable } from 'actions-lib';
-import { Radian, Vector } from 'helpers-lib';
-import { PhysicsBodyDTO, PhysicsEntityDefinition } from '../interfaces';
-import { PhysicsEntity } from './physics-entity';
-export declare abstract class MovablePhysicsEntity extends PhysicsEntity {
-    readonly position: Variable<Vector>;
-    readonly rotation: Variable<Radian>;
-    readonly velocity: Variable<Vector>;
-    readonly rotationalSpeed: Variable<number>;
-    private _ignorePositionUpdate;
-    private _ignoreRotationUpdate;
-    private _ignoreVelocityUpdate;
-    private _ignoreRotationalSpeedUpdate;
-    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
-    convertToDTO(): PhysicsBodyDTO;
-    private _step;
-    private _phsicsToLocalSync;
-    private _localToPhsicsSync;
-}

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

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MovablePhysicsEntity = void 0;
-const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
-const game_entities_1 = require("../../game-entities");
-const p2js_helper_1 = require("../libs/p2js.helper");
-const physics_internal_gateway_1 = require("../module/\u269C\uFE0Fgateways/physics-internal.gateway");
-const physics_entity_1 = require("./physics-entity");
-class MovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
-    constructor(physicsWorldID, physicsEntityDefinition) {
-        super(physicsWorldID, physicsEntityDefinition, 'dynamic');
-        this.position = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
-        this.rotation = new actions_lib_1.Variable(helpers_lib_1.Radian.get0);
-        this.velocity = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
-        this.rotationalSpeed = new actions_lib_1.Variable(0);
-        this._ignorePositionUpdate = false;
-        this._ignoreRotationUpdate = false;
-        this._ignoreVelocityUpdate = false;
-        this._ignoreRotationalSpeedUpdate = false;
-        this._phsicsToLocalSync();
-        this._localToPhsicsSync();
-        game_entities_1.Service.get(physics_internal_gateway_1.PhysicsInternalGateway)
-            .subscribeToPhysicsStep(physicsWorldID, ({ time, delta }) => this._step(time, delta))
-            .attach(this);
-    }
-    convertToDTO() {
-        return {
-            entityID: this.id,
-            classID: this.classID,
-            position: this.position.value,
-            rotation: this.rotation.value,
-            velocity: this.velocity.value,
-            rotationalSpeed: this.rotationalSpeed.value
-        };
-    }
-    _step(time, delta) {
-        this._ignorePositionUpdate = true;
-        this._ignoreRotationUpdate = true;
-        this._ignoreVelocityUpdate = true;
-        this._ignoreRotationalSpeedUpdate = true;
-        this._phsicsToLocalSync();
-    }
-    _phsicsToLocalSync() {
-        this.position.value = p2js_helper_1.P2JSHelper.arrayToVector(this.p2Body.position);
-        this.rotation.value = new helpers_lib_1.Radian(this.p2Body.angle);
-        this.velocity.value = p2js_helper_1.P2JSHelper.arrayToVector(this.p2Body.velocity);
-        this.rotationalSpeed.value = this.p2Body.angularVelocity;
-    }
-    _localToPhsicsSync() {
-        this.position
-            .subscribe(position => {
-            if (this._ignorePositionUpdate) {
-                this._ignorePositionUpdate = false;
-            }
-            else {
-                this.p2Body.position = [position.x, position.y];
-            }
-        })
-            .attach(this);
-        this.rotation
-            .subscribe(rotation => {
-            if (this._ignoreRotationUpdate) {
-                this._ignoreRotationUpdate = false;
-            }
-            else {
-                this.p2Body.angle = rotation.value;
-            }
-        })
-            .attach(this);
-        this.velocity
-            .subscribe(velocity => {
-            if (this._ignoreVelocityUpdate) {
-                this._ignoreVelocityUpdate = false;
-            }
-            else {
-                this.p2Body.velocity = [velocity.x, velocity.y];
-            }
-        })
-            .attach(this);
-        this.rotationalSpeed
-            .subscribe(rotationalSpeed => {
-            if (this._ignoreRotationalSpeedUpdate) {
-                this._ignoreRotationalSpeedUpdate = false;
-            }
-            else {
-                this.p2Body.angularVelocity = rotationalSpeed;
-            }
-        })
-            .attach(this);
-    }
-}
-exports.MovablePhysicsEntity = MovablePhysicsEntity;
-//# sourceMappingURL=movable-physics-entity.js.map

package/dist/physics/entity-types/physics-entity.d.ts

@@ -1,30 +0,0 @@
-import { Action } from 'actions-lib';
-import { Entity } from '../../game-entities';
-import { CollisionReport, PhysicsBodyDTO, PhysicsEntityDefinition } from '../interfaces';
-import { PhysicsBodyGroup } from '../libs/physics-body-groups';
-export declare abstract class PhysicsEntity extends Entity {
-    private static _p2BodyIDToPhysicsBody;
-    private static _physicsEntities;
-    static getFromP2BodyID(p2BodyID: number): PhysicsEntity | undefined;
-    static getFromP2BodyIDOrFail(p2BodyID: number): PhysicsEntity;
-    static getPhysicsInstanceOrFail(id: number): PhysicsEntity;
-    static getPhysicsEntities(): PhysicsEntity[];
-    readonly _onCollision: Action<readonly CollisionReport[]>;
-    readonly onCollision: import("actions-lib").Notifier<readonly CollisionReport[]>;
-    get area(): number;
-    get mass(): number;
-    get collisions(): readonly CollisionReport[];
-    readonly physicsWorldID: number;
-    readonly physicsBodyGroup: PhysicsBodyGroup;
-    readonly includeInPathfinding: boolean;
-    protected readonly type: 'dynamic' | 'static';
-    private readonly _physicsInternalGateway;
-    private _physicsGroup;
-    private _physicsMask;
-    private _area;
-    private _mass;
-    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition, type: 'dynamic' | 'static');
-    abstract convertToDTO(): PhysicsBodyDTO;
-    destroy(): void;
-    canCollideWith(target: PhysicsEntity): boolean;
-}

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

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhysicsEntity = void 0;
-const actions_lib_1 = require("actions-lib");
-const game_entities_1 = require("../../game-entities");
-const p2js_helper_1 = require("../libs/p2js.helper");
-const physics_internal_gateway_1 = require("../module/\u269C\uFE0Fgateways/physics-internal.gateway");
-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 getFromP2BodyIDOrFail(p2BodyID) {
-        let physicsBody = PhysicsEntity._p2BodyIDToPhysicsBody.get(p2BodyID);
-        if (!physicsBody) {
-            throw new Error(`PhysicsEntity with p2BodyID ${p2BodyID} not found`);
-        }
-        return physicsBody;
-    }
-    static getPhysicsInstanceOrFail(id) {
-        let physicsEntity = PhysicsEntity._physicsEntities.get(id);
-        if (!physicsEntity) {
-            throw new Error(`PhysicsEntity with id ${id} not found`);
-        }
-        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(physicsWorldID, physicsEntityDefinition, type) {
-        super();
-        this._onCollision = new actions_lib_1.Action();
-        this.onCollision = this._onCollision.notifier;
-        this.type = 'dynamic';
-        this._area = 0;
-        this._mass = 0;
-        /** @internal */
-        this._collisions = [];
-        this.physicsWorldID = physicsWorldID;
-        this._physicsInternalGateway = game_entities_1.Service.get(physics_internal_gateway_1.PhysicsInternalGateway);
-        let material = this._physicsInternalGateway.getMaterial(this.physicsWorldID, physicsEntityDefinition.shapeDefinition.materialName);
-        let materialDefinition = this._physicsInternalGateway.getMaterialDefinition(this.physicsWorldID, physicsEntityDefinition.shapeDefinition.materialName);
-        this.type = type;
-        this.physicsBodyGroup = physicsEntityDefinition.shapeDefinition.group;
-        this.includeInPathfinding = physicsEntityDefinition.includeOnPathfinding;
-        this._physicsGroup = this._physicsInternalGateway.getGroupConstant(this.physicsWorldID, this.physicsBodyGroup);
-        this._physicsMask = this._physicsInternalGateway.getMaskConstant(this.physicsWorldID, this.physicsBodyGroup);
-        this.p2Body = this._physicsInternalGateway.createBody(this.physicsWorldID, 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.value;
-        let addedToTheWorld = this._physicsInternalGateway.addBody(this.physicsWorldID, 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);
-    }
-    destroy() {
-        if (!this.destroyed) {
-            super.destroy();
-            this._physicsInternalGateway.removeBody(this.physicsWorldID, this.p2Body);
-            PhysicsEntity._p2BodyIDToPhysicsBody.delete(this.p2Body.id);
-            PhysicsEntity._physicsEntities.delete(this.id);
-        }
-    }
-    canCollideWith(target) {
-        return p2js_helper_1.P2JSHelper.arePhysicsGroupsCollidable(this._physicsGroup, this._physicsMask, target._physicsGroup, target._physicsMask);
-    }
-    /** @internal */
-    _setCollisionReports(collisionReports) {
-        this._collisions = collisionReports;
-        if (collisionReports.length > 0) {
-            this._onCollision.trigger(collisionReports);
-        }
-    }
-}
-exports.PhysicsEntity = PhysicsEntity;
-//# sourceMappingURL=physics-entity.js.map

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

@@ -1,19 +0,0 @@
-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;
-}

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

@@ -1,109 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.ClosestAvailableSpaceHelper = void 0;
-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));
-  }
-  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;
-      }
-    }
-  }
-  /**
-   * @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 };
-      }
-    }
-    while (queue.length > 0) {
-      const shiftedPoint = queue.shift();
-      if (shiftedPoint) {
-        const currentPoint = shiftedPoint;
-        const 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]) => {
-          const nextPoint = { x: currentPoint.x + dx, y: currentPoint.y + dy };
-          if (this.isWithinBounds(nextPoint) && !visited.has(`${nextPoint.x},${nextPoint.y}`)) {
-            queue.push(nextPoint);
-          }
-        });
-      }
-    }
-    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) {
-    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

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

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

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

@@ -1,118 +0,0 @@
-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();
-  });
-});
-//# sourceMappingURL=closest-available-space.helper.spec.js.map

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

@@ -1,7 +0,0 @@
-/// <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];
-}