bard-legends-framework 0.9.6 → 0.10.0

package/dist/physics/sub-elements/available-spaces/physics-available-spaces.js

@@ -1,90 +1,102 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsAvailableSpaces = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const closest_available_space_helper_1 = require("../../../utilities/libraries/grid-algorithms/closest-available-space/closest-available-space.helper");
-const p2js_helper_1 = require("../../helpers/p2js.helper");
-const utilities_1 = require("../../../utilities");
-const physics_body_groups_1 = require("../elements/physics-body-groups");
-const physics_entity_1 = require("../../entitity-types/physics-entity");
-const vector_field_path_finder_1 = require("../../../utilities/libraries/grid-algorithms/vector-field-path-finder/vector-field-path-finder");
-const availability_grid_helper_1 = require("./helpers/availability-grid.helper");
+const helpers_lib_1 = require('helpers-lib');
+const closest_available_space_helper_1 = require('../../../utilities/libraries/grid-algorithms/closest-available-space/closest-available-space.helper');
+const p2js_helper_1 = require('../../helpers/p2js.helper');
+const utilities_1 = require('../../../utilities');
+const physics_body_groups_1 = require('../elements/physics-body-groups');
+const physics_entity_1 = require('../../entitity-types/physics-entity');
+const vector_field_path_finder_1 = require('../../../utilities/libraries/grid-algorithms/vector-field-path-finder/vector-field-path-finder');
+const availability_grid_helper_1 = require('./helpers/availability-grid.helper');
 const GRID_CELL_SIZE = 50;
 class PhysicsAvailableSpaces {
-    constructor(physicsAvailabilityGrid) {
-        this.physicsAvailabilityGrid = physicsAvailabilityGrid;
-        this.vectorFieldCache = new Map();
+  constructor(physicsAvailabilityGrid) {
+    this.physicsAvailabilityGrid = physicsAvailabilityGrid;
+    this.vectorFieldCache = new Map();
+  }
+  clear() {
+    this.vectorFieldCache.clear();
+  }
+  getAvailabilityGrid(physicsBodyGroup) {
+    const availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, physicsBodyGroup);
+    return availabilityGrid.map((value, position) => ({
+      position: availability_grid_helper_1.AvailabilityGridHelper.gridPositionToPosition(position, GRID_CELL_SIZE),
+      availability: value
+    }));
+  }
+  findClosestAvailableSpace(body, physicsBodyGroup) {
+    body.aabbNeedsUpdate = true;
+    body.updateAABB();
+    const changeVector = closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(
+      this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, physicsBodyGroup),
+      p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb),
+      GRID_CELL_SIZE
+    );
+    return changeVector;
+  }
+  findPathAStar(startingPosition, target, options) {
+    if (!options) {
+      options = {};
     }
-    clear() {
-        this.vectorFieldCache.clear();
+    if (options.includeDiagonals === undefined) {
+      options.includeDiagonals = false;
     }
-    getAvailabilityGrid(physicsBodyGroup) {
-        let availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, physicsBodyGroup);
-        return availabilityGrid.map((value, position) => ({
-            position: availability_grid_helper_1.AvailabilityGridHelper.gridPositionToPosition(position, GRID_CELL_SIZE),
-            availability: value
-        }));
+    if (options.collidableWithGroup === undefined) {
+      options.collidableWithGroup = physics_body_groups_1.PhysicsBodyGroup.none;
     }
-    findClosestAvailableSpace(body, physicsBodyGroup) {
-        body.aabbNeedsUpdate = true;
-        body.updateAABB();
-        let changeVector = closest_available_space_helper_1.ClosestAvailableSpaceHelper.findByConvertingGridSpace(this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, physicsBodyGroup), p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb), GRID_CELL_SIZE);
-        return changeVector;
+    let targetPosition;
+    let targetP2Body;
+    if (helpers_lib_1.Comparator.isString(target)) {
+      const targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
+      targetP2Body = targetEntity['p2Body'];
+      targetPosition = p2js_helper_1.P2JSHelper.arrayToVector(targetP2Body.position);
+    } else {
+      targetPosition = target;
     }
-    findPathAStar(startingPosition, target, options) {
-        if (!options) {
-            options = {};
-        }
-        if (options.includeDiagonals === undefined) {
-            options.includeDiagonals = false;
-        }
-        if (options.collidableWithGroup === undefined) {
-            options.collidableWithGroup = physics_body_groups_1.PhysicsBodyGroup.none;
-        }
-        let targetPosition;
-        let targetP2Body;
-        if (helpers_lib_1.Comparator.isString(target)) {
-            let targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
-            targetP2Body = targetEntity['p2Body'];
-            targetPosition = p2js_helper_1.P2JSHelper.arrayToVector(targetP2Body.position);
-        }
-        else {
-            targetPosition = target;
-        }
-        let startingGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(startingPosition, GRID_CELL_SIZE);
-        let targetGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(targetPosition, GRID_CELL_SIZE);
-        let availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, options.collidableWithGroup);
-        if (targetP2Body) {
-            let boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetP2Body.aabb);
-            let gridSpaceBoundingBox = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, GRID_CELL_SIZE);
-            availabilityGrid.safeSetArea(gridSpaceBoundingBox, true);
-        }
-        let result = utilities_1.PathFinder.findPath(availabilityGrid, startingGridPosition, targetGridPosition, {
-            includeDiagonals: options.includeDiagonals
-        });
-        result.path = result.path.map(gridPosition => availability_grid_helper_1.AvailabilityGridHelper.gridPositionToPosition(gridPosition, GRID_CELL_SIZE));
-        return result;
+    const startingGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(
+      startingPosition,
+      GRID_CELL_SIZE
+    );
+    const targetGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(
+      targetPosition,
+      GRID_CELL_SIZE
+    );
+    const availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, options.collidableWithGroup);
+    if (targetP2Body) {
+      const boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetP2Body.aabb);
+      const gridSpaceBoundingBox = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(boundingBox, GRID_CELL_SIZE);
+      availabilityGrid.safeSetArea(gridSpaceBoundingBox, true);
     }
-    findPathDirection(startingPosition, target, collidableWithGroup) {
-        let targetArea;
-        if (helpers_lib_1.Comparator.isString(target)) {
-            let targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
-            targetArea = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetEntity['p2Body'].aabb);
-        }
-        else {
-            targetArea = new helpers_lib_1.Rectangle(target, target);
-        }
-        let targetGridArea = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(targetArea, GRID_CELL_SIZE);
-        let cacheName = JSON.stringify({ targetGridArea, collidableWithGroup });
-        let vectorField = this.vectorFieldCache.get(cacheName);
-        if (!vectorField) {
-            let availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, collidableWithGroup);
-            vectorField = new vector_field_path_finder_1.VectorFieldPathFinder(targetGridArea, availabilityGrid);
-            this.vectorFieldCache.set(cacheName, vectorField);
-        }
-        let startingGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(startingPosition, GRID_CELL_SIZE);
-        return vectorField.getDirectionToTarget(startingGridPosition);
+    const result = utilities_1.PathFinder.findPath(availabilityGrid, startingGridPosition, targetGridPosition, {
+      includeDiagonals: options.includeDiagonals
+    });
+    result.path = result.path.map(gridPosition =>
+      availability_grid_helper_1.AvailabilityGridHelper.gridPositionToPosition(gridPosition, GRID_CELL_SIZE)
+    );
+    return result;
+  }
+  findPathDirection(startingPosition, target, collidableWithGroup) {
+    let targetArea;
+    if (helpers_lib_1.Comparator.isString(target)) {
+      const targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
+      targetArea = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetEntity['p2Body'].aabb);
+    } else {
+      targetArea = new helpers_lib_1.Rectangle(target, target);
     }
+    const targetGridArea = availability_grid_helper_1.AvailabilityGridHelper.areaToGridArea(targetArea, GRID_CELL_SIZE);
+    const cacheName = JSON.stringify({ targetGridArea, collidableWithGroup });
+    let vectorField = this.vectorFieldCache.get(cacheName);
+    if (!vectorField) {
+      const availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(GRID_CELL_SIZE, collidableWithGroup);
+      vectorField = new vector_field_path_finder_1.VectorFieldPathFinder(targetGridArea, availabilityGrid);
+      this.vectorFieldCache.set(cacheName, vectorField);
+    }
+    const startingGridPosition = availability_grid_helper_1.AvailabilityGridHelper.positionToGridPosition(
+      startingPosition,
+      GRID_CELL_SIZE
+    );
+    return vectorField.getDirectionToTarget(startingGridPosition);
+  }
 }
 exports.PhysicsAvailableSpaces = PhysicsAvailableSpaces;
-//# sourceMappingURL=physics-available-spaces.js.map
+//# sourceMappingURL=physics-available-spaces.js.map

package/dist/physics/sub-elements/collisions/contact-equation-orginiser.d.ts

@@ -2,17 +2,17 @@
 import { PhysicsEntity } from '../../entitity-types/physics-entity';
 import { CollisionReport } from '../../interfaces';
 export interface BodyWithCollisionReports {
-    p2Body: p2.Body;
-    entity: PhysicsEntity;
-    collisionReports: CollisionReport[];
+  p2Body: p2.Body;
+  entity: PhysicsEntity;
+  collisionReports: CollisionReport[];
 }
 export declare class ContactEquationOrganiser {
-    private bodiesInContactWith;
-    private collisionReports;
-    getAllBodiesWithTheirCollisionReports(): BodyWithCollisionReports[];
-    registerContactEquation(contactEquation: p2.ContactEquation): void;
-    reset(): void;
-    private getCollisionDetails;
-    private getCollisionDetail;
-    private getNormals;
+  private bodiesInContactWith;
+  private collisionReports;
+  getAllBodiesWithTheirCollisionReports(): BodyWithCollisionReports[];
+  registerContactEquation(contactEquation: p2.ContactEquation): void;
+  reset(): void;
+  private getCollisionDetails;
+  private getCollisionDetail;
+  private getNormals;
 }

package/dist/physics/sub-elements/collisions/contact-equation-orginiser.js

@@ -1,82 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.ContactEquationOrganiser = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const physics_entity_1 = require("../../entitity-types/physics-entity");
-const p2js_helper_1 = require("../../helpers/p2js.helper");
+const helpers_lib_1 = require('helpers-lib');
+const physics_entity_1 = require('../../entitity-types/physics-entity');
+const p2js_helper_1 = require('../../helpers/p2js.helper');
 class ContactEquationOrganiser {
-    constructor() {
-        this.bodiesInContactWith = new Map();
-        this.collisionReports = new Map();
+  constructor() {
+    this.bodiesInContactWith = new Map();
+    this.collisionReports = new Map();
+  }
+  getAllBodiesWithTheirCollisionReports() {
+    const result = [];
+    this.bodiesInContactWith.forEach((item, bodyId) => {
+      const collisionReports = this.collisionReports.get(bodyId) || [];
+      result.push({
+        p2Body: item.p2Body,
+        entity: item.entity,
+        collisionReports
+      });
+    });
+    return result;
+  }
+  registerContactEquation(contactEquation) {
+    const entityA = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyA.id);
+    const entityB = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyB.id);
+    if (entityA && entityB) {
+      this.bodiesInContactWith.set(contactEquation.bodyA.id, {
+        p2Body: contactEquation.bodyA,
+        entity: entityA
+      });
+      this.bodiesInContactWith.set(contactEquation.bodyB.id, {
+        p2Body: contactEquation.bodyB,
+        entity: entityB
+      });
+      const bodyACollisions = this.collisionReports.get(contactEquation.bodyA.id) || [];
+      const bodyBCollisions = this.collisionReports.get(contactEquation.bodyB.id) || [];
+      const { collisionDetailsA, collisionDetailsB } = this.getCollisionDetails(entityA, entityB, contactEquation);
+      bodyACollisions.push({
+        self: collisionDetailsA,
+        target: collisionDetailsB
+      });
+      bodyBCollisions.push({
+        self: collisionDetailsB,
+        target: collisionDetailsA
+      });
+      this.collisionReports.set(contactEquation.bodyA.id, bodyACollisions);
+      this.collisionReports.set(contactEquation.bodyB.id, bodyBCollisions);
+    } else {
+      console.warn('ContactEquationOrganiser: Entity not found for contact equation', contactEquation);
     }
-    getAllBodiesWithTheirCollisionReports() {
-        let result = [];
-        this.bodiesInContactWith.forEach((item, bodyId) => {
-            let collisionReports = this.collisionReports.get(bodyId) || [];
-            result.push({ p2Body: item.p2Body, entity: item.entity, collisionReports });
-        });
-        return result;
-    }
-    registerContactEquation(contactEquation) {
-        let entityA = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyA.id);
-        let entityB = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyB.id);
-        if (entityA && entityB) {
-            this.bodiesInContactWith.set(contactEquation.bodyA.id, { p2Body: contactEquation.bodyA, entity: entityA });
-            this.bodiesInContactWith.set(contactEquation.bodyB.id, { p2Body: contactEquation.bodyB, entity: entityB });
-            let bodyACollisions = this.collisionReports.get(contactEquation.bodyA.id) || [];
-            let bodyBCollisions = this.collisionReports.get(contactEquation.bodyB.id) || [];
-            let { collisionDetailsA, collisionDetailsB } = this.getCollisionDetails(entityA, entityB, contactEquation);
-            bodyACollisions.push({
-                self: collisionDetailsA,
-                target: collisionDetailsB
-            });
-            bodyBCollisions.push({
-                self: collisionDetailsB,
-                target: collisionDetailsA
-            });
-            this.collisionReports.set(contactEquation.bodyA.id, bodyACollisions);
-            this.collisionReports.set(contactEquation.bodyB.id, bodyBCollisions);
-        }
-        else {
-            console.warn('ContactEquationOrganiser: Entity not found for contact equation', contactEquation);
+  }
+  reset() {
+    this.bodiesInContactWith.clear();
+    this.collisionReports.clear();
+  }
+  getCollisionDetails(entityA, entityB, contactEquation) {
+    const dtoA = entityA.convertToDTO();
+    const dtoB = entityB.convertToDTO();
+    const contactPointA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointA);
+    const contactPointB = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointB);
+    const { normalA, normalB } = this.getNormals(contactEquation);
+    return {
+      collisionDetailsA: this.getCollisionDetail(dtoA, contactEquation.bodyA.mass, contactPointA, normalA, entityA.area),
+      collisionDetailsB: this.getCollisionDetail(dtoB, contactEquation.bodyB.mass, contactPointB, normalB, entityB.area)
+    };
+  }
+  getCollisionDetail(physicsBodyDTOSelf, massSelf, contactPointSelf, normalSelf, areaSelf) {
+    let positionRelativeToObject;
+    return {
+      body: physicsBodyDTOSelf,
+      getPositionReletiveToObject: () => {
+        if (!positionRelativeToObject) {
+          positionRelativeToObject = contactPointSelf.rotate(helpers_lib_1.Radian.toVector(-physicsBodyDTOSelf.rotation));
         }
-    }
-    reset() {
-        this.bodiesInContactWith.clear();
-        this.collisionReports.clear();
-    }
-    getCollisionDetails(entityA, entityB, contactEquation) {
-        let dtoA = entityA.convertToDTO();
-        let dtoB = entityB.convertToDTO();
-        let contactPointA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointA);
-        let contactPointB = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointB);
-        let { normalA, normalB } = this.getNormals(contactEquation);
-        return {
-            collisionDetailsA: this.getCollisionDetail(dtoA, contactEquation.bodyA.mass, contactPointA, normalA, entityA.area),
-            collisionDetailsB: this.getCollisionDetail(dtoB, contactEquation.bodyB.mass, contactPointB, normalB, entityB.area)
-        };
-    }
-    getCollisionDetail(physicsBodyDTOSelf, massSelf, contactPointSelf, normalSelf, areaSelf) {
-        let positionRelativeToObject;
-        return {
-            body: physicsBodyDTOSelf,
-            getPositionReletiveToObject: () => {
-                if (!positionRelativeToObject) {
-                    positionRelativeToObject = contactPointSelf.rotate(helpers_lib_1.Radian.toVector(-physicsBodyDTOSelf.rotation));
-                }
-                return positionRelativeToObject;
-            },
-            position: contactPointSelf,
-            mass: massSelf,
-            area: areaSelf,
-            normal: normalSelf
-        };
-    }
-    getNormals(contactEquation) {
-        let contactEquationNormalA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.normalA);
-        let contactEquationNormalB = contactEquationNormalA.multiply(-1);
-        return { normalA: contactEquationNormalA, normalB: contactEquationNormalB };
-    }
+        return positionRelativeToObject;
+      },
+      position: contactPointSelf,
+      mass: massSelf,
+      area: areaSelf,
+      normal: normalSelf
+    };
+  }
+  getNormals(contactEquation) {
+    const contactEquationNormalA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.normalA);
+    const contactEquationNormalB = contactEquationNormalA.multiply(-1);
+    return { normalA: contactEquationNormalA, normalB: contactEquationNormalB };
+  }
 }
 exports.ContactEquationOrganiser = ContactEquationOrganiser;
-//# sourceMappingURL=contact-equation-orginiser.js.map
+//# sourceMappingURL=contact-equation-orginiser.js.map

package/dist/physics/sub-elements/collisions/physics-collision.d.ts

@@ -2,11 +2,11 @@
 import { CollisionReport } from '../../interfaces';
 export type OnCollisionCallbackFunciton = (collision: CollisionReport) => void;
 export declare class PhysicsCollision {
-    private p2World;
-    private contactEquationOrganiser;
-    constructor(p2World: p2.World);
-    update(time: number, delta: number): void;
-    isCollidingWithAnything(p2Body: p2.Body): boolean;
-    private setResults;
-    private handleSpeedLimit;
+  private p2World;
+  private contactEquationOrganiser;
+  constructor(p2World: p2.World);
+  update(time: number, delta: number): void;
+  isCollidingWithAnything(p2Body: p2.Body): boolean;
+  private setResults;
+  private handleSpeedLimit;
 }

package/dist/physics/sub-elements/collisions/physics-collision.js

@@ -1,51 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsCollision = void 0;
-const p2js_helper_1 = require("../../helpers/p2js.helper");
-const contact_equation_orginiser_1 = require("./contact-equation-orginiser");
-const physics_entity_1 = require("../../entitity-types/physics-entity");
+const p2js_helper_1 = require('../../helpers/p2js.helper');
+const contact_equation_orginiser_1 = require('./contact-equation-orginiser');
+const physics_entity_1 = require('../../entitity-types/physics-entity');
 const SPEED_LIMIT = 0.8;
 const ROTATIONAL_SPEED_LIMIT = 0.01;
 class PhysicsCollision {
-    constructor(p2World) {
-        this.contactEquationOrganiser = new contact_equation_orginiser_1.ContactEquationOrganiser();
-        this.p2World = p2World;
-        this.p2World.on('beginContact', (event) => {
-            event.contactEquations.forEach(contactEquation => {
-                this.contactEquationOrganiser.registerContactEquation(contactEquation);
-            });
-        });
-    }
-    update(time, delta) {
-        physics_entity_1.PhysicsEntity.getPhysicsEntities().forEach(entity => {
-            entity['_collisions'] = [];
-        });
-        this.p2World.narrowphase.contactEquations.forEach(contactEquation => {
-            this.contactEquationOrganiser.registerContactEquation(contactEquation);
-        });
-        this.setResults();
-        this.contactEquationOrganiser.reset();
-    }
-    isCollidingWithAnything(p2Body) {
-        p2Body.aabbNeedsUpdate = true;
-        p2Body.updateAABB();
-        let overlappingBodies = this.p2World.broadphase.aabbQuery(this.p2World, p2Body.aabb);
-        return overlappingBodies.length > 0;
-    }
-    setResults() {
-        this.contactEquationOrganiser.getAllBodiesWithTheirCollisionReports().forEach(bodiesAndContacts => {
-            this.handleSpeedLimit(bodiesAndContacts.p2Body);
-            bodiesAndContacts.entity['setCollisionReports'](bodiesAndContacts.collisionReports);
-        });
-    }
-    handleSpeedLimit(body) {
-        let velocity = p2js_helper_1.P2JSHelper.arrayToVector(body.velocity);
-        if (velocity.length > SPEED_LIMIT) {
-            velocity = velocity.normalize(SPEED_LIMIT);
-            body.velocity = p2js_helper_1.P2JSHelper.vectorToArray(velocity);
-        }
-        body.angularVelocity = Math.min(Math.max(body.angularVelocity, -ROTATIONAL_SPEED_LIMIT), ROTATIONAL_SPEED_LIMIT);
+  constructor(p2World) {
+    this.contactEquationOrganiser = new contact_equation_orginiser_1.ContactEquationOrganiser();
+    this.p2World = p2World;
+    this.p2World.on('beginContact', event => {
+      event.contactEquations.forEach(contactEquation => {
+        this.contactEquationOrganiser.registerContactEquation(contactEquation);
+      });
+    });
+  }
+  update(time, delta) {
+    physics_entity_1.PhysicsEntity.getPhysicsEntities().forEach(entity => {
+      entity['_collisions'] = [];
+    });
+    this.p2World.narrowphase.contactEquations.forEach(contactEquation => {
+      this.contactEquationOrganiser.registerContactEquation(contactEquation);
+    });
+    this.setResults();
+    this.contactEquationOrganiser.reset();
+  }
+  isCollidingWithAnything(p2Body) {
+    p2Body.aabbNeedsUpdate = true;
+    p2Body.updateAABB();
+    const overlappingBodies = this.p2World.broadphase.aabbQuery(this.p2World, p2Body.aabb);
+    return overlappingBodies.length > 0;
+  }
+  setResults() {
+    this.contactEquationOrganiser.getAllBodiesWithTheirCollisionReports().forEach(bodiesAndContacts => {
+      this.handleSpeedLimit(bodiesAndContacts.p2Body);
+      bodiesAndContacts.entity['setCollisionReports'](bodiesAndContacts.collisionReports);
+    });
+  }
+  handleSpeedLimit(body) {
+    let velocity = p2js_helper_1.P2JSHelper.arrayToVector(body.velocity);
+    if (velocity.length > SPEED_LIMIT) {
+      velocity = velocity.normalize(SPEED_LIMIT);
+      body.velocity = p2js_helper_1.P2JSHelper.vectorToArray(velocity);
     }
+    body.angularVelocity = Math.min(Math.max(body.angularVelocity, -ROTATIONAL_SPEED_LIMIT), ROTATIONAL_SPEED_LIMIT);
+  }
 }
 exports.PhysicsCollision = PhysicsCollision;
-//# sourceMappingURL=physics-collision.js.map
+//# sourceMappingURL=physics-collision.js.map

package/dist/physics/sub-elements/elements/physics-body-groups.d.ts

@@ -1,15 +1,15 @@
 export declare enum PhysicsBodyGroup {
-    none = 0,
-    border = 1,
-    friend = 2,
-    friendProjectile = 3,
-    enemy = 4,
-    enemyProjectile = 5,
-    neutral = 6,
-    explosion = 7
+  none = 0,
+  border = 1,
+  friend = 2,
+  friendProjectile = 3,
+  enemy = 4,
+  enemyProjectile = 5,
+  neutral = 6,
+  explosion = 7
 }
 export declare class PhysicsBodyGroups {
-    static getGroupConstant(group: PhysicsBodyGroup): number;
-    static getMaskConstant(group: PhysicsBodyGroup): number;
-    static canCollide(group1: PhysicsBodyGroup, group2: PhysicsBodyGroup): boolean;
+  static getGroupConstant(group: PhysicsBodyGroup): number;
+  static getMaskConstant(group: PhysicsBodyGroup): number;
+  static canCollide(group1: PhysicsBodyGroup, group2: PhysicsBodyGroup): boolean;
 }