bard-legends-framework 0.9.6 → 0.10.0

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

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+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");
+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) {
-        let rayResultGroupOfBodies = this.groupRayResultsByBody(rays);
-        return [...rayResultGroupOfBodies.values()].map(rayResultGroupOfABody => new PhysicsBodyExplosionHit(rayResultGroupOfABody, centerOfExplosion, totalCountOfRays));
-    }
-    static groupRayResultsByBody(rayCasts) {
-        let bodyToHitResults = new Map();
-        rayCasts.forEach(ray => {
-            ray.results.forEach(rayCastResult => {
-                let previousRecord = bodyToHitResults.get(rayCastResult.body);
-                if (previousRecord) {
-                    let 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 {
-                    let 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 {
-            let 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;
+  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
+//# sourceMappingURL=physics-body-explosion-hit.js.map

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

@@ -4,10 +4,17 @@ 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;
+  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;
 }

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

@@ -1,80 +1,115 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.PhysicsExplosion = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const pixi_1 = require("../../../pixi");
-const utilities_1 = require("../../../utilities");
-const p2js_helper_1 = require("../../helpers/p2js.helper");
-const ray_cast_1 = require("./ray-cast");
-const physics_body_explosion_hit_1 = require("./physics-body-explosion-hit");
+const helpers_lib_1 = require('helpers-lib');
+const pixi_1 = require('../../../pixi');
+const utilities_1 = require('../../../utilities');
+const p2js_helper_1 = require('../../helpers/p2js.helper');
+const ray_cast_1 = require('./ray-cast');
+const physics_body_explosion_hit_1 = require('./physics-body-explosion-hit');
 class PhysicsExplosion {
-    static createExplosion(centerOfExplosion, radius, physicsBodyGroup, severity, physicsWorld, options) {
-        let totalCountOfRays = this.getTotalCountOfRays(radius);
-        let rayCasts = this.createRays(centerOfExplosion, radius, physicsBodyGroup, totalCountOfRays, options?.hitOnlyClosest === true, physicsWorld);
-        let bodyExplosionHits = physics_body_explosion_hit_1.PhysicsBodyExplosionHit.convertRaysToBodyExplosionHits(rayCasts, centerOfExplosion, totalCountOfRays);
-        this.applyForcesToBodies(centerOfExplosion, radius, severity, totalCountOfRays, bodyExplosionHits);
-        if (options?.printRaysOn) {
-            this.createExplosionDebugVisual(rayCasts, centerOfExplosion, radius, options.printRaysOn, physicsWorld, options.debugRayDuration);
-        }
-        return bodyExplosionHits;
+  static createExplosion(centerOfExplosion, radius, physicsBodyGroup, severity, physicsWorld, options) {
+    const totalCountOfRays = PhysicsExplosion.getTotalCountOfRays(radius);
+    const rayCasts = PhysicsExplosion.createRays(
+      centerOfExplosion,
+      radius,
+      physicsBodyGroup,
+      totalCountOfRays,
+      options?.hitOnlyClosest === true,
+      physicsWorld
+    );
+    const bodyExplosionHits = physics_body_explosion_hit_1.PhysicsBodyExplosionHit.convertRaysToBodyExplosionHits(
+      rayCasts,
+      centerOfExplosion,
+      totalCountOfRays
+    );
+    PhysicsExplosion.applyForcesToBodies(centerOfExplosion, radius, severity, totalCountOfRays, bodyExplosionHits);
+    if (options?.printRaysOn) {
+      PhysicsExplosion.createExplosionDebugVisual(
+        rayCasts,
+        centerOfExplosion,
+        radius,
+        options.printRaysOn,
+        physicsWorld,
+        options.debugRayDuration
+      );
     }
-    static createRays(centerOfExplosion, 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 = centerOfExplosion.add(directionVector);
-            directionVector = directionVector.rotate(rotationVector);
-            let ray = new ray_cast_1.RayCast(centerOfExplosion, to, physicsWorld);
-            hitOnlyClosest ? ray.castClosest(physicsBodyGroup) : ray.castAllFirstContacts(physicsBodyGroup);
-            return ray;
+    return bodyExplosionHits;
+  }
+  static createRays(centerOfExplosion, 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 = centerOfExplosion.add(directionVector);
+      directionVector = directionVector.rotate(rotationVector);
+      const ray = new ray_cast_1.RayCast(centerOfExplosion, to, physicsWorld);
+      hitOnlyClosest ? ray.castClosest(physicsBodyGroup) : ray.castAllFirstContacts(physicsBodyGroup);
+      return ray;
+    });
+  }
+  static applyForcesToBodies(centerOfExplosion, radius, severity, totalCountOfRays, PhysicsBodyExplosionHits) {
+    PhysicsBodyExplosionHits.forEach(physicsBodyExplosionHit => {
+      if (physicsBodyExplosionHit.isExternal) {
+        physicsBodyExplosionHit.raycastResults.forEach(rayCastResult => {
+          const force = severity * (1 - rayCastResult.fraction);
+          PhysicsExplosion.pushBody(
+            rayCastResult.body,
+            rayCastResult.hitPosition(),
+            rayCastResult.fraction,
+            rayCastResult.rayCast.fromTo,
+            force
+          );
         });
+      } else {
+        const p2Body = physicsBodyExplosionHit.body['p2Body'];
+        const vectorToCenter = helpers_lib_1.Vector.fromTo(
+          centerOfExplosion,
+          p2js_helper_1.P2JSHelper.arrayToVector(p2Body.position)
+        );
+        const fractionToCenter = vectorToCenter.length / radius;
+        const force = (severity * totalCountOfRays * fractionToCenter) / 2;
+        PhysicsExplosion.pushBody(
+          p2Body,
+          physicsBodyExplosionHit.getHitPosition(),
+          physicsBodyExplosionHit.fraction,
+          vectorToCenter,
+          force
+        );
+      }
+    });
+  }
+  static pushBody(body, hitPosition, fraction, fromTo, severity) {
+    const force = fromTo.normalize(severity * (1 - fraction));
+    const relativePoint = [hitPosition.x - body.position[0], hitPosition.y - body.position[1]];
+    body.applyImpulse(p2js_helper_1.P2JSHelper.vectorToArray(force), relativePoint);
+  }
+  static createExplosionDebugVisual(rayCasts, position, radius, testLayerId, physicsWorld, duration = 300) {
+    const lineContainer = pixi_1.Container.create().parent(testLayerId).setAlpha(0.5).attach(physicsWorld);
+    pixi_1.Graphics.createCircle(radius, helpers_lib_1.ColorHelper.blue)
+      .parent(lineContainer)
+      .setPosition(position)
+      .setAlpha(0.5)
+      .attach(physicsWorld);
+    rayCasts.forEach(ray => {
+      const color = ray.results.length > 0 ? helpers_lib_1.ColorHelper.red : helpers_lib_1.ColorHelper.white;
+      pixi_1.Graphics.createVector(position, ray.to, color).parent(lineContainer).attach(physicsWorld);
+    });
+    new utilities_1.Animator(lineContainer, 'alpha', {
+      duration,
+      animation: new utilities_1.AnimationEaseIn()
+    })
+      .animate({ alpha: 0 })
+      .then(() => {
+        lineContainer.destroy();
+      });
+  }
+  static getTotalCountOfRays(radius) {
+    if (radius > 100) {
+      return Math.floor(radius * 0.3);
+    } else {
+      return Math.floor(radius * 0.26 + 4);
     }
-    static applyForcesToBodies(centerOfExplosion, radius, severity, totalCountOfRays, PhysicsBodyExplosionHits) {
-        PhysicsBodyExplosionHits.forEach(physicsBodyExplosionHit => {
-            if (physicsBodyExplosionHit.isExternal) {
-                physicsBodyExplosionHit.raycastResults.forEach(rayCastResult => {
-                    let force = severity * (1 - rayCastResult.fraction);
-                    this.pushBody(rayCastResult.body, rayCastResult.hitPosition(), rayCastResult.fraction, rayCastResult.rayCast.fromTo, force);
-                });
-            }
-            else {
-                let p2Body = physicsBodyExplosionHit.body['p2Body'];
-                let vectorToCenter = helpers_lib_1.Vector.fromTo(centerOfExplosion, p2js_helper_1.P2JSHelper.arrayToVector(p2Body.position));
-                let fractionToCenter = vectorToCenter.length / radius;
-                let force = (severity * totalCountOfRays * fractionToCenter) / 2;
-                this.pushBody(p2Body, physicsBodyExplosionHit.getHitPosition(), physicsBodyExplosionHit.fraction, vectorToCenter, force);
-            }
-        });
-    }
-    static pushBody(body, hitPosition, fraction, fromTo, severity) {
-        let force = fromTo.normalize(severity * (1 - fraction));
-        let relativePoint = [hitPosition.x - body.position[0], hitPosition.y - body.position[1]];
-        body.applyImpulse(p2js_helper_1.P2JSHelper.vectorToArray(force), relativePoint);
-    }
-    static createExplosionDebugVisual(rayCasts, position, radius, testLayerId, physicsWorld, duration = 300) {
-        let lineContainer = pixi_1.Container.create().parent(testLayerId).setAlpha(0.5).attach(physicsWorld);
-        pixi_1.Graphics.createCircle(radius, helpers_lib_1.ColorHelper.blue)
-            .parent(lineContainer)
-            .setPosition(position)
-            .setAlpha(0.5)
-            .attach(physicsWorld);
-        rayCasts.forEach(ray => {
-            let color = ray.results.length > 0 ? helpers_lib_1.ColorHelper.red : helpers_lib_1.ColorHelper.white;
-            pixi_1.Graphics.createVector(position, ray.to, color).parent(lineContainer).attach(physicsWorld);
-        });
-        new utilities_1.Animator(lineContainer, 'alpha', { duration, animation: new utilities_1.AnimationEaseIn() }).animate({ alpha: 0 }).then(() => {
-            lineContainer.destroy();
-        });
-    }
-    static getTotalCountOfRays(radius) {
-        if (radius > 100) {
-            return Math.floor(radius * 0.3);
-        }
-        else {
-            return Math.floor(radius * 0.26 + 4);
-        }
-    }
+  }
 }
 exports.PhysicsExplosion = PhysicsExplosion;
-//# sourceMappingURL=physics-explosion.js.map
+//# sourceMappingURL=physics-explosion.js.map

package/dist/physics/sub-elements/raycasting/ray-cast.d.ts

@@ -3,25 +3,25 @@ import p2 from 'p2';
 import { PhysicsWorld } from '../../physics-world';
 import { PhysicsBodyGroup } from '../elements/physics-body-groups';
 export interface RayCastResult {
-    readonly body: p2.Body;
-    readonly hitPosition: () => Vector;
-    readonly hitDistance: () => number;
-    readonly isExternal: () => boolean;
-    readonly normal: Vector;
-    readonly fraction: number;
-    readonly rayCast: RayCast;
+  readonly body: p2.Body;
+  readonly hitPosition: () => Vector;
+  readonly hitDistance: () => number;
+  readonly isExternal: () => boolean;
+  readonly normal: Vector;
+  readonly fraction: number;
+  readonly rayCast: RayCast;
 }
 export declare class RayCast {
-    readonly from: Vector;
-    readonly to: Vector;
-    private physicsWorld;
-    private _fromTo;
-    get fromTo(): Vector;
-    get length(): number;
-    private _results;
-    get results(): RayCastResult[];
-    constructor(from: Vector, to: Vector, physicsWorld: PhysicsWorld);
-    castClosest(physicsBodyGroup: PhysicsBodyGroup): RayCastResult | undefined;
-    castAllFirstContacts(physicsBodyGroup: PhysicsBodyGroup): RayCastResult[];
-    private convertP2RaycastResultToRaycastResult;
+  readonly from: Vector;
+  readonly to: Vector;
+  private physicsWorld;
+  private _fromTo;
+  get fromTo(): Vector;
+  get length(): number;
+  private _results;
+  get results(): RayCastResult[];
+  constructor(from: Vector, to: Vector, physicsWorld: PhysicsWorld);
+  castClosest(physicsBodyGroup: PhysicsBodyGroup): RayCastResult | undefined;
+  castAllFirstContacts(physicsBodyGroup: PhysicsBodyGroup): RayCastResult[];
+  private convertP2RaycastResultToRaycastResult;
 }

package/dist/physics/sub-elements/raycasting/ray-cast.js

@@ -1,106 +1,101 @@
-"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.RayCast = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const p2_1 = __importDefault(require("p2"));
-const p2js_helper_1 = require("../../helpers/p2js.helper");
-const physics_body_groups_1 = require("../elements/physics-body-groups");
+const helpers_lib_1 = require('helpers-lib');
+const p2_1 = __importDefault(require('p2'));
+const p2js_helper_1 = require('../../helpers/p2js.helper');
+const physics_body_groups_1 = require('../elements/physics-body-groups');
 class RayCast {
-    get fromTo() {
-        if (this._fromTo === undefined) {
-            this._fromTo = helpers_lib_1.Vector.fromTo(this.from, this.to);
-        }
-        return this._fromTo;
-    }
-    get length() {
-        return this.fromTo.length;
+  get fromTo() {
+    if (this._fromTo === undefined) {
+      this._fromTo = helpers_lib_1.Vector.fromTo(this.from, this.to);
     }
-    get results() {
-        return this._results;
+    return this._fromTo;
+  }
+  get length() {
+    return this.fromTo.length;
+  }
+  get results() {
+    return this._results;
+  }
+  constructor(from, to, physicsWorld) {
+    this._results = [];
+    this.from = from;
+    this.to = to;
+    this.physicsWorld = physicsWorld;
+  }
+  castClosest(physicsBodyGroup) {
+    const p2RaycastResult = new p2_1.default.RaycastResult();
+    const p2Ray = new p2_1.default.Ray({
+      mode: p2_1.default.Ray.CLOSEST,
+      from: p2js_helper_1.P2JSHelper.vectorToArray(this.from),
+      to: p2js_helper_1.P2JSHelper.vectorToArray(this.to),
+      collisionGroup: physics_body_groups_1.PhysicsBodyGroups.getGroupConstant(physicsBodyGroup),
+      collisionMask: physics_body_groups_1.PhysicsBodyGroups.getMaskConstant(physicsBodyGroup)
+    });
+    this.physicsWorld['p2World'].raycast(p2RaycastResult, p2Ray);
+    if (p2RaycastResult.hasHit()) {
+      const rayCastResult = this.convertP2RaycastResultToRaycastResult(p2RaycastResult);
+      this._results = [rayCastResult];
+      return rayCastResult;
+    } else {
+      this._results = [];
     }
-    constructor(from, to, physicsWorld) {
-        this._results = [];
-        this.from = from;
-        this.to = to;
-        this.physicsWorld = physicsWorld;
-    }
-    castClosest(physicsBodyGroup) {
-        let p2RaycastResult = new p2_1.default.RaycastResult();
-        let p2Ray = new p2_1.default.Ray({
-            mode: p2_1.default.Ray.CLOSEST,
-            from: p2js_helper_1.P2JSHelper.vectorToArray(this.from),
-            to: p2js_helper_1.P2JSHelper.vectorToArray(this.to),
-            collisionGroup: physics_body_groups_1.PhysicsBodyGroups.getGroupConstant(physicsBodyGroup),
-            collisionMask: physics_body_groups_1.PhysicsBodyGroups.getMaskConstant(physicsBodyGroup)
-        });
-        this.physicsWorld['p2World'].raycast(p2RaycastResult, p2Ray);
-        if (p2RaycastResult.hasHit()) {
-            let rayCastResult = this.convertP2RaycastResultToRaycastResult(p2RaycastResult);
-            this._results = [rayCastResult];
-            return rayCastResult;
+  }
+  castAllFirstContacts(physicsBodyGroup) {
+    const p2BodyToClosestRaycastResult = new Map();
+    const p2Ray = new p2_1.default.Ray({
+      mode: p2_1.default.Ray.ALL,
+      from: p2js_helper_1.P2JSHelper.vectorToArray(this.from),
+      to: p2js_helper_1.P2JSHelper.vectorToArray(this.to),
+      collisionGroup: physics_body_groups_1.PhysicsBodyGroups.getGroupConstant(physicsBodyGroup),
+      collisionMask: physics_body_groups_1.PhysicsBodyGroups.getMaskConstant(physicsBodyGroup),
+      callback: callbackResult => {
+        const previousItem = p2BodyToClosestRaycastResult.get(callbackResult.body);
+        if (!p2BodyToClosestRaycastResult.has(callbackResult.body) || callbackResult.fraction < previousItem.fraction) {
+          p2BodyToClosestRaycastResult.set(callbackResult.body, this.convertP2RaycastResultToRaycastResult(callbackResult));
+        } else if (callbackResult.fraction === previousItem.fraction && previousItem.isExternal()) {
+          // If the raycast starts from inside an object with multiple shapes, there is a chance that first hit is wrongfuly seen as external hit.
+          p2BodyToClosestRaycastResult.set(callbackResult.body, this.convertP2RaycastResultToRaycastResult(callbackResult));
         }
-        else {
-            this._results = [];
+      }
+    });
+    this.physicsWorld['p2World'].raycast(new p2_1.default.RaycastResult(), p2Ray);
+    const rayCastResults = Array.from(p2BodyToClosestRaycastResult.values());
+    this._results = rayCastResults;
+    return rayCastResults;
+  }
+  convertP2RaycastResultToRaycastResult(p2RaycastResult) {
+    const fraction = p2RaycastResult.fraction;
+    const normal = p2js_helper_1.P2JSHelper.arrayToVector(p2RaycastResult.normal);
+    let hitPosition;
+    let hitDistance;
+    let isExternal;
+    return {
+      body: p2RaycastResult.body,
+      hitPosition: () => {
+        if (hitPosition === undefined) {
+          hitPosition = this.from.lerp(this.to, fraction);
         }
-    }
-    castAllFirstContacts(physicsBodyGroup) {
-        let p2BodyToClosestRaycastResult = new Map();
-        let p2Ray = new p2_1.default.Ray({
-            mode: p2_1.default.Ray.ALL,
-            from: p2js_helper_1.P2JSHelper.vectorToArray(this.from),
-            to: p2js_helper_1.P2JSHelper.vectorToArray(this.to),
-            collisionGroup: physics_body_groups_1.PhysicsBodyGroups.getGroupConstant(physicsBodyGroup),
-            collisionMask: physics_body_groups_1.PhysicsBodyGroups.getMaskConstant(physicsBodyGroup),
-            callback: callbackResult => {
-                let previousItem = p2BodyToClosestRaycastResult.get(callbackResult.body);
-                if (!p2BodyToClosestRaycastResult.has(callbackResult.body) || callbackResult.fraction < previousItem.fraction) {
-                    p2BodyToClosestRaycastResult.set(callbackResult.body, this.convertP2RaycastResultToRaycastResult(callbackResult));
-                }
-                else if (callbackResult.fraction === previousItem.fraction && previousItem.isExternal()) {
-                    // If the raycast starts from inside an object with multiple shapes, there is a chance that first hit is wrongfuly seen as external hit.
-                    p2BodyToClosestRaycastResult.set(callbackResult.body, this.convertP2RaycastResultToRaycastResult(callbackResult));
-                }
-            }
-        });
-        this.physicsWorld['p2World'].raycast(new p2_1.default.RaycastResult(), p2Ray);
-        let rayCastResults = Array.from(p2BodyToClosestRaycastResult.values());
-        this._results = rayCastResults;
-        return rayCastResults;
-    }
-    convertP2RaycastResultToRaycastResult(p2RaycastResult) {
-        let fraction = p2RaycastResult.fraction;
-        let normal = p2js_helper_1.P2JSHelper.arrayToVector(p2RaycastResult.normal);
-        let hitPosition;
-        let hitDistance;
-        let isExternal;
-        return {
-            body: p2RaycastResult.body,
-            hitPosition: () => {
-                if (hitPosition === undefined) {
-                    hitPosition = this.from.lerp(this.to, fraction);
-                }
-                return hitPosition;
-            },
-            hitDistance: () => {
-                if (hitDistance === undefined) {
-                    hitDistance = this.length * fraction;
-                }
-                return hitDistance;
-            },
-            isExternal: () => {
-                if (isExternal === undefined) {
-                    isExternal = this.fromTo.dotProduct(normal) < 0;
-                }
-                return isExternal;
-            },
-            normal,
-            fraction,
-            rayCast: this
-        };
-    }
+        return hitPosition;
+      },
+      hitDistance: () => {
+        if (hitDistance === undefined) {
+          hitDistance = this.length * fraction;
+        }
+        return hitDistance;
+      },
+      isExternal: () => {
+        if (isExternal === undefined) {
+          isExternal = this.fromTo.dotProduct(normal) < 0;
+        }
+        return isExternal;
+      },
+      normal,
+      fraction,
+      rayCast: this
+    };
+  }
 }
 exports.RayCast = RayCast;
-//# sourceMappingURL=ray-cast.js.map
+//# sourceMappingURL=ray-cast.js.map

package/dist/pixi/display-object/components/filters.d.ts

@@ -1,21 +1,21 @@
 import * as PIXI from 'pixi.js';
 export declare class Filters {
-    private container;
-    private colorMatrix;
-    private _red;
-    private _green;
-    private _blue;
-    private _brightness;
-    get brightness(): number;
-    set brightness(value: number);
-    get red(): number;
-    set red(value: number);
-    get green(): number;
-    set green(value: number);
-    get blue(): number;
-    set blue(value: number);
-    constructor(container: PIXI.Container);
-    removeColorFilter(): void;
-    private refreshColorMatrix;
-    private onFilterChange;
+  private container;
+  private colorMatrix;
+  private _red;
+  private _green;
+  private _blue;
+  private _brightness;
+  get brightness(): number;
+  set brightness(value: number);
+  get red(): number;
+  set red(value: number);
+  get green(): number;
+  set green(value: number);
+  get blue(): number;
+  set blue(value: number);
+  constructor(container: PIXI.Container);
+  removeColorFilter(): void;
+  private refreshColorMatrix;
+  private onFilterChange;
 }