bard-legends-framework 0.10.9 → 0.12.0

package/dist/physics/module//360/237/223/220services/creation/shape-creation.service.d.ts

@@ -2,8 +2,8 @@ import p2 from 'p2';
 import { PhysicsEntityDefinition } from '../../../interfaces';
 import { MaterialDefinition } from '../../⚜️gateways';
 export declare class ShapeCreationService {
-    createBody(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition, material: p2.Material, materialDefinition: MaterialDefinition, type: 'dynamic' | 'static'): p2.Body;
-    private createCircleBody;
-    private createPolygonBody;
-    private createRectangleBody;
+    createBody(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition, material: p2.Material, materialDefinition: MaterialDefinition, type: 'dynamic' | 'static'): p2.Body;
+    private _createCircleBody;
+    private _createPolygonBody;
+    private _createRectangleBody;
 }

package/dist/physics/module//360/237/223/220services/creation/shape-creation.service.js

@@ -15,23 +15,23 @@ const game_entities_1 = require("../../../../game-entities");
 const interfaces_1 = require("../../../interfaces");
 const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");
 let ShapeCreationService = class ShapeCreationService {
-    createBody(physicsWorldId, physicsEntityDefinition, material, materialDefinition, type) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    createBody(physicsWorldID, physicsEntityDefinition, material, materialDefinition, type) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         if (!physicsWorld.physicsBodyGroupToP2Group.has(physicsEntityDefinition.shapeDefinition.group)) {
             throw new Error(`Physics body group "${physicsEntityDefinition.shapeDefinition.group}" not found`);
         }
         switch (physicsEntityDefinition.shapeDefinition.shapeType) {
-            case interfaces_1.PhysicsShapeType.point:
-                return this.createCircleBody(physicsWorld, undefined, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
-            case interfaces_1.PhysicsShapeType.circle:
-                return this.createCircleBody(physicsWorld, physicsEntityDefinition.shapeDefinition.shapeData, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
-            case interfaces_1.PhysicsShapeType.polygon:
-                return this.createPolygonBody(physicsWorld, physicsEntityDefinition.shapeDefinition.shapeData, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
-            case interfaces_1.PhysicsShapeType.rectangle:
-                return this.createRectangleBody(physicsWorld, physicsEntityDefinition.shapeDefinition.shapeData, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
+            case interfaces_1.PhysicsShapeType.Point:
+                return this._createCircleBody(physicsWorld, undefined, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
+            case interfaces_1.PhysicsShapeType.Circle:
+                return this._createCircleBody(physicsWorld, physicsEntityDefinition.shapeDefinition.shapeData, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
+            case interfaces_1.PhysicsShapeType.Polygon:
+                return this._createPolygonBody(physicsWorld, physicsEntityDefinition.shapeDefinition.shapeData, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
+            case interfaces_1.PhysicsShapeType.Rectangle:
+                return this._createRectangleBody(physicsWorld, physicsEntityDefinition.shapeDefinition.shapeData, material, materialDefinition, physicsEntityDefinition.shapeDefinition.group, type);
         }
     }
-    createCircleBody(physicsWorld, shapeData, material, materialDefinition, group, type) {
+    _createCircleBody(physicsWorld, shapeData, material, materialDefinition, group, type) {
         let shape = new p2_1.default.Circle({
             collisionGroup: physicsWorld.physicsBodyGroupToP2Group.get(group),
             collisionMask: physicsWorld.physicsBodyGroupToP2Mask.get(group),
@@ -47,7 +47,7 @@ let ShapeCreationService = class ShapeCreationService {
         p2Body.addShape(shape);
         return p2Body;
     }
-    createPolygonBody(physicsWorld, polygonShapeData, material, materialDefinition, group, type) {
+    _createPolygonBody(physicsWorld, polygonShapeData, material, materialDefinition, group, type) {
         let collisionGroup = physicsWorld.physicsBodyGroupToP2Group.get(group);
         let collisionMask = physicsWorld.physicsBodyGroupToP2Mask.get(group);
         let shapes = polygonShapeData
@@ -71,7 +71,7 @@ let ShapeCreationService = class ShapeCreationService {
         p2Body.setDensity(materialDefinition.density);
         return p2Body;
     }
-    createRectangleBody(physicsWorld, rectangleShapeData, material, materialDefinition, group, type) {
+    _createRectangleBody(physicsWorld, rectangleShapeData, material, materialDefinition, group, type) {
         let shape = new p2_1.default.Box({
             width: rectangleShapeData.x,
             height: rectangleShapeData.y,

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

@@ -6,13 +6,13 @@ import { TestVisualsService } from '../test-visuals/test-visuals.service';
 import { ImpactService } from './impact.service';
 import { RayCastHitConverterService } from './ray-cast-hit-converter';
 export declare class ElipticExplosionService {
-    private rayCastingService;
-    private testVisualsService;
-    private rayCastHitConverterService;
-    private impactService;
-    constructor(rayCastingService: RayCastingService, testVisualsService: TestVisualsService, rayCastHitConverterService: RayCastHitConverterService, impactService: ImpactService);
-    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;
+    private _rayCastHitConverterService;
+    private _impactService;
+    constructor(_rayCastingService: RayCastingService, _testVisualsService: TestVisualsService, _rayCastHitConverterService: RayCastHitConverterService, _impactService: ImpactService);
+    createElipticExplosion(physicsWorldID: number, explosionCenter: Vector, rotation: Radian, size: Vector, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+    private _createRays;
+    private _getWidthOfLine;
+    private _applyForcesToBodies;
 }

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

@@ -19,26 +19,26 @@ const impact_service_1 = require("./impact.service");
 const ray_cast_hit_converter_1 = require("./ray-cast-hit-converter");
 const MIN_GAP_BETWEEN_LINES = 15;
 let ElipticExplosionService = class ElipticExplosionService {
-    constructor(rayCastingService, testVisualsService, rayCastHitConverterService, impactService) {
-        this.rayCastingService = rayCastingService;
-        this.testVisualsService = testVisualsService;
-        this.rayCastHitConverterService = rayCastHitConverterService;
-        this.impactService = impactService;
+    constructor(_rayCastingService, _testVisualsService, _rayCastHitConverterService, _impactService) {
+        this._rayCastingService = _rayCastingService;
+        this._testVisualsService = _testVisualsService;
+        this._rayCastHitConverterService = _rayCastHitConverterService;
+        this._impactService = _impactService;
     }
-    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 = this.rayCastHitConverterService.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 = this._rayCastHitConverterService.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 => {
             let { p2Body: _p2Body, ...explosionHit } = explosionHitWithP2Body;
             return explosionHit;
         });
     }
-    createRays(explosionCenter, rotation, size, physicsBodyGroup, hitOnlyClosest, physicsWorld) {
+    _createRays(explosionCenter, rotation, size, physicsBodyGroup, hitOnlyClosest, physicsWorld) {
         let lines = [];
         let centerDirection = rotation.vector;
         let lineDirection = rotation.add(helpers_lib_1.Radian.get90).vector;
@@ -56,7 +56,7 @@ let ElipticExplosionService = class ElipticExplosionService {
         helpers_lib_1.ArrayHelper.createIntegerArray(lineCount).forEach(index => {
             let distanceFromCenter = gap * (index + 1);
             let distanceFromCenterVector = gapVector.multiplyNumber(index + 1);
-            let vector = lineDirection.normalize(this.getWidthOfLine(width, heightSquared, distanceFromCenter));
+            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.multiplyNumber(-1))));
@@ -66,19 +66,19 @@ let ElipticExplosionService = class ElipticExplosionService {
         });
         return lines.map(line => {
             if (hitOnlyClosest) {
-                let hit = this.rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
+                let hit = this._rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
                 return { line, hits: hit ? [hit] : [] };
             }
             else {
-                let hits = this.rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
+                let hits = this._rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
                 return { line, hits };
             }
         });
     }
-    getWidthOfLine(width, heightSquared, distanceFromCenter) {
+    _getWidthOfLine(width, heightSquared, distanceFromCenter) {
         return Math.sqrt(1 - Math.pow(distanceFromCenter, 2) / heightSquared) * width;
     }
-    applyForcesToBodies(explosionHits, severity) {
+    _applyForcesToBodies(explosionHits, severity) {
         explosionHits.forEach(explosionHit => {
             explosionHit.raycastResults.forEach(rayCastResult => {
                 let hitDirection;
@@ -91,7 +91,7 @@ let ElipticExplosionService = class ElipticExplosionService {
                     hitDirection = rayCastResult.line.fromTo.multiplyNumber(-1);
                     force = severity * (1 - rayCastResult.fraction) * 8;
                 }
-                this.impactService.applyImpulse(rayCastResult.body, rayCastResult.hitPosition(), hitDirection, force);
+                this._impactService.applyImpulse(rayCastResult.body, rayCastResult.hitPosition(), hitDirection, force);
             });
         });
     }

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

@@ -6,13 +6,13 @@ import { TestVisualsService } from '../test-visuals/test-visuals.service';
 import { ImpactService } from './impact.service';
 import { RayCastHitConverterService } from './ray-cast-hit-converter';
 export declare class ExplosionService {
-    private rayCastingService;
-    private testVisualsService;
-    private rayCastHitConverterService;
-    private impactService;
-    constructor(rayCastingService: RayCastingService, testVisualsService: TestVisualsService, rayCastHitConverterService: RayCastHitConverterService, impactService: ImpactService);
-    createExplosion(physicsWorldId: string, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
-    private createRays;
-    private applyForcesToBodies;
-    private getTotalCountOfRays;
+    private _rayCastingService;
+    private _testVisualsService;
+    private _rayCastHitConverterService;
+    private _impactService;
+    constructor(_rayCastingService: RayCastingService, _testVisualsService: TestVisualsService, _rayCastHitConverterService: RayCastHitConverterService, _impactService: ImpactService);
+    createExplosion(physicsWorldID: number, 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/impact/explosion.service.js

@@ -19,24 +19,24 @@ const test_visuals_service_1 = require("../test-visuals/test-visuals.service");
 const impact_service_1 = require("./impact.service");
 const ray_cast_hit_converter_1 = require("./ray-cast-hit-converter");
 let ExplosionService = class ExplosionService {
-    constructor(rayCastingService, testVisualsService, rayCastHitConverterService, impactService) {
-        this.rayCastingService = rayCastingService;
-        this.testVisualsService = testVisualsService;
-        this.rayCastHitConverterService = rayCastHitConverterService;
-        this.impactService = impactService;
+    constructor(_rayCastingService, _testVisualsService, _rayCastHitConverterService, _impactService) {
+        this._rayCastingService = _rayCastingService;
+        this._testVisualsService = _testVisualsService;
+        this._rayCastHitConverterService = _rayCastHitConverterService;
+        this._impactService = _impactService;
     }
-    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 = this.rayCastHitConverterService.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 = this._rayCastHitConverterService.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) {
+    _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.vector;
@@ -48,32 +48,32 @@ let ExplosionService = class ExplosionService {
         })
             .map(line => {
             if (hitOnlyClosest) {
-                let hit = this.rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
+                let hit = this._rayCastingService.castClosest(physicsWorld, line, physicsBodyGroup);
                 return { line, hits: hit ? [hit] : [] };
             }
             else {
-                let hits = this.rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
+                let hits = this._rayCastingService.castAllFirstContacts(physicsWorld, line, physicsBodyGroup);
                 return { line, hits };
             }
         });
     }
-    applyForcesToBodies(explosionCenter, radius, severity, totalCountOfRays, explosionHits) {
+    _applyForcesToBodies(explosionCenter, radius, severity, totalCountOfRays, explosionHits) {
         explosionHits.forEach(explosionHit => {
             if (explosionHit.isExternal) {
                 explosionHit.raycastResults.forEach(rayCastResult => {
                     let force = severity * (1 - rayCastResult.fraction);
-                    this.impactService.applyImpulse(rayCastResult.body, rayCastResult.hitPosition(), rayCastResult.line.fromTo, force);
+                    this._impactService.applyImpulse(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;
-                this.impactService.applyImpulse(explosionHit.p2Body, explosionHit.getHitPosition(), vectorToCenter, force);
+                this._impactService.applyImpulse(explosionHit.p2Body, explosionHit.getHitPosition(), vectorToCenter, force);
             }
         });
     }
-    getTotalCountOfRays(radius) {
+    _getTotalCountOfRays(radius) {
         if (radius > 100) {
             return Math.floor(radius * 0.3);
         }

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

@@ -5,5 +5,5 @@ export interface ExplosionHitWithP2Body extends ExplosionHit {
 }
 export declare class RayCastHitConverterService {
     toExplosionHits(rayCasts: RayCast[], allRaysStartingFromSamePosition?: boolean): ExplosionHitWithP2Body[];
-    private convertRayResultGroupToExplosionHit;
+    private _convertRayResultGroupToExplosionHit;
 }

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

@@ -42,14 +42,14 @@ let RayCastHitConverterService = class RayCastHitConverterService {
                 }
             });
         });
-        return [...bodyToHitResults.values()].map(rayResultGroupOfABody => this.convertRayResultGroupToExplosionHit(rayResultGroupOfABody, rayCasts.length));
+        return [...bodyToHitResults.values()].map(rayResultGroupOfABody => this._convertRayResultGroupToExplosionHit(rayResultGroupOfABody, rayCasts.length));
     }
-    convertRayResultGroupToExplosionHit(rayResultGroupOfABody, totalCountOfRays) {
+    _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(),
+                body: physics_entity_1.PhysicsEntity.getFromP2BodyIDOrFail(rayResultGroupOfABody.closestRaycastHit.body.id).convertToDTO(),
                 p2Body: rayResultGroupOfABody.closestRaycastHit.body,
                 isExternal: true,
                 normal: rayResultGroupOfABody.closestRaycastHit.normal,
@@ -63,7 +63,7 @@ let RayCastHitConverterService = class RayCastHitConverterService {
         else {
             let bodyPosition = p2js_helper_1.P2JSHelper.arrayToVector(rayResultGroupOfABody.closestRaycastHit.body.position);
             return {
-                body: physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(rayResultGroupOfABody.closestRaycastHit.body.id).convertToDTO(),
+                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(),

package/dist/physics/module//360/237/223/220services/path-finding/availability-grid-cache.service.d.ts

@@ -3,8 +3,8 @@ import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 import { PhysicsWorldEntity } from '../../🧊entities/physics-world.entity';
 import { PhysicsBodyGroupService } from '../collision/physics-body-group.service';
 export declare class AvailabilityGridCacheService {
-    private physicsBodyGroupService;
-    constructor(physicsBodyGroupService: PhysicsBodyGroupService);
+    private _physicsBodyGroupService;
+    constructor(_physicsBodyGroupService: PhysicsBodyGroupService);
     getCollidableGrids(physicsWorld: PhysicsWorldEntity, physicsBodyGroup: PhysicsBodyGroup): {
         grid: Grid<boolean>;
         cellSize: number;

package/dist/physics/module//360/237/223/220services/path-finding/availability-grid-cache.service.js

@@ -13,14 +13,14 @@ exports.AvailabilityGridCacheService = void 0;
 const game_entities_1 = require("../../../../game-entities");
 const physics_body_group_service_1 = require("../collision/physics-body-group.service");
 let AvailabilityGridCacheService = class AvailabilityGridCacheService {
-    constructor(physicsBodyGroupService) {
-        this.physicsBodyGroupService = physicsBodyGroupService;
+    constructor(_physicsBodyGroupService) {
+        this._physicsBodyGroupService = _physicsBodyGroupService;
     }
     getCollidableGrids(physicsWorld, physicsBodyGroup) {
         let results = [];
         physicsWorld.availabilityGridCache.forEach((cellSizeMap, cellSize) => {
             cellSizeMap.forEach((grid, gridPhysicsBodyGroup) => {
-                if (this.physicsBodyGroupService.canCollide(physicsWorld, gridPhysicsBodyGroup, physicsBodyGroup)) {
+                if (this._physicsBodyGroupService.canCollide(physicsWorld, gridPhysicsBodyGroup, physicsBodyGroup)) {
                     results.push({ grid, cellSize });
                 }
             });

package/dist/physics/module//360/237/223/220services/path-finding/availability-grid.service.d.ts

@@ -5,12 +5,12 @@ import { PhysicsWorldEntity } from '../../🧊entities/physics-world.entity';
 import { PhysicsBodyGroupService } from '../collision/physics-body-group.service';
 import { AvailabilityGridCacheService } from './availability-grid-cache.service';
 export declare class AvailabilityGridService {
-    private physicsBodyGroupService;
-    private availabilityGridCacheService;
-    constructor(physicsBodyGroupService: PhysicsBodyGroupService, availabilityGridCacheService: AvailabilityGridCacheService);
+    private _physicsBodyGroupService;
+    private _availabilityGridCacheService;
+    constructor(_physicsBodyGroupService: PhysicsBodyGroupService, _availabilityGridCacheService: AvailabilityGridCacheService);
     onBodyAdded(physicsWorld: PhysicsWorldEntity, body: p2.Body, physicsBodyGroup: PhysicsBodyGroup): void;
     findClosestAvailableSpace(physicsWorld: PhysicsWorldEntity, body: p2.Body, physicsBodyGroup: PhysicsBodyGroup, gridCellSize?: number): Vector | undefined;
     getAvilabilityGrid(physicsWorld: PhysicsWorldEntity, cellSize: number, physicsBodyGroup: PhysicsBodyGroup): Grid<boolean>;
-    private createGrid;
-    private getGridSpaceBoundingBox;
+    private _createGrid;
+    private _getGridSpaceBoundingBox;
 }

package/dist/physics/module//360/237/223/220services/path-finding/availability-grid.service.js

@@ -13,22 +13,22 @@ exports.AvailabilityGridService = void 0;
 const helpers_lib_1 = require("helpers-lib");
 const game_entities_1 = require("../../../../game-entities");
 const utilities_1 = require("../../../../utilities");
-const position_to_grid_position_converter_1 = require("../../../../utilities/libraries/grid-algorithms/position-to-grid-position-converter");
+const position_to_grid_position_converter_1 = require("../../../../utilities/grid-algorithms/position-to-grid-position-converter");
 const physics_entity_1 = require("../../../entity-types/physics-entity");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
 const physics_body_group_service_1 = require("../collision/physics-body-group.service");
 const availability_grid_cache_service_1 = require("./availability-grid-cache.service");
 const path_finder_service_1 = require("./path-finder.service");
 let AvailabilityGridService = class AvailabilityGridService {
-    constructor(physicsBodyGroupService, availabilityGridCacheService) {
-        this.physicsBodyGroupService = physicsBodyGroupService;
-        this.availabilityGridCacheService = availabilityGridCacheService;
+    constructor(_physicsBodyGroupService, _availabilityGridCacheService) {
+        this._physicsBodyGroupService = _physicsBodyGroupService;
+        this._availabilityGridCacheService = _availabilityGridCacheService;
     }
     onBodyAdded(physicsWorld, body, physicsBodyGroup) {
         body.aabbNeedsUpdate = true;
         body.updateAABB();
         let boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(body.aabb);
-        this.availabilityGridCacheService.getCollidableGrids(physicsWorld, physicsBodyGroup).forEach(item => {
+        this._availabilityGridCacheService.getCollidableGrids(physicsWorld, physicsBodyGroup).forEach(item => {
             let gridSpaceBoundingBox = position_to_grid_position_converter_1.PositionToGridPositionConverter.areaToGridArea(boundingBox, item.cellSize);
             item.grid.setArea(gridSpaceBoundingBox, false);
         });
@@ -40,29 +40,29 @@ let AvailabilityGridService = class AvailabilityGridService {
         return changeVector;
     }
     getAvilabilityGrid(physicsWorld, cellSize, physicsBodyGroup) {
-        let grid = this.availabilityGridCacheService.get(physicsWorld, cellSize, physicsBodyGroup);
+        let grid = this._availabilityGridCacheService.get(physicsWorld, cellSize, physicsBodyGroup);
         if (!grid) {
-            grid = this.createGrid(physicsWorld, cellSize, physicsBodyGroup);
-            this.availabilityGridCacheService.set(physicsWorld, cellSize, physicsBodyGroup, grid);
+            grid = this._createGrid(physicsWorld, cellSize, physicsBodyGroup);
+            this._availabilityGridCacheService.set(physicsWorld, cellSize, physicsBodyGroup, grid);
         }
         return grid;
     }
-    createGrid(physicsWorld, cellSize, physicsBodyGroup) {
+    _createGrid(physicsWorld, cellSize, physicsBodyGroup) {
         let grid = new helpers_lib_1.Grid({
             size: new helpers_lib_1.Vector(Math.floor(physicsWorld.mapSize.x / cellSize), Math.floor(physicsWorld.mapSize.y / cellSize)),
             defaultValue: true
         });
         physicsWorld.p2World.bodies.forEach(p2Body => {
-            let physicsEntity = physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(p2Body.id);
+            let physicsEntity = physics_entity_1.PhysicsEntity.getFromP2BodyIDOrFail(p2Body.id);
             if (physicsEntity.includeInPathfinding &&
-                this.physicsBodyGroupService.canCollide(physicsWorld, physicsEntity.physicsBodyGroup, physicsBodyGroup)) {
-                let gridSpaceBoundingBox = this.getGridSpaceBoundingBox(p2Body, cellSize);
+                this._physicsBodyGroupService.canCollide(physicsWorld, physicsEntity.physicsBodyGroup, physicsBodyGroup)) {
+                let gridSpaceBoundingBox = this._getGridSpaceBoundingBox(p2Body, cellSize);
                 grid.setArea(gridSpaceBoundingBox, false);
             }
         });
         return grid;
     }
-    getGridSpaceBoundingBox(p2Body, cellSize) {
+    _getGridSpaceBoundingBox(p2Body, cellSize) {
         let boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(p2Body.aabb);
         return position_to_grid_position_converter_1.PositionToGridPositionConverter.areaToGridArea(boundingBox, cellSize);
     }

package/dist/physics/module//360/237/223/220services/path-finding/path-finder.service.d.ts

@@ -4,11 +4,11 @@ import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 import { AvailabilityGridService } from './availability-grid.service';
 export declare const DEFAULT_GRID_CELL_SIZE = 50;
 export declare class PathFinderService {
-    private physicsAvailabilityGrid;
-    constructor(physicsAvailabilityGrid: AvailabilityGridService);
-    findPathAStar(physicsWorldId: string, startingPosition: Vector, target: Vector | string, collidableWithGroup: PhysicsBodyGroup, options?: {
+    private _physicsAvailabilityGrid;
+    constructor(_physicsAvailabilityGrid: AvailabilityGridService);
+    findPathAStar(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup, options?: {
         neighborType?: GridNeighborType;
         gridCellSize?: number;
     }): PathFinderResult;
-    findPathDirection(physicsWorldId: string, startingPosition: Vector, target: Vector | string, collidableWithGroup: PhysicsBodyGroup, gridCellSize?: number): Radian | undefined;
+    findPathDirection(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup, gridCellSize?: number): Radian | undefined;
 }

package/dist/physics/module//360/237/223/220services/path-finding/path-finder.service.js

@@ -13,30 +13,30 @@ exports.PathFinderService = exports.DEFAULT_GRID_CELL_SIZE = void 0;
 const helpers_lib_1 = require("helpers-lib");
 const game_entities_1 = require("../../../../game-entities");
 const utilities_1 = require("../../../../utilities");
-const position_to_grid_position_converter_1 = require("../../../../utilities/libraries/grid-algorithms/position-to-grid-position-converter");
+const position_to_grid_position_converter_1 = require("../../../../utilities/grid-algorithms/position-to-grid-position-converter");
 const physics_entity_1 = require("../../../entity-types/physics-entity");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
 const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");
 const availability_grid_service_1 = require("./availability-grid.service");
 exports.DEFAULT_GRID_CELL_SIZE = 50;
 let PathFinderService = class PathFinderService {
-    constructor(physicsAvailabilityGrid) {
-        this.physicsAvailabilityGrid = physicsAvailabilityGrid;
+    constructor(_physicsAvailabilityGrid) {
+        this._physicsAvailabilityGrid = _physicsAvailabilityGrid;
     }
-    findPathAStar(physicsWorldId, startingPosition, target, collidableWithGroup, options) {
+    findPathAStar(physicsWorldID, startingPosition, target, collidableWithGroup, options) {
         if (!options) {
             options = {};
         }
         if (options.neighborType === undefined) {
-            options.neighborType = helpers_lib_1.GridNeighborType.ORTOGONAL;
+            options.neighborType = helpers_lib_1.GridNeighborType.Ortogonal;
         }
         if (options.gridCellSize === undefined) {
             options.gridCellSize = exports.DEFAULT_GRID_CELL_SIZE;
         }
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         let targetPosition;
         let targetP2Body;
-        if (helpers_lib_1.Comparator.isString(target)) {
+        if (helpers_lib_1.Comparator.isNumber(target)) {
             let targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
             targetP2Body = targetEntity['p2Body'];
             targetPosition = p2js_helper_1.P2JSHelper.arrayToVector(targetP2Body.position);
@@ -46,7 +46,7 @@ let PathFinderService = class PathFinderService {
         }
         let startingGridPosition = position_to_grid_position_converter_1.PositionToGridPositionConverter.positionToGridPosition(startingPosition, options.gridCellSize);
         let targetGridPosition = position_to_grid_position_converter_1.PositionToGridPositionConverter.positionToGridPosition(targetPosition, options.gridCellSize);
-        let availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(physicsWorld, options.gridCellSize, collidableWithGroup);
+        let availabilityGrid = this._physicsAvailabilityGrid.getAvilabilityGrid(physicsWorld, options.gridCellSize, collidableWithGroup);
         if (targetP2Body) {
             let boundingBox = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetP2Body.aabb);
             let gridSpaceBoundingBox = position_to_grid_position_converter_1.PositionToGridPositionConverter.areaToGridArea(boundingBox, options.gridCellSize);
@@ -56,12 +56,12 @@ let PathFinderService = class PathFinderService {
         result.path = result.path.map(gridPosition => position_to_grid_position_converter_1.PositionToGridPositionConverter.gridPositionToPosition(gridPosition, options.gridCellSize));
         return result;
     }
-    findPathDirection(physicsWorldId, startingPosition, target, collidableWithGroup, gridCellSize = exports.DEFAULT_GRID_CELL_SIZE) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    findPathDirection(physicsWorldID, startingPosition, target, collidableWithGroup, gridCellSize = exports.DEFAULT_GRID_CELL_SIZE) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         let targetArea;
-        if (helpers_lib_1.Comparator.isString(target)) {
+        if (helpers_lib_1.Comparator.isNumber(target)) {
             let targetEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(target);
-            targetArea = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetEntity['p2Body'].aabb);
+            targetArea = p2js_helper_1.P2JSHelper.aabbToBoundingBox(targetEntity.p2Body.aabb);
         }
         else {
             targetArea = new helpers_lib_1.Rectangle(target, target);
@@ -70,7 +70,7 @@ let PathFinderService = class PathFinderService {
         let cacheName = JSON.stringify({ targetGridArea, collidableWithGroup });
         let vectorField = physicsWorld.vectorFieldCache.get(cacheName);
         if (!vectorField) {
-            let availabilityGrid = this.physicsAvailabilityGrid.getAvilabilityGrid(physicsWorld, gridCellSize, collidableWithGroup);
+            let availabilityGrid = this._physicsAvailabilityGrid.getAvilabilityGrid(physicsWorld, gridCellSize, collidableWithGroup);
             vectorField = new utilities_1.VectorFieldPathFinder(targetGridArea, availabilityGrid);
             physicsWorld.vectorFieldCache.set(cacheName, vectorField);
         }

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

@@ -1,9 +1,9 @@
-import { ActionListenerCallbackFunction, ActionSubscription } from 'actions-lib';
+import { IAttachment, NotifierCallbackFunction } from 'actions-lib';
 import { MapSizeDTO } from '../../⚜️gateways';
 export declare class PhysicsQueryService {
-    getMapSize(physicsWorldId: string): MapSizeDTO;
-    subscribeToPhysicsStep(physicsWorldId: string, callback: ActionListenerCallbackFunction<{
+    getMapSize(physicsWorldID: number): MapSizeDTO;
+    subscribeToPhysicsStep(physicsWorldID: number, callback: NotifierCallbackFunction<{
         time: number;
         delta: number;
-    }>): ActionSubscription;
+    }>): IAttachment;
 }

package/dist/physics/module//360/237/223/220services/query/physics-query.service.js

@@ -10,12 +10,12 @@ exports.PhysicsQueryService = void 0;
 const game_entities_1 = require("../../../../game-entities");
 const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");
 let PhysicsQueryService = class PhysicsQueryService {
-    getMapSize(physicsWorldId) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    getMapSize(physicsWorldID) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         return { dimentions: physicsWorld.mapSize, center: physicsWorld.mapSizeCenter };
     }
-    subscribeToPhysicsStep(physicsWorldId, callback) {
-        return physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId).onPhysicsStep.subscribe(callback);
+    subscribeToPhysicsStep(physicsWorldID, callback) {
+        return physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID).onPhysicsStep.subscribe(callback);
     }
 };
 exports.PhysicsQueryService = PhysicsQueryService;

package/dist/physics/module//360/237/223/220services/ray-casting/ray-casting.service.d.ts

@@ -2,11 +2,8 @@ import { Line } from 'helpers-lib';
 import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 import { RayCastHit } from '../../⚜️gateways';
 import { PhysicsWorldEntity } from '../../🧊entities/physics-world.entity';
-import { PhysicsBodyGroupService } from '../collision/physics-body-group.service';
 export declare class RayCastingService {
-    private physicsBodyGroupService;
-    constructor(physicsBodyGroupService: PhysicsBodyGroupService);
     castClosest(physicsWorld: PhysicsWorldEntity, line: Line, physicsBodyGroup: PhysicsBodyGroup): RayCastHit | undefined;
     castAllFirstContacts(physicsWorld: PhysicsWorldEntity, line: Line, physicsBodyGroup: PhysicsBodyGroup): RayCastHit[];
-    private convertP2RaycastResultToRaycastResult;
+    private _convertP2RaycastResultToRaycastResult;
 }