bard-legends-framework 0.12.1 → 1.0.0-rc1

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

@@ -1,77 +0,0 @@
-var __decorate =
-  (this && this.__decorate) ||
-  ((decorators, target, key, desc) => {
-    var c = arguments.length,
-      r = c < 3 ? target : desc === null ? (desc = Object.getOwnPropertyDescriptor(target, key)) : desc,
-      d;
-    if (typeof Reflect === 'object' && typeof Reflect.decorate === 'function')
-      r = Reflect.decorate(decorators, target, key, desc);
-    else
-      for (var i = decorators.length - 1; i >= 0; i--)
-        if ((d = decorators[i])) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-  });
-var __metadata =
-  (this && this.__metadata) ||
-  ((k, v) => {
-    if (typeof Reflect === 'object' && typeof Reflect.metadata === 'function') return Reflect.metadata(k, v);
-  });
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsWorldBorders = exports.BorderEntity = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const interfaces_1 = require('../../interfaces');
-const physics_body_groups_1 = require('./physics-body-groups');
-const game_entities_1 = require('../../../game-entities');
-const immovable_physics_entity_1 = require('../../entitity-types/immovable-physics-entity');
-let BorderEntity = class BorderEntity extends immovable_physics_entity_1.ImmovablePhysicsEntity {
-  // TODO: check - physicsWorld type is removed because, it is giving "PhysicsWorld cannot be accessed before it's initialization".
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  constructor(physicsWorld, physicsEntityDefinition) {
-    super(physicsWorld, physicsEntityDefinition);
-  }
-};
-exports.BorderEntity = BorderEntity;
-exports.BorderEntity = BorderEntity = __decorate(
-  [(0, game_entities_1.EntityDecorator)(), __metadata('design:paramtypes', [Object, Object])],
-  BorderEntity
-);
-class PhysicsWorldBorders {
-  static createBorders(physicsWorld, mapSize) {
-    PhysicsWorldBorders.createBorder(
-      physicsWorld,
-      new helpers_lib_1.Vector(mapSize.x / 2, -50),
-      new helpers_lib_1.Vector(mapSize.x + 200, 100)
-    ); // Top border
-    PhysicsWorldBorders.createBorder(
-      physicsWorld,
-      new helpers_lib_1.Vector(mapSize.x / 2, mapSize.y + 50),
-      new helpers_lib_1.Vector(mapSize.x + 200, 100)
-    ); // Bottom border
-    PhysicsWorldBorders.createBorder(
-      physicsWorld,
-      new helpers_lib_1.Vector(-50, mapSize.y / 2),
-      new helpers_lib_1.Vector(100, mapSize.y + 200)
-    ); // Left border
-    PhysicsWorldBorders.createBorder(
-      physicsWorld,
-      new helpers_lib_1.Vector(mapSize.x + 50, mapSize.y / 2),
-      new helpers_lib_1.Vector(100, mapSize.y + 200)
-    ); // Right border
-  }
-  static createBorder(physicsWorld, position, size) {
-    return new 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

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

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

package/dist/physics/sub-elements/physics-body-groups.js

@@ -1,54 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsBodyGroups = exports.PhysicsBodyGroup = void 0;
-/* eslint-disable no-bitwise */
-const BORDER_GROUP = 2 ** 0; // 0b0001;
-const FRIEND_GROUP = 2 ** 1; // 0b0010;
-const ENEMY_GROUP = 2 ** 2; // 0b0100;
-const NEUTRAL_GROUP = 2 ** 3; // 0b1000;
-const BORDER_MASK = FRIEND_GROUP | ENEMY_GROUP | NEUTRAL_GROUP; // Borders only collide with bodies
-const FRIEND_MASK = ENEMY_GROUP | NEUTRAL_GROUP | BORDER_GROUP;
-const ENEMY_MASK = FRIEND_GROUP | NEUTRAL_GROUP | BORDER_GROUP;
-const NEUTRAL_MASK = FRIEND_GROUP | ENEMY_GROUP | NEUTRAL_GROUP | BORDER_GROUP;
-var PhysicsBodyGroup;
-(PhysicsBodyGroup => {
-  PhysicsBodyGroup[(PhysicsBodyGroup['none'] = 0)] = 'none';
-  PhysicsBodyGroup[(PhysicsBodyGroup['border'] = 1)] = 'border';
-  PhysicsBodyGroup[(PhysicsBodyGroup['friend'] = 2)] = 'friend';
-  PhysicsBodyGroup[(PhysicsBodyGroup['enemy'] = 3)] = 'enemy';
-  PhysicsBodyGroup[(PhysicsBodyGroup['neutral'] = 4)] = 'neutral';
-})(PhysicsBodyGroup || (exports.PhysicsBodyGroup = PhysicsBodyGroup = {}));
-class PhysicsBodyGroups {
-  static getGroupConstant(group) {
-    switch (group) {
-      case PhysicsBodyGroup.none:
-        return 0;
-      case PhysicsBodyGroup.border:
-        return BORDER_GROUP;
-      case PhysicsBodyGroup.friend:
-        return FRIEND_GROUP;
-      case PhysicsBodyGroup.enemy:
-        return ENEMY_GROUP;
-      case PhysicsBodyGroup.neutral:
-        return NEUTRAL_GROUP;
-    }
-  }
-  static getMaskConstant(group) {
-    switch (group) {
-      case PhysicsBodyGroup.none:
-        return 0;
-      case PhysicsBodyGroup.border:
-        return BORDER_MASK;
-      case PhysicsBodyGroup.friend:
-        return FRIEND_MASK;
-      case PhysicsBodyGroup.enemy:
-        return ENEMY_MASK;
-      case PhysicsBodyGroup.neutral:
-        return NEUTRAL_MASK;
-    }
-  }
-  static canCollide(group1, group2) {
-    return (PhysicsBodyGroups.getMaskConstant(group1) & PhysicsBodyGroups.getGroupConstant(group2)) !== 0;
-  }
-}
-exports.PhysicsBodyGroups = PhysicsBodyGroups;
-//# sourceMappingURL=physics-body-groups.js.map

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

@@ -1,22 +0,0 @@
-/// <reference types="p2" />
-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;
-}

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

@@ -1,155 +0,0 @@
-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 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 => {
-      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();
-    }
-    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);
-  }
-  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);
-    }
-    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
-        });
-      }
-      if (callbackB) {
-        callbackB({
-          self: objectBCollisionDetails,
-          target: objectACollisionDetails
-        });
-      }
-    }
-  }
-  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

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

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

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

@@ -1,108 +0,0 @@
-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');
-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);
-  }
-  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;
-    }
-  }
-  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;
-    }
-  }
-  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
-          });
-        }
-      }
-    });
-    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

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

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

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

@@ -1,29 +0,0 @@
-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');
-class PhysicsWorldBorders {
-  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

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

@@ -1,20 +0,0 @@
-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();
-}

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

@@ -1,65 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.PhysicsBodyExplosionHit = 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');
-class PhysicsBodyExplosionHit {
-  static convertRaysToBodyExplosionHits(rays, centerOfExplosion, totalCountOfRays) {
-    const rayResultGroupOfBodies = PhysicsBodyExplosionHit.groupRayResultsByBody(rays);
-    return [...rayResultGroupOfBodies.values()].map(
-      rayResultGroupOfABody => new PhysicsBodyExplosionHit(rayResultGroupOfABody, centerOfExplosion, totalCountOfRays)
-    );
-  }
-  static groupRayResultsByBody(rayCasts) {
-    const bodyToHitResults = new Map();
-    rayCasts.forEach(ray => {
-      ray.results.forEach(rayCastResult => {
-        const previousRecord = bodyToHitResults.get(rayCastResult.body);
-        if (previousRecord) {
-          const closestRaycastResult =
-            rayCastResult.fraction < previousRecord.closestRaycastResult.fraction
-              ? rayCastResult
-              : previousRecord.closestRaycastResult;
-          previousRecord.raycastResults.push(rayCastResult);
-          bodyToHitResults.set(rayCastResult.body, {
-            hitCount: previousRecord.hitCount + 1,
-            closestRaycastResult,
-            raycastResults: previousRecord.raycastResults,
-            isExternal: previousRecord.isExternal
-          });
-        } else {
-          const isExternal = rayCastResult.isExternal();
-          bodyToHitResults.set(rayCastResult.body, {
-            hitCount: 1,
-            closestRaycastResult: rayCastResult,
-            raycastResults: [rayCastResult],
-            isExternal
-          });
-        }
-      });
-    });
-    return bodyToHitResults;
-  }
-  constructor(rayResultGroupOfABody, centerOfExplosion, totalCountOfRays) {
-    this.ratioOfHits = rayResultGroupOfABody.hitCount / totalCountOfRays;
-    this.raycastResults = rayResultGroupOfABody.raycastResults;
-    if (rayResultGroupOfABody.isExternal) {
-      this.body = physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(rayResultGroupOfABody.closestRaycastResult.body.id);
-      this.getHitPosition = rayResultGroupOfABody.closestRaycastResult.hitPosition;
-      this.getHitDistance = rayResultGroupOfABody.closestRaycastResult.hitDistance;
-      this.isExternal = true;
-      this.normal = rayResultGroupOfABody.closestRaycastResult.normal;
-      this.fraction = rayResultGroupOfABody.closestRaycastResult.fraction;
-    } else {
-      const bodyPosition = p2js_helper_1.P2JSHelper.arrayToVector(rayResultGroupOfABody.closestRaycastResult.body.position);
-      this.body = physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(rayResultGroupOfABody.closestRaycastResult.body.id);
-      this.getHitPosition = () => centerOfExplosion;
-      this.getHitDistance = () => 0;
-      this.isExternal = false;
-      this.normal = helpers_lib_1.Vector.fromTo(bodyPosition, centerOfExplosion).normalize();
-      this.fraction = 0;
-    }
-  }
-}
-exports.PhysicsBodyExplosionHit = PhysicsBodyExplosionHit;
-//# sourceMappingURL=physics-body-explosion-hit.js.map

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

@@ -1,20 +0,0 @@
-import { Vector } from 'helpers-lib';
-import { PhysicsWorld } from '../../physics-world';
-import { PhysicsExplosionOptions } from '../../interfaces';
-import { PhysicsBodyExplosionHit } from './physics-body-explosion-hit';
-import { PhysicsBodyGroup } from '../elements/physics-body-groups';
-export declare class PhysicsExplosion {
-  static createExplosion(
-    centerOfExplosion: Vector,
-    radius: number,
-    physicsBodyGroup: PhysicsBodyGroup,
-    severity: number,
-    physicsWorld: PhysicsWorld,
-    options?: PhysicsExplosionOptions
-  ): PhysicsBodyExplosionHit[];
-  private static createRays;
-  private static applyForcesToBodies;
-  private static pushBody;
-  private static createExplosionDebugVisual;
-  private static getTotalCountOfRays;
-}