bard-legends-framework 0.9.6 → 0.9.7

package/dist/physics/module//360/237/223/220services/explosions/eliptic-explosion.service.js

@@ -1,102 +1,126 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (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;
+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) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  });
+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.ElipticExplosionService = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const game_entities_1 = require("../../../../game-entities");
-const ray_casting_service_1 = require("../ray-casting/ray-casting.service");
-const test_visuals_service_1 = require("../test-visuals/test-visuals.service");
-const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");
-const ray_cast_hit_converter_1 = require("./helpers/ray-cast-hit-converter");
-const p2js_helper_1 = require("../../../libs/p2js.helper");
+const helpers_lib_1 = require('helpers-lib');
+const game_entities_1 = require('../../../../game-entities');
+const ray_casting_service_1 = require('../ray-casting/ray-casting.service');
+const test_visuals_service_1 = require('../test-visuals/test-visuals.service');
+const physics_world_entity_1 = require('../../\uD83E\uDDCAentities/physics-world.entity');
+const ray_cast_hit_converter_1 = require('./helpers/ray-cast-hit-converter');
+const p2js_helper_1 = require('../../../libs/p2js.helper');
 const MIN_GAP_BETWEEN_LINES = 15;
 let ElipticExplosionService = class ElipticExplosionService {
-    constructor(rayCastingService, testVisualsService) {
-        this.rayCastingService = rayCastingService;
-        this.testVisualsService = testVisualsService;
+  constructor(rayCastingService, testVisualsService) {
+    this.rayCastingService = rayCastingService;
+    this.testVisualsService = testVisualsService;
+  }
+  createElipticExplosion(physicsWorldId, explosionCenter, rotation, size, physicsBodyGroup, severity, options) {
+    const physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    const rayCasts = this.createRays(
+      explosionCenter,
+      rotation,
+      size,
+      physicsBodyGroup,
+      options?.hitOnlyClosest === true,
+      physicsWorld
+    );
+    const explosionHitWithP2Bodies = ray_cast_hit_converter_1.RayCastHitConverter.toExplosionHits(rayCasts, false);
+    this.applyForcesToBodies(explosionHitWithP2Bodies, severity);
+    if (options?.testLayerId) {
+      this.testVisualsService.createElipticExplosionDebugVisual(
+        physicsWorld,
+        options.testLayerId,
+        rayCasts,
+        explosionCenter,
+        rotation,
+        size,
+        options.debugRayDuration
+      );
     }
-    createElipticExplosion(physicsWorldId, explosionCenter, rotation, size, physicsBodyGroup, severity, options) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
-        let rayCasts = this.createRays(explosionCenter, rotation, size, physicsBodyGroup, options?.hitOnlyClosest === true, physicsWorld);
-        let explosionHitWithP2Bodies = ray_cast_hit_converter_1.RayCastHitConverter.toExplosionHits(rayCasts, false);
-        this.applyForcesToBodies(explosionHitWithP2Bodies, severity);
-        if (options?.testLayerId) {
-            this.testVisualsService.createElipticExplosionDebugVisual(physicsWorld, options.testLayerId, rayCasts, explosionCenter, rotation, size, options.debugRayDuration);
+    return explosionHitWithP2Bodies.map(explosionHitWithP2Body => {
+      const { p2Body, ...explosionHit } = explosionHitWithP2Body;
+      return explosionHit;
+    });
+  }
+  createRays(explosionCenter, rotation, size, physicsBodyGroup, hitOnlyClosest, physicsWorld) {
+    const lines = [];
+    const centerDirection = rotation.toVector();
+    const lineDirection = rotation.add(helpers_lib_1.Radian.get90).toVector();
+    const horizontalVector = lineDirection.normalize(size.x);
+    lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(horizontalVector)));
+    lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(horizontalVector.multiply(-1))));
+    const verticalVector = centerDirection.normalize(size.y);
+    lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(verticalVector)));
+    lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(verticalVector.multiply(-1))));
+    const lineCount = Math.round(size.y / MIN_GAP_BETWEEN_LINES);
+    const gap = (size.y / (lineCount * 2 + 1)) * 2;
+    const gapVector = centerDirection.normalize(gap);
+    const width = size.x;
+    const heightSquared = size.y ** 2;
+    helpers_lib_1.ArrayHelper.createIntegerArray(lineCount).forEach(index => {
+      const distanceFromCenter = gap * (index + 1);
+      const distanceFromCenterVector = gapVector.multiply(index + 1);
+      const vector = lineDirection.normalize(this.getWidthOfLine(width, heightSquared, distanceFromCenter));
+      const center1 = explosionCenter.add(distanceFromCenterVector);
+      lines.push(new helpers_lib_1.Line(center1, center1.add(vector)));
+      lines.push(new helpers_lib_1.Line(center1, center1.add(vector.multiply(-1))));
+      const center2 = explosionCenter.add(distanceFromCenterVector.multiply(-1));
+      lines.push(new helpers_lib_1.Line(center2, center2.add(vector)));
+      lines.push(new helpers_lib_1.Line(center2, center2.add(vector.multiply(-1))));
+    });
+    return lines.map(line => {
+      if (hitOnlyClosest) {
+        const hit = this.rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
+        return { line, hits: hit ? [hit] : [] };
+      } else {
+        const hits = this.rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
+        return { line, hits };
+      }
+    });
+  }
+  getWidthOfLine(width, heightSquared, distanceFromCenter) {
+    return Math.sqrt(1 - distanceFromCenter ** 2 / heightSquared) * width;
+  }
+  applyForcesToBodies(explosionHits, severity) {
+    explosionHits.forEach(explosionHit => {
+      explosionHit.raycastResults.forEach(rayCastResult => {
+        let hitDirection;
+        let force;
+        if (rayCastResult.isExternal()) {
+          hitDirection = rayCastResult.line.fromTo;
+          force = severity * 2;
+        } else {
+          hitDirection = rayCastResult.line.fromTo.multiply(-1);
+          force = severity * (1 - rayCastResult.fraction) * 8;
         }
-        return explosionHitWithP2Bodies.map(explosionHitWithP2Body => {
-            let { p2Body, ...explosionHit } = explosionHitWithP2Body;
-            return explosionHit;
-        });
-    }
-    createRays(explosionCenter, rotation, size, physicsBodyGroup, hitOnlyClosest, physicsWorld) {
-        let lines = [];
-        let centerDirection = rotation.toVector();
-        let lineDirection = rotation.add(helpers_lib_1.Radian.get90).toVector();
-        let horizontalVector = lineDirection.normalize(size.x);
-        lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(horizontalVector)));
-        lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(horizontalVector.multiply(-1))));
-        let verticalVector = centerDirection.normalize(size.y);
-        lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(verticalVector)));
-        lines.push(new helpers_lib_1.Line(explosionCenter, explosionCenter.add(verticalVector.multiply(-1))));
-        let lineCount = Math.round(size.y / MIN_GAP_BETWEEN_LINES);
-        let gap = (size.y / (lineCount * 2 + 1)) * 2;
-        let gapVector = centerDirection.normalize(gap);
-        let width = size.x;
-        let heightSquared = Math.pow(size.y, 2);
-        helpers_lib_1.ArrayHelper.createIntegerArray(lineCount).forEach(index => {
-            let distanceFromCenter = gap * (index + 1);
-            let distanceFromCenterVector = gapVector.multiply(index + 1);
-            let vector = lineDirection.normalize(this.getWidthOfLine(width, heightSquared, distanceFromCenter));
-            let center1 = explosionCenter.add(distanceFromCenterVector);
-            lines.push(new helpers_lib_1.Line(center1, center1.add(vector)));
-            lines.push(new helpers_lib_1.Line(center1, center1.add(vector.multiply(-1))));
-            let center2 = explosionCenter.add(distanceFromCenterVector.multiply(-1));
-            lines.push(new helpers_lib_1.Line(center2, center2.add(vector)));
-            lines.push(new helpers_lib_1.Line(center2, center2.add(vector.multiply(-1))));
-        });
-        return lines.map(line => {
-            if (hitOnlyClosest) {
-                let hit = this.rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
-                return { line, hits: hit ? [hit] : [] };
-            }
-            else {
-                let hits = this.rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
-                return { line, hits };
-            }
-        });
-    }
-    getWidthOfLine(width, heightSquared, distanceFromCenter) {
-        return Math.sqrt(1 - Math.pow(distanceFromCenter, 2) / heightSquared) * width;
-    }
-    applyForcesToBodies(explosionHits, severity) {
-        explosionHits.forEach(explosionHit => {
-            explosionHit.raycastResults.forEach(rayCastResult => {
-                let hitDirection;
-                let force;
-                if (rayCastResult.isExternal()) {
-                    hitDirection = rayCastResult.line.fromTo;
-                    force = severity * 2;
-                }
-                else {
-                    hitDirection = rayCastResult.line.fromTo.multiply(-1);
-                    force = severity * (1 - rayCastResult.fraction) * 8;
-                }
-                p2js_helper_1.P2JSHelper.pushBody(rayCastResult.body, rayCastResult.hitPosition(), hitDirection, force);
-            });
-        });
-    }
+        p2js_helper_1.P2JSHelper.pushBody(rayCastResult.body, rayCastResult.hitPosition(), hitDirection, force);
+      });
+    });
+  }
 };
 exports.ElipticExplosionService = ElipticExplosionService;
-exports.ElipticExplosionService = ElipticExplosionService = __decorate([
+exports.ElipticExplosionService = ElipticExplosionService = __decorate(
+  [
     (0, game_entities_1.ServiceDecorator)(),
-    __metadata("design:paramtypes", [ray_casting_service_1.RayCastingService, test_visuals_service_1.TestVisualsService])
-], ElipticExplosionService);
-//# sourceMappingURL=eliptic-explosion.service.js.map
+    __metadata('design:paramtypes', [ray_casting_service_1.RayCastingService, test_visuals_service_1.TestVisualsService])
+  ],
+  ElipticExplosionService
+);
+//# sourceMappingURL=eliptic-explosion.service.js.map

package/dist/physics/module//360/237/223/220services/explosions/explosion.service.d.ts

@@ -4,11 +4,18 @@ import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 import { TestVisualsService } from '../test-visuals/test-visuals.service';
 import { RayCastingService } from '../ray-casting/ray-casting.service';
 export declare class ExplosionService {
-    private rayCastingService;
-    private testVisualsService;
-    constructor(rayCastingService: RayCastingService, testVisualsService: TestVisualsService);
-    createExplosion(physicsWorldId: string, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
-    private createRays;
-    private applyForcesToBodies;
-    private getTotalCountOfRays;
+  private rayCastingService;
+  private testVisualsService;
+  constructor(rayCastingService: RayCastingService, testVisualsService: TestVisualsService);
+  createExplosion(
+    physicsWorldId: string,
+    explosionCenter: Vector,
+    radius: number,
+    physicsBodyGroup: PhysicsBodyGroup,
+    severity: number,
+    options?: PhysicsExplosionOptions
+  ): ExplosionHit[];
+  private createRays;
+  private applyForcesToBodies;
+  private getTotalCountOfRays;
 }

package/dist/physics/module//360/237/223/220services/explosions/explosion.service.js

@@ -1,87 +1,112 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (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;
+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) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  });
+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.ExplosionService = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const game_entities_1 = require("../../../../game-entities");
-const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");
-const p2js_helper_1 = require("../../../libs/p2js.helper");
-const ray_cast_hit_converter_1 = require("./helpers/ray-cast-hit-converter");
-const test_visuals_service_1 = require("../test-visuals/test-visuals.service");
-const ray_casting_service_1 = require("../ray-casting/ray-casting.service");
+const helpers_lib_1 = require('helpers-lib');
+const game_entities_1 = require('../../../../game-entities');
+const physics_world_entity_1 = require('../../\uD83E\uDDCAentities/physics-world.entity');
+const p2js_helper_1 = require('../../../libs/p2js.helper');
+const ray_cast_hit_converter_1 = require('./helpers/ray-cast-hit-converter');
+const test_visuals_service_1 = require('../test-visuals/test-visuals.service');
+const ray_casting_service_1 = require('../ray-casting/ray-casting.service');
 let ExplosionService = class ExplosionService {
-    constructor(rayCastingService, testVisualsService) {
-        this.rayCastingService = rayCastingService;
-        this.testVisualsService = testVisualsService;
+  constructor(rayCastingService, testVisualsService) {
+    this.rayCastingService = rayCastingService;
+    this.testVisualsService = testVisualsService;
+  }
+  createExplosion(physicsWorldId, explosionCenter, radius, physicsBodyGroup, severity, options) {
+    const physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    const totalCountOfRays = this.getTotalCountOfRays(radius);
+    const rayCasts = this.createRays(
+      explosionCenter,
+      radius,
+      physicsBodyGroup,
+      totalCountOfRays,
+      options?.hitOnlyClosest === true,
+      physicsWorld
+    );
+    const explosionHits = ray_cast_hit_converter_1.RayCastHitConverter.toExplosionHits(rayCasts);
+    this.applyForcesToBodies(explosionCenter, radius, severity, totalCountOfRays, explosionHits);
+    if (options?.testLayerId) {
+      this.testVisualsService.createExplosionDebugVisual(
+        physicsWorld,
+        options.testLayerId,
+        rayCasts,
+        explosionCenter,
+        radius,
+        options.debugRayDuration
+      );
     }
-    createExplosion(physicsWorldId, explosionCenter, radius, physicsBodyGroup, severity, options) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
-        let totalCountOfRays = this.getTotalCountOfRays(radius);
-        let rayCasts = this.createRays(explosionCenter, radius, physicsBodyGroup, totalCountOfRays, options?.hitOnlyClosest === true, physicsWorld);
-        let explosionHits = ray_cast_hit_converter_1.RayCastHitConverter.toExplosionHits(rayCasts);
-        this.applyForcesToBodies(explosionCenter, radius, severity, totalCountOfRays, explosionHits);
-        if (options?.testLayerId) {
-            this.testVisualsService.createExplosionDebugVisual(physicsWorld, options.testLayerId, rayCasts, explosionCenter, radius, options.debugRayDuration);
+    return explosionHits;
+  }
+  createRays(explosionCenter, radius, physicsBodyGroup, totalCountOfRays, hitOnlyClosest, physicsWorld) {
+    const radianPerLine = new helpers_lib_1.Radian(helpers_lib_1.PI_360 / totalCountOfRays);
+    let directionVector = new helpers_lib_1.Vector(0, -radius);
+    const rotationVector = radianPerLine.toVector();
+    return helpers_lib_1.ArrayHelper.createEmptyArray(totalCountOfRays)
+      .map(() => {
+        const to = explosionCenter.add(directionVector);
+        directionVector = directionVector.rotate(rotationVector);
+        return new helpers_lib_1.Line(explosionCenter, to);
+      })
+      .map(line => {
+        if (hitOnlyClosest) {
+          const hit = this.rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
+          return { line, hits: hit ? [hit] : [] };
+        } else {
+          const hits = this.rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
+          return { line, hits };
         }
-        return explosionHits;
-    }
-    createRays(explosionCenter, radius, physicsBodyGroup, totalCountOfRays, hitOnlyClosest, physicsWorld) {
-        let radianPerLine = new helpers_lib_1.Radian(helpers_lib_1.PI_360 / totalCountOfRays);
-        let directionVector = new helpers_lib_1.Vector(0, -radius);
-        let rotationVector = radianPerLine.toVector();
-        return helpers_lib_1.ArrayHelper.createEmptyArray(totalCountOfRays)
-            .map(() => {
-            let to = explosionCenter.add(directionVector);
-            directionVector = directionVector.rotate(rotationVector);
-            return new helpers_lib_1.Line(explosionCenter, to);
-        })
-            .map(line => {
-            if (hitOnlyClosest) {
-                let hit = this.rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
-                return { line, hits: hit ? [hit] : [] };
-            }
-            else {
-                let hits = this.rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
-                return { line, hits };
-            }
-        });
-    }
-    applyForcesToBodies(explosionCenter, radius, severity, totalCountOfRays, explosionHits) {
-        explosionHits.forEach(explosionHit => {
-            if (explosionHit.isExternal) {
-                explosionHit.raycastResults.forEach(rayCastResult => {
-                    let force = severity * (1 - rayCastResult.fraction);
-                    p2js_helper_1.P2JSHelper.pushBody(rayCastResult.body, rayCastResult.hitPosition(), rayCastResult.line.fromTo, force);
-                });
-            }
-            else {
-                let vectorToCenter = helpers_lib_1.Vector.fromTo(explosionCenter, p2js_helper_1.P2JSHelper.arrayToVector(explosionHit.p2Body.position));
-                let fractionToCenter = vectorToCenter.length / radius;
-                let force = (severity * totalCountOfRays * fractionToCenter) / 2;
-                p2js_helper_1.P2JSHelper.pushBody(explosionHit.p2Body, explosionHit.getHitPosition(), vectorToCenter, force);
-            }
+      });
+  }
+  applyForcesToBodies(explosionCenter, radius, severity, totalCountOfRays, explosionHits) {
+    explosionHits.forEach(explosionHit => {
+      if (explosionHit.isExternal) {
+        explosionHit.raycastResults.forEach(rayCastResult => {
+          const force = severity * (1 - rayCastResult.fraction);
+          p2js_helper_1.P2JSHelper.pushBody(rayCastResult.body, rayCastResult.hitPosition(), rayCastResult.line.fromTo, force);
         });
+      } else {
+        const vectorToCenter = helpers_lib_1.Vector.fromTo(
+          explosionCenter,
+          p2js_helper_1.P2JSHelper.arrayToVector(explosionHit.p2Body.position)
+        );
+        const fractionToCenter = vectorToCenter.length / radius;
+        const force = (severity * totalCountOfRays * fractionToCenter) / 2;
+        p2js_helper_1.P2JSHelper.pushBody(explosionHit.p2Body, explosionHit.getHitPosition(), vectorToCenter, force);
+      }
+    });
+  }
+  getTotalCountOfRays(radius) {
+    if (radius > 100) {
+      return Math.floor(radius * 0.3);
+    } else {
+      return Math.floor(radius * 0.26 + 4);
     }
-    getTotalCountOfRays(radius) {
-        if (radius > 100) {
-            return Math.floor(radius * 0.3);
-        }
-        else {
-            return Math.floor(radius * 0.26 + 4);
-        }
-    }
+  }
 };
 exports.ExplosionService = ExplosionService;
-exports.ExplosionService = ExplosionService = __decorate([
+exports.ExplosionService = ExplosionService = __decorate(
+  [
     (0, game_entities_1.ServiceDecorator)(),
-    __metadata("design:paramtypes", [ray_casting_service_1.RayCastingService, test_visuals_service_1.TestVisualsService])
-], ExplosionService);
-//# sourceMappingURL=explosion.service.js.map
+    __metadata('design:paramtypes', [ray_casting_service_1.RayCastingService, test_visuals_service_1.TestVisualsService])
+  ],
+  ExplosionService
+);
+//# sourceMappingURL=explosion.service.js.map

package/dist/physics/module//360/237/223/220services/explosions/helpers/ray-cast-hit-converter.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="p2" />
 import { ExplosionHit, RayCast } from '../../../⚜️gateways';
 export interface ExplosionHitWithP2Body extends ExplosionHit {
-    p2Body: p2.Body;
+  p2Body: p2.Body;
 }
 export declare class RayCastHitConverter {
-    static toExplosionHits(rayCasts: RayCast[], allRaysStartingFromSamePosition?: boolean): ExplosionHitWithP2Body[];
-    private static convertRayResultGroupToExplosionHit;
+  static toExplosionHits(rayCasts: RayCast[], allRaysStartingFromSamePosition?: boolean): ExplosionHitWithP2Body[];
+  private static convertRayResultGroupToExplosionHit;
 }

package/dist/physics/module//360/237/223/220services/explosions/helpers/ray-cast-hit-converter.js

@@ -1,73 +1,77 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.RayCastHitConverter = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const physics_entity_1 = require("../../../../entity-types/physics-entity");
-const p2js_helper_1 = require("../../../../libs/p2js.helper");
+const helpers_lib_1 = require('helpers-lib');
+const physics_entity_1 = require('../../../../entity-types/physics-entity');
+const p2js_helper_1 = require('../../../../libs/p2js.helper');
 class RayCastHitConverter {
-    static toExplosionHits(rayCasts, allRaysStartingFromSamePosition = true) {
-        let bodyToHitResults = new Map();
-        rayCasts.forEach(rayCast => {
-            rayCast.hits.forEach(rayCastHit => {
-                let previousRecord = bodyToHitResults.get(rayCastHit.body);
-                if (previousRecord) {
-                    let closestRaycastResult = rayCastHit.fraction < previousRecord.closestRaycastHit.fraction ? rayCastHit : previousRecord.closestRaycastHit;
-                    previousRecord.rayCastHits.push(rayCastHit);
-                    bodyToHitResults.set(rayCastHit.body, {
-                        hitCount: previousRecord.hitCount + 1,
-                        closestRaycastHit: closestRaycastResult,
-                        rayCastHits: previousRecord.rayCastHits,
-                        isExternal: allRaysStartingFromSamePosition
-                            ? previousRecord.isExternal
-                            : previousRecord.isExternal && rayCastHit.isExternal(),
-                        explosionCenter: rayCastHit.line.from
-                    });
-                }
-                else {
-                    let isExternal = rayCastHit.isExternal();
-                    bodyToHitResults.set(rayCastHit.body, {
-                        hitCount: 1,
-                        closestRaycastHit: rayCastHit,
-                        rayCastHits: [rayCastHit],
-                        isExternal,
-                        explosionCenter: rayCastHit.line.from
-                    });
-                }
-            });
-        });
-        return [...bodyToHitResults.values()].map(rayResultGroupOfABody => this.convertRayResultGroupToExplosionHit(rayResultGroupOfABody, rayCasts.length));
-    }
-    static convertRayResultGroupToExplosionHit(rayResultGroupOfABody, totalCountOfRays) {
-        let ratioOfHits = rayResultGroupOfABody.hitCount / totalCountOfRays;
-        let raycastResults = rayResultGroupOfABody.rayCastHits;
-        if (rayResultGroupOfABody.isExternal) {
-            return {
-                body: physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(rayResultGroupOfABody.closestRaycastHit.body.id).convertToDTO(),
-                p2Body: rayResultGroupOfABody.closestRaycastHit.body,
-                isExternal: true,
-                normal: rayResultGroupOfABody.closestRaycastHit.normal,
-                fraction: rayResultGroupOfABody.closestRaycastHit.fraction,
-                ratioOfHits,
-                raycastResults,
-                getHitPosition: rayResultGroupOfABody.closestRaycastHit.hitPosition,
-                getHitDistance: rayResultGroupOfABody.closestRaycastHit.hitDistance
-            };
-        }
-        else {
-            let bodyPosition = p2js_helper_1.P2JSHelper.arrayToVector(rayResultGroupOfABody.closestRaycastHit.body.position);
-            return {
-                body: physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(rayResultGroupOfABody.closestRaycastHit.body.id).convertToDTO(),
-                p2Body: rayResultGroupOfABody.closestRaycastHit.body,
-                isExternal: false,
-                normal: helpers_lib_1.Vector.fromTo(bodyPosition, rayResultGroupOfABody.explosionCenter).normalize(),
-                fraction: 0,
-                ratioOfHits,
-                raycastResults,
-                getHitPosition: () => rayResultGroupOfABody.explosionCenter,
-                getHitDistance: () => 0
-            };
+  static toExplosionHits(rayCasts, allRaysStartingFromSamePosition = true) {
+    const bodyToHitResults = new Map();
+    rayCasts.forEach(rayCast => {
+      rayCast.hits.forEach(rayCastHit => {
+        const previousRecord = bodyToHitResults.get(rayCastHit.body);
+        if (previousRecord) {
+          const closestRaycastResult =
+            rayCastHit.fraction < previousRecord.closestRaycastHit.fraction ? rayCastHit : previousRecord.closestRaycastHit;
+          previousRecord.rayCastHits.push(rayCastHit);
+          bodyToHitResults.set(rayCastHit.body, {
+            hitCount: previousRecord.hitCount + 1,
+            closestRaycastHit: closestRaycastResult,
+            rayCastHits: previousRecord.rayCastHits,
+            isExternal: allRaysStartingFromSamePosition
+              ? previousRecord.isExternal
+              : previousRecord.isExternal && rayCastHit.isExternal(),
+            explosionCenter: rayCastHit.line.from
+          });
+        } else {
+          const isExternal = rayCastHit.isExternal();
+          bodyToHitResults.set(rayCastHit.body, {
+            hitCount: 1,
+            closestRaycastHit: rayCastHit,
+            rayCastHits: [rayCastHit],
+            isExternal,
+            explosionCenter: rayCastHit.line.from
+          });
         }
+      });
+    });
+    return [...bodyToHitResults.values()].map(rayResultGroupOfABody =>
+      RayCastHitConverter.convertRayResultGroupToExplosionHit(rayResultGroupOfABody, rayCasts.length)
+    );
+  }
+  static convertRayResultGroupToExplosionHit(rayResultGroupOfABody, totalCountOfRays) {
+    const ratioOfHits = rayResultGroupOfABody.hitCount / totalCountOfRays;
+    const raycastResults = rayResultGroupOfABody.rayCastHits;
+    if (rayResultGroupOfABody.isExternal) {
+      return {
+        body: physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(
+          rayResultGroupOfABody.closestRaycastHit.body.id
+        ).convertToDTO(),
+        p2Body: rayResultGroupOfABody.closestRaycastHit.body,
+        isExternal: true,
+        normal: rayResultGroupOfABody.closestRaycastHit.normal,
+        fraction: rayResultGroupOfABody.closestRaycastHit.fraction,
+        ratioOfHits,
+        raycastResults,
+        getHitPosition: rayResultGroupOfABody.closestRaycastHit.hitPosition,
+        getHitDistance: rayResultGroupOfABody.closestRaycastHit.hitDistance
+      };
+    } else {
+      const bodyPosition = p2js_helper_1.P2JSHelper.arrayToVector(rayResultGroupOfABody.closestRaycastHit.body.position);
+      return {
+        body: physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(
+          rayResultGroupOfABody.closestRaycastHit.body.id
+        ).convertToDTO(),
+        p2Body: rayResultGroupOfABody.closestRaycastHit.body,
+        isExternal: false,
+        normal: helpers_lib_1.Vector.fromTo(bodyPosition, rayResultGroupOfABody.explosionCenter).normalize(),
+        fraction: 0,
+        ratioOfHits,
+        raycastResults,
+        getHitPosition: () => rayResultGroupOfABody.explosionCenter,
+        getHitDistance: () => 0
+      };
     }
+  }
 }
 exports.RayCastHitConverter = RayCastHitConverter;
-//# sourceMappingURL=ray-cast-hit-converter.js.map
+//# sourceMappingURL=ray-cast-hit-converter.js.map

package/dist/physics/module//360/237/223/220services/helpers/ray-cast-hit-converter.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="p2" />
 import { ExplosionHit, RayCast } from '../../⚜️gateways';
 export interface ExplosionHitWithP2Body extends ExplosionHit {
-    p2Body: p2.Body;
+  p2Body: p2.Body;
 }
 export declare class RayCastHitConverter {
-    static toExplosionHits(rayCasts: RayCast[], allRaysStartingFromSamePosition?: boolean): ExplosionHitWithP2Body[];
-    private static convertRayResultGroupToExplosionHit;
+  static toExplosionHits(rayCasts: RayCast[], allRaysStartingFromSamePosition?: boolean): ExplosionHitWithP2Body[];
+  private static convertRayResultGroupToExplosionHit;
 }