bard-legends-framework 0.9.6 → 0.9.7

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

@@ -3,20 +3,20 @@ import { Vec2 } from 'helpers-lib';
 import { CollisionReport } from '../interfaces';
 export type OnCollisionCallbackFunciton = (collision: CollisionReport) => void;
 export declare class PhysicsCollision {
-    private p2BodyIdtoOnCollisionCallback;
-    private p2World;
-    private closestAvailableSpaceHelper?;
-    private mapSize;
-    constructor(p2World: p2.World, mapsize: Vec2);
-    update(time: number, delta: number): void;
-    isCollidingWithAnything(p2Body: p2.Body): boolean;
-    findClosestAvailableSpace(body: p2.Body): Vec2 | undefined;
-    onBodyAdded(body: p2.Body, onCollisionCallback: OnCollisionCallbackFunciton, markOnGrid: boolean): void;
-    onBodyRemoved(body: p2.Body): void;
-    private createClosestAvailableSpaceHelper;
-    private handleSpeedLimit;
-    private handleCollision;
-    private calculateImpactSeverity;
-    private getContactPointsOfCollision;
-    private getContactPointOfCollision;
+  private p2BodyIdtoOnCollisionCallback;
+  private p2World;
+  private closestAvailableSpaceHelper?;
+  private mapSize;
+  constructor(p2World: p2.World, mapsize: Vec2);
+  update(time: number, delta: number): void;
+  isCollidingWithAnything(p2Body: p2.Body): boolean;
+  findClosestAvailableSpace(body: p2.Body): Vec2 | undefined;
+  onBodyAdded(body: p2.Body, onCollisionCallback: OnCollisionCallbackFunciton, markOnGrid: boolean): void;
+  onBodyRemoved(body: p2.Body): void;
+  private createClosestAvailableSpaceHelper;
+  private handleSpeedLimit;
+  private handleCollision;
+  private calculateImpactSeverity;
+  private getContactPointsOfCollision;
+  private getContactPointOfCollision;
 }

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

@@ -1,135 +1,155 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsCollision = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const p2js_helper_1 = require("../helpers/p2js.helper");
-const closest_available_space_helper_1 = require("../helpers/closest-available-space.helper");
-const movable_physics_entity_1 = require("../entitity-types/movable-physics-entity");
+const helpers_lib_1 = require('helpers-lib');
+const p2js_helper_1 = require('../helpers/p2js.helper');
+const closest_available_space_helper_1 = require('../helpers/closest-available-space.helper');
+const movable_physics_entity_1 = require('../entitity-types/movable-physics-entity');
 const GRID_SIZE = 80;
 const HALF_DAMAGE_STIFFNESS = 100;
 const SPEED_LIMIT = 0.8;
 const ANGULAR_SPEED_LIMIT = 0.01;
 class PhysicsCollision {
-    constructor(p2World, mapsize) {
-        this.p2BodyIdtoOnCollisionCallback = new Map();
-        this.p2World = p2World;
-        this.mapSize = mapsize;
-        this.p2World.on('beginContact', (event) => {
-            let bodyA = event.bodyA;
-            let bodyB = event.bodyB;
-            let { contactPointA, contactPointB } = this.getContactPointsOfCollision(event);
-            let relativeVelocity = helpers_lib_1.Vector.getLength({
-                x: bodyA.velocity[0] - bodyB.velocity[0],
-                y: bodyA.velocity[1] - bodyB.velocity[1]
-            });
-            let stiffness = event.contactEquations[0].stiffness;
-            this.handleCollision({ body: bodyA, contactPoint: contactPointA, rotation: bodyA.angle, mass: bodyA.mass }, { body: bodyB, contactPoint: contactPointB, rotation: bodyB.angle, mass: bodyB.mass }, relativeVelocity, stiffness);
-        });
-        this.p2World.on('endContact', (event) => {
-            this.handleSpeedLimit(event.bodyA);
-            this.handleSpeedLimit(event.bodyB);
-        });
-    }
-    update(time, delta) {
-        this.closestAvailableSpaceHelper = undefined;
-    }
-    isCollidingWithAnything(p2Body) {
-        p2Body.aabbNeedsUpdate = true;
-        p2Body.updateAABB();
-        let overlappingBodies = this.p2World.broadphase.aabbQuery(this.p2World, p2Body.aabb);
-        return !!overlappingBodies.length;
-    }
-    findClosestAvailableSpace(body) {
-        if (!this.closestAvailableSpaceHelper) {
-            this.createClosestAvailableSpaceHelper();
-        }
-        body.aabbNeedsUpdate = true;
-        body.updateAABB();
-        let changeVector = this.closestAvailableSpaceHelper?.findClosestAvailableSpace(p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb));
-        return changeVector;
+  constructor(p2World, mapsize) {
+    this.p2BodyIdtoOnCollisionCallback = new Map();
+    this.p2World = p2World;
+    this.mapSize = mapsize;
+    this.p2World.on('beginContact', event => {
+      const bodyA = event.bodyA;
+      const bodyB = event.bodyB;
+      const { contactPointA, contactPointB } = this.getContactPointsOfCollision(event);
+      const relativeVelocity = helpers_lib_1.Vector.getLength({
+        x: bodyA.velocity[0] - bodyB.velocity[0],
+        y: bodyA.velocity[1] - bodyB.velocity[1]
+      });
+      const stiffness = event.contactEquations[0].stiffness;
+      this.handleCollision(
+        {
+          body: bodyA,
+          contactPoint: contactPointA,
+          rotation: bodyA.angle,
+          mass: bodyA.mass
+        },
+        {
+          body: bodyB,
+          contactPoint: contactPointB,
+          rotation: bodyB.angle,
+          mass: bodyB.mass
+        },
+        relativeVelocity,
+        stiffness
+      );
+    });
+    this.p2World.on('endContact', event => {
+      this.handleSpeedLimit(event.bodyA);
+      this.handleSpeedLimit(event.bodyB);
+    });
+  }
+  update(time, delta) {
+    this.closestAvailableSpaceHelper = undefined;
+  }
+  isCollidingWithAnything(p2Body) {
+    p2Body.aabbNeedsUpdate = true;
+    p2Body.updateAABB();
+    const overlappingBodies = this.p2World.broadphase.aabbQuery(this.p2World, p2Body.aabb);
+    return !!overlappingBodies.length;
+  }
+  findClosestAvailableSpace(body) {
+    if (!this.closestAvailableSpaceHelper) {
+      this.createClosestAvailableSpaceHelper();
     }
-    onBodyAdded(body, onCollisionCallback, markOnGrid) {
-        this.p2BodyIdtoOnCollisionCallback.set(body.id, onCollisionCallback);
-        if (markOnGrid && this.closestAvailableSpaceHelper) {
-            body.aabbNeedsUpdate = true;
-            body.updateAABB();
-            this.closestAvailableSpaceHelper.markObjectOnGrid(p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb));
-        }
+    body.aabbNeedsUpdate = true;
+    body.updateAABB();
+    const changeVector = this.closestAvailableSpaceHelper?.findClosestAvailableSpace(
+      p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb)
+    );
+    return changeVector;
+  }
+  onBodyAdded(body, onCollisionCallback, markOnGrid) {
+    this.p2BodyIdtoOnCollisionCallback.set(body.id, onCollisionCallback);
+    if (markOnGrid && this.closestAvailableSpaceHelper) {
+      body.aabbNeedsUpdate = true;
+      body.updateAABB();
+      this.closestAvailableSpaceHelper.markObjectOnGrid(p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb));
     }
-    onBodyRemoved(body) {
-        this.p2BodyIdtoOnCollisionCallback.delete(body.id);
+  }
+  onBodyRemoved(body) {
+    this.p2BodyIdtoOnCollisionCallback.delete(body.id);
+  }
+  createClosestAvailableSpaceHelper() {
+    const closestAvailableSpaceHelper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(
+      this.mapSize.x,
+      this.mapSize.y,
+      GRID_SIZE
+    );
+    this.p2World.bodies.forEach(body => {
+      body.updateAABB();
+      closestAvailableSpaceHelper.markObjectOnGrid(p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb));
+    });
+    this.closestAvailableSpaceHelper = closestAvailableSpaceHelper;
+  }
+  handleSpeedLimit(body) {
+    let velocity = p2js_helper_1.P2JSHelper.arrayToVec2(body.velocity);
+    if (helpers_lib_1.Vector.getLength(velocity) > SPEED_LIMIT) {
+      velocity = helpers_lib_1.Vector.normalize(velocity, SPEED_LIMIT);
+      body.velocity = p2js_helper_1.P2JSHelper.vec2ToArray(velocity);
     }
-    createClosestAvailableSpaceHelper() {
-        let closestAvailableSpaceHelper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(this.mapSize.x, this.mapSize.y, GRID_SIZE);
-        this.p2World.bodies.forEach(body => {
-            body.updateAABB();
-            closestAvailableSpaceHelper.markObjectOnGrid(p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb));
+    body.angularVelocity = Math.min(Math.max(body.angularVelocity, -ANGULAR_SPEED_LIMIT), ANGULAR_SPEED_LIMIT);
+  }
+  handleCollision(objectA, objectB, relativeVelocity, stiffness) {
+    const callbackA = this.p2BodyIdtoOnCollisionCallback.get(objectA.body.id);
+    const callbackB = this.p2BodyIdtoOnCollisionCallback.get(objectB.body.id);
+    const bodyA = movable_physics_entity_1.MovablePhysicsEntity.getFromP2BodyId(objectA.body.id);
+    const bodyB = movable_physics_entity_1.MovablePhysicsEntity.getFromP2BodyId(objectB.body.id);
+    if ((callbackA || callbackB) && bodyA && bodyB) {
+      const objectACollisionDetails = {
+        body: bodyA.convertToDTO(),
+        getPositionReletiveToObject: () =>
+          helpers_lib_1.Vector.rotate(objectA.contactPoint, helpers_lib_1.Radian.radianToVector(-objectA.rotation)),
+        getSeverity: () => this.calculateImpactSeverity(relativeVelocity, stiffness, objectA.mass, objectB.mass),
+        position: objectA.contactPoint
+      };
+      const objectBCollisionDetails = {
+        body: bodyB.convertToDTO(),
+        getPositionReletiveToObject: () =>
+          helpers_lib_1.Vector.rotate(objectB.contactPoint, helpers_lib_1.Radian.radianToVector(-objectB.rotation)),
+        getSeverity: () => this.calculateImpactSeverity(relativeVelocity, stiffness, objectB.mass, objectA.mass),
+        position: objectB.contactPoint
+      };
+      if (callbackA) {
+        callbackA({
+          self: objectACollisionDetails,
+          target: objectBCollisionDetails
         });
-        this.closestAvailableSpaceHelper = closestAvailableSpaceHelper;
-    }
-    handleSpeedLimit(body) {
-        let velocity = p2js_helper_1.P2JSHelper.arrayToVec2(body.velocity);
-        if (helpers_lib_1.Vector.getLength(velocity) > SPEED_LIMIT) {
-            velocity = helpers_lib_1.Vector.normalize(velocity, SPEED_LIMIT);
-            body.velocity = p2js_helper_1.P2JSHelper.vec2ToArray(velocity);
-        }
-        body.angularVelocity = Math.min(Math.max(body.angularVelocity, -ANGULAR_SPEED_LIMIT), ANGULAR_SPEED_LIMIT);
-    }
-    handleCollision(objectA, objectB, relativeVelocity, stiffness) {
-        let callbackA = this.p2BodyIdtoOnCollisionCallback.get(objectA.body.id);
-        let callbackB = this.p2BodyIdtoOnCollisionCallback.get(objectB.body.id);
-        let bodyA = movable_physics_entity_1.MovablePhysicsEntity.getFromP2BodyId(objectA.body.id);
-        let bodyB = movable_physics_entity_1.MovablePhysicsEntity.getFromP2BodyId(objectB.body.id);
-        if ((callbackA || callbackB) && bodyA && bodyB) {
-            let objectACollisionDetails = {
-                body: bodyA.convertToDTO(),
-                getPositionReletiveToObject: () => helpers_lib_1.Vector.rotate(objectA.contactPoint, helpers_lib_1.Radian.radianToVector(-objectA.rotation)),
-                getSeverity: () => this.calculateImpactSeverity(relativeVelocity, stiffness, objectA.mass, objectB.mass),
-                position: objectA.contactPoint
-            };
-            let objectBCollisionDetails = {
-                body: bodyB.convertToDTO(),
-                getPositionReletiveToObject: () => helpers_lib_1.Vector.rotate(objectB.contactPoint, helpers_lib_1.Radian.radianToVector(-objectB.rotation)),
-                getSeverity: () => this.calculateImpactSeverity(relativeVelocity, stiffness, objectB.mass, objectA.mass),
-                position: objectB.contactPoint
-            };
-            if (callbackA) {
-                callbackA({
-                    self: objectACollisionDetails,
-                    target: objectBCollisionDetails
-                });
-            }
-            if (callbackB) {
-                callbackB({
-                    self: objectBCollisionDetails,
-                    target: objectACollisionDetails
-                });
-            }
-        }
-    }
-    calculateImpactSeverity(relativeVelocity, stiffness, objectMass, targetMass) {
-        let massRatio = Math.min(targetMass / objectMass, Number.MAX_SAFE_INTEGER);
-        let impactMomentum = (2 * massRatio * relativeVelocity) / (1 + massRatio);
-        let stiffnessMultiplier = stiffness / (HALF_DAMAGE_STIFFNESS + stiffness);
-        return impactMomentum * stiffnessMultiplier;
-    }
-    getContactPointsOfCollision(event) {
-        return {
-            contactPointA: this.getContactPointOfCollision(event, event.bodyA.id),
-            contactPointB: this.getContactPointOfCollision(event, event.bodyB.id)
-        };
+      }
+      if (callbackB) {
+        callbackB({
+          self: objectBCollisionDetails,
+          target: objectACollisionDetails
+        });
+      }
     }
-    getContactPointOfCollision(event, bodyId) {
-        if (event.contactEquations[0].bodyA.id === bodyId) {
-            return p2js_helper_1.P2JSHelper.arrayToVec2(event.contactEquations[0].contactPointA);
-        }
-        else if (event.contactEquations[0].bodyB.id === bodyId) {
-            return p2js_helper_1.P2JSHelper.arrayToVec2(event.contactEquations[0].contactPointB);
-        }
-        else {
-            throw new Error('Collision bodyA are not matching contact equations.');
-        }
+  }
+  calculateImpactSeverity(relativeVelocity, stiffness, objectMass, targetMass) {
+    const massRatio = Math.min(targetMass / objectMass, Number.MAX_SAFE_INTEGER);
+    const impactMomentum = (2 * massRatio * relativeVelocity) / (1 + massRatio);
+    const stiffnessMultiplier = stiffness / (HALF_DAMAGE_STIFFNESS + stiffness);
+    return impactMomentum * stiffnessMultiplier;
+  }
+  getContactPointsOfCollision(event) {
+    return {
+      contactPointA: this.getContactPointOfCollision(event, event.bodyA.id),
+      contactPointB: this.getContactPointOfCollision(event, event.bodyB.id)
+    };
+  }
+  getContactPointOfCollision(event, bodyId) {
+    if (event.contactEquations[0].bodyA.id === bodyId) {
+      return p2js_helper_1.P2JSHelper.arrayToVec2(event.contactEquations[0].contactPointA);
+    } else if (event.contactEquations[0].bodyB.id === bodyId) {
+      return p2js_helper_1.P2JSHelper.arrayToVec2(event.contactEquations[0].contactPointB);
+    } else {
+      throw new Error('Collision bodyA are not matching contact equations.');
     }
+  }
 }
 exports.PhysicsCollision = PhysicsCollision;
-//# sourceMappingURL=physics-collision.js.map
+//# sourceMappingURL=physics-collision.js.map

package/dist/physics/sub-elements/physics-materials.d.ts

@@ -1,14 +1,19 @@
 import p2 from 'p2';
 import { BorderProperties, MaterialContactDefinition, MaterialDefinition } from '../interfaces';
 export declare class PhysicsMaterials {
-    private borderMaterial;
-    private materials;
-    private materialDefinitions;
-    constructor(p2World: p2.World, borderProperties: BorderProperties, materialDefinitions: ReadonlyArray<MaterialDefinition>, materialContactDefinitions: ReadonlyArray<MaterialContactDefinition>);
-    getBorderMaterial(): p2.Material;
-    getMaterial(name: string): p2.Material;
-    getMaterialDefinition(name: string): MaterialDefinition;
-    private addContactMaterials;
-    private getFullListOfMaterialContactDefinitions;
-    private addContactMaterialsWithBorder;
+  private borderMaterial;
+  private materials;
+  private materialDefinitions;
+  constructor(
+    p2World: p2.World,
+    borderProperties: BorderProperties,
+    materialDefinitions: ReadonlyArray<MaterialDefinition>,
+    materialContactDefinitions: ReadonlyArray<MaterialContactDefinition>
+  );
+  getBorderMaterial(): p2.Material;
+  getMaterial(name: string): p2.Material;
+  getMaterialDefinition(name: string): MaterialDefinition;
+  private addContactMaterials;
+  private getFullListOfMaterialContactDefinitions;
+  private addContactMaterialsWithBorder;
 }

package/dist/physics/sub-elements/physics-materials.js

@@ -1,107 +1,108 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+var __importDefault = (this && this.__importDefault) || (mod => (mod && mod.__esModule ? mod : { default: mod }));
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsMaterials = void 0;
-const p2_1 = __importDefault(require("p2"));
-const interfaces_1 = require("../interfaces");
+const p2_1 = __importDefault(require('p2'));
+const interfaces_1 = require('../interfaces');
 class PhysicsMaterials {
-    constructor(p2World, borderProperties, materialDefinitions, materialContactDefinitions) {
-        this.borderMaterial = new p2_1.default.Material();
-        this.materials = new Map();
-        this.materialDefinitions = new Map();
-        materialDefinitions.forEach(materialDefinition => {
-            this.materials.set(materialDefinition.name, new p2_1.default.Material());
-            this.materialDefinitions.set(materialDefinition.name, materialDefinition);
-        });
-        this.addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions);
+  constructor(p2World, borderProperties, materialDefinitions, materialContactDefinitions) {
+    this.borderMaterial = new p2_1.default.Material();
+    this.materials = new Map();
+    this.materialDefinitions = new Map();
+    materialDefinitions.forEach(materialDefinition => {
+      this.materials.set(materialDefinition.name, new p2_1.default.Material());
+      this.materialDefinitions.set(materialDefinition.name, materialDefinition);
+    });
+    this.addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions);
+  }
+  getBorderMaterial() {
+    return this.borderMaterial;
+  }
+  getMaterial(name) {
+    if (name === interfaces_1.BorderMaterialName) {
+      return this.borderMaterial;
+    } else {
+      const material = this.materials.get(name);
+      if (!material) {
+        throw new Error(`Could not find material with name ${name}.`);
+      }
+      return material;
     }
-    getBorderMaterial() {
-        return this.borderMaterial;
+  }
+  getMaterialDefinition(name) {
+    if (name === interfaces_1.BorderMaterialName) {
+      return {
+        name: interfaces_1.BorderMaterialName,
+        density: Number.MAX_SAFE_INTEGER,
+        velocityDrag: 1,
+        rotationalDrag: 1
+      };
+    } else {
+      const materialDefinition = this.materialDefinitions.get(name);
+      if (!materialDefinition) {
+        throw new Error(`Could not find material definition with name ${name}.`);
+      }
+      return materialDefinition;
     }
-    getMaterial(name) {
-        if (name === interfaces_1.BorderMaterialName) {
-            return this.borderMaterial;
+  }
+  addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions) {
+    this.getFullListOfMaterialContactDefinitions(
+      materialDefinitions.map(definition => definition.name),
+      materialContactDefinitions
+    ).forEach(contactDefinition => {
+      const materialA = this.getMaterial(contactDefinition.materialA);
+      const materialB = this.getMaterial(contactDefinition.materialB);
+      p2World.addContactMaterial(
+        new p2_1.default.ContactMaterial(materialA, materialB, {
+          friction: contactDefinition.friction,
+          restitution: contactDefinition.bounciness,
+          stiffness: contactDefinition.stiffness
+        })
+      );
+    });
+    this.addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions);
+  }
+  getFullListOfMaterialContactDefinitions(materialNames, materialContactDefinitions) {
+    const definedCombinations = new Map();
+    materialContactDefinitions.forEach(contactDefinition => {
+      let materialAMap = definedCombinations.get(contactDefinition.materialA);
+      if (!materialAMap) {
+        materialAMap = new Map();
+        definedCombinations.set(contactDefinition.materialA, materialAMap);
+      }
+      materialAMap.set(contactDefinition.materialB, contactDefinition);
+    });
+    const fullList = [];
+    materialNames.forEach((materialA, index) => {
+      for (let i = index; i < materialNames.length; i++) {
+        const materialB = materialNames[i];
+        const contactDefinition = definedCombinations.get(materialA)?.get(materialB);
+        if (contactDefinition) {
+          fullList.push(contactDefinition);
+        } else {
+          fullList.push({
+            materialA,
+            materialB,
+            friction: 0,
+            bounciness: 0,
+            stiffness: 1e6 // default p2js stiffness
+          });
         }
-        else {
-            let material = this.materials.get(name);
-            if (!material) {
-                throw new Error(`Could not find material with name ${name}.`);
-            }
-            return material;
-        }
-    }
-    getMaterialDefinition(name) {
-        if (name === interfaces_1.BorderMaterialName) {
-            return {
-                name: interfaces_1.BorderMaterialName,
-                density: Number.MAX_SAFE_INTEGER,
-                velocityDrag: 1,
-                rotationalDrag: 1
-            };
-        }
-        else {
-            let materialDefinition = this.materialDefinitions.get(name);
-            if (!materialDefinition) {
-                throw new Error(`Could not find material definition with name ${name}.`);
-            }
-            return materialDefinition;
-        }
-    }
-    addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions) {
-        this.getFullListOfMaterialContactDefinitions(materialDefinitions.map(definition => definition.name), materialContactDefinitions).forEach(contactDefinition => {
-            let materialA = this.getMaterial(contactDefinition.materialA);
-            let materialB = this.getMaterial(contactDefinition.materialB);
-            p2World.addContactMaterial(new p2_1.default.ContactMaterial(materialA, materialB, {
-                friction: contactDefinition.friction,
-                restitution: contactDefinition.bounciness,
-                stiffness: contactDefinition.stiffness
-            }));
-        });
-        this.addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions);
-    }
-    getFullListOfMaterialContactDefinitions(materialNames, materialContactDefinitions) {
-        let definedCombinations = new Map();
-        materialContactDefinitions.forEach(contactDefinition => {
-            let materialAMap = definedCombinations.get(contactDefinition.materialA);
-            if (!materialAMap) {
-                materialAMap = new Map();
-                definedCombinations.set(contactDefinition.materialA, materialAMap);
-            }
-            materialAMap.set(contactDefinition.materialB, contactDefinition);
-        });
-        let fullList = [];
-        materialNames.forEach((materialA, index) => {
-            for (let i = index; i < materialNames.length; i++) {
-                let materialB = materialNames[i];
-                let contactDefinition = definedCombinations.get(materialA)?.get(materialB);
-                if (contactDefinition) {
-                    fullList.push(contactDefinition);
-                }
-                else {
-                    fullList.push({
-                        materialA,
-                        materialB,
-                        friction: 0,
-                        bounciness: 0,
-                        stiffness: 1e6 // default p2js stiffness
-                    });
-                }
-            }
-        });
-        return fullList;
-    }
-    addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions) {
-        materialDefinitions.forEach(materialDefinition => {
-            let materialA = this.getMaterial(materialDefinition.name);
-            p2World.addContactMaterial(new p2_1.default.ContactMaterial(materialA, this.borderMaterial, {
-                friction: borderProperties.friction,
-                restitution: borderProperties.bounciness,
-                stiffness: borderProperties.stiffness
-            }));
-        });
-    }
+      }
+    });
+    return fullList;
+  }
+  addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions) {
+    materialDefinitions.forEach(materialDefinition => {
+      const materialA = this.getMaterial(materialDefinition.name);
+      p2World.addContactMaterial(
+        new p2_1.default.ContactMaterial(materialA, this.borderMaterial, {
+          friction: borderProperties.friction,
+          restitution: borderProperties.bounciness,
+          stiffness: borderProperties.stiffness
+        })
+      );
+    });
+  }
 }
 exports.PhysicsMaterials = PhysicsMaterials;
-//# sourceMappingURL=physics-materials.js.map
+//# sourceMappingURL=physics-materials.js.map

package/dist/physics/sub-elements/physics-world-borders.d.ts

@@ -1,6 +1,6 @@
 import { Vec2 } from 'helpers-lib';
 import { PhysicsWorld } from '../physics-world';
 export declare class PhysicsWorldBorders {
-    static createBorders(physicsWorld: PhysicsWorld, mapSize: Vec2): void;
-    private static createBorder;
+  static createBorders(physicsWorld: PhysicsWorld, mapSize: Vec2): void;
+  private static createBorder;
 }

package/dist/physics/sub-elements/physics-world-borders.js

@@ -1,30 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsWorldBorders = void 0;
-const interfaces_1 = require("../interfaces");
-const physics_world_1 = require("../physics-world");
-const physics_body_groups_1 = require("./physics-body-groups");
+const interfaces_1 = require('../interfaces');
+const physics_world_1 = require('../physics-world');
+const physics_body_groups_1 = require('./physics-body-groups');
 class PhysicsWorldBorders {
-    static createBorders(physicsWorld, mapSize) {
-        this.createBorder(physicsWorld, { x: mapSize.x / 2, y: -50 }, { x: mapSize.x + 200, y: 100 }); // Top border
-        this.createBorder(physicsWorld, { x: mapSize.x / 2, y: mapSize.y + 50 }, { x: mapSize.x + 200, y: 100 }); // Bottom border
-        this.createBorder(physicsWorld, { x: -50, y: mapSize.y / 2 }, { x: 100, y: mapSize.y + 200 }); // Left border
-        this.createBorder(physicsWorld, { x: mapSize.x + 50, y: mapSize.y / 2 }, { x: 100, y: mapSize.y + 200 }); // Right border
-    }
-    static createBorder(physicsWorld, position, size) {
-        return new physics_world_1.BorderEntity(physicsWorld, {
-            shapeDefinition: {
-                materialName: interfaces_1.BorderMaterialName,
-                group: physics_body_groups_1.PhysicsBodyGroup.border,
-                shapeType: interfaces_1.PhysicsShapeType.rectangle,
-                shapeData: { size }
-            },
-            position,
-            rotation: 0,
-            addInEmptySpace: false,
-            includeOnPathfinding: true
-        }).attach(physicsWorld);
-    }
+  static createBorders(physicsWorld, mapSize) {
+    PhysicsWorldBorders.createBorder(physicsWorld, { x: mapSize.x / 2, y: -50 }, { x: mapSize.x + 200, y: 100 }); // Top border
+    PhysicsWorldBorders.createBorder(physicsWorld, { x: mapSize.x / 2, y: mapSize.y + 50 }, { x: mapSize.x + 200, y: 100 }); // Bottom border
+    PhysicsWorldBorders.createBorder(physicsWorld, { x: -50, y: mapSize.y / 2 }, { x: 100, y: mapSize.y + 200 }); // Left border
+    PhysicsWorldBorders.createBorder(physicsWorld, { x: mapSize.x + 50, y: mapSize.y / 2 }, { x: 100, y: mapSize.y + 200 }); // Right border
+  }
+  static createBorder(physicsWorld, position, size) {
+    return new physics_world_1.BorderEntity(physicsWorld, {
+      shapeDefinition: {
+        materialName: interfaces_1.BorderMaterialName,
+        group: physics_body_groups_1.PhysicsBodyGroup.border,
+        shapeType: interfaces_1.PhysicsShapeType.rectangle,
+        shapeData: { size }
+      },
+      position,
+      rotation: 0,
+      addInEmptySpace: false,
+      includeOnPathfinding: true
+    }).attach(physicsWorld);
+  }
 }
 exports.PhysicsWorldBorders = PhysicsWorldBorders;
-//# sourceMappingURL=physics-world-borders.js.map
+//# sourceMappingURL=physics-world-borders.js.map

package/dist/physics/sub-elements/raycasting/physics-body-explosion-hit.d.ts

@@ -2,15 +2,19 @@ import { Vector } from 'helpers-lib';
 import { RayCast, RayCastResult } from './ray-cast';
 import { PhysicsEntity } from '../../entitity-types/physics-entity';
 export declare class PhysicsBodyExplosionHit {
-    static convertRaysToBodyExplosionHits(rays: RayCast[], centerOfExplosion: Vector, totalCountOfRays: number): PhysicsBodyExplosionHit[];
-    private static groupRayResultsByBody;
-    readonly body: PhysicsEntity;
-    readonly isExternal: boolean;
-    readonly normal: Vector;
-    readonly fraction: number;
-    readonly ratioOfHits: number;
-    readonly raycastResults: ReadonlyArray<RayCastResult>;
-    readonly getHitPosition: () => Vector;
-    readonly getHitDistance: () => number;
-    private constructor();
+  static convertRaysToBodyExplosionHits(
+    rays: RayCast[],
+    centerOfExplosion: Vector,
+    totalCountOfRays: number
+  ): PhysicsBodyExplosionHit[];
+  private static groupRayResultsByBody;
+  readonly body: PhysicsEntity;
+  readonly isExternal: boolean;
+  readonly normal: Vector;
+  readonly fraction: number;
+  readonly ratioOfHits: number;
+  readonly raycastResults: ReadonlyArray<RayCastResult>;
+  readonly getHitPosition: () => Vector;
+  readonly getHitDistance: () => number;
+  private constructor();
 }