bard-legends-framework 0.9.6 → 0.9.7

package/dist/physics/module//360/237/223/220services/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.service");
-const debug_visuals_service_1 = require("./debug-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.service');
+const debug_visuals_service_1 = require('./debug-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, debugVisualsService) {
-        this.rayCastingService = rayCastingService;
-        this.debugVisualsService = debugVisualsService;
+  constructor(rayCastingService, debugVisualsService) {
+    this.rayCastingService = rayCastingService;
+    this.debugVisualsService = debugVisualsService;
+  }
+  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.debugVisualsService.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.debugVisualsService.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 = helpers_lib_1.Radian.toVector(rotation);
+    const lineDirection = helpers_lib_1.Radian.toVector(rotation + helpers_lib_1.Radian.get90);
+    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 = helpers_lib_1.Radian.toVector(rotation);
-        let lineDirection = helpers_lib_1.Radian.toVector(rotation + helpers_lib_1.Radian.get90);
-        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, debug_visuals_service_1.DebugVisualsService])
-], ElipticExplosionService);
-//# sourceMappingURL=eliptic-explosion.service.js.map
+    __metadata('design:paramtypes', [ray_casting_service_1.RayCastingService, debug_visuals_service_1.DebugVisualsService])
+  ],
+  ElipticExplosionService
+);
+//# sourceMappingURL=eliptic-explosion.service.js.map

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

@@ -4,11 +4,18 @@ import { PhysicsBodyGroup } from '../../libs/physics-body-groups';
 import { DebugVisualsService } from './debug-visuals.service';
 import { RayCastingService } from './ray-casting.service';
 export declare class ExplosionService {
-    private rayCastingService;
-    private debugVisualsService;
-    constructor(rayCastingService: RayCastingService, debugVisualsService: DebugVisualsService);
-    createExplosion(physicsWorldId: string, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
-    private createRays;
-    private applyForcesToBodies;
-    private getTotalCountOfRays;
+  private rayCastingService;
+  private debugVisualsService;
+  constructor(rayCastingService: RayCastingService, debugVisualsService: DebugVisualsService);
+  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/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 debug_visuals_service_1 = require("./debug-visuals.service");
-const ray_casting_service_1 = require("./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 debug_visuals_service_1 = require('./debug-visuals.service');
+const ray_casting_service_1 = require('./ray-casting.service');
 let ExplosionService = class ExplosionService {
-    constructor(rayCastingService, debugVisualsService) {
-        this.rayCastingService = rayCastingService;
-        this.debugVisualsService = debugVisualsService;
+  constructor(rayCastingService, debugVisualsService) {
+    this.rayCastingService = rayCastingService;
+    this.debugVisualsService = debugVisualsService;
+  }
+  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.debugVisualsService.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.debugVisualsService.createExplosionDebugVisual(physicsWorld, options.testLayerId, rayCasts, explosionCenter, radius, options.debugRayDuration);
+    return explosionHits;
+  }
+  createRays(explosionCenter, radius, physicsBodyGroup, totalCountOfRays, hitOnlyClosest, physicsWorld) {
+    const radianPerLine = helpers_lib_1.Radian.get360 / totalCountOfRays;
+    let directionVector = new helpers_lib_1.Vector(0, -radius);
+    const rotationVector = helpers_lib_1.Radian.toVector(radianPerLine);
+    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 = helpers_lib_1.Radian.get360 / totalCountOfRays;
-        let directionVector = new helpers_lib_1.Vector(0, -radius);
-        let rotationVector = helpers_lib_1.Radian.toVector(radianPerLine);
-        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, debug_visuals_service_1.DebugVisualsService])
-], ExplosionService);
-//# sourceMappingURL=explosion.service.js.map
+    __metadata('design:paramtypes', [ray_casting_service_1.RayCastingService, debug_visuals_service_1.DebugVisualsService])
+  ],
+  ExplosionService
+);
+//# sourceMappingURL=explosion.service.js.map

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

@@ -4,11 +4,19 @@ import { ExplosionHit, PhysicsExplosionOptions } from '../../⚜️gateways';
 import { RayCastingService } from '../ray-casting/ray-casting.service';
 import { TestVisualsService } from '../test-visuals/test-visuals.service';
 export declare class ElipticExplosionService {
-    private rayCastingService;
-    private testVisualsService;
-    constructor(rayCastingService: RayCastingService, testVisualsService: TestVisualsService);
-    createElipticExplosion(physicsWorldId: string, explosionCenter: Vector, rotation: Radian, size: Vector, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
-    private createRays;
-    private getWidthOfLine;
-    private applyForcesToBodies;
+  private rayCastingService;
+  private testVisualsService;
+  constructor(rayCastingService: RayCastingService, testVisualsService: TestVisualsService);
+  createElipticExplosion(
+    physicsWorldId: string,
+    explosionCenter: Vector,
+    rotation: Radian,
+    size: Vector,
+    physicsBodyGroup: PhysicsBodyGroup,
+    severity: number,
+    options?: PhysicsExplosionOptions
+  ): ExplosionHit[];
+  private createRays;
+  private getWidthOfLine;
+  private applyForcesToBodies;
 }