bard-legends-framework 0.11.0 → 0.12.0

package/dist/physics/module//342/232/234/357/270/217gateways/physics-internal.gateway.js

@@ -10,29 +10,29 @@ exports.PhysicsInternalGateway = exports.PhysicsInternalControllerLink = void 0;
 const game_entities_1 = require("../../../game-entities");
 exports.PhysicsInternalControllerLink = new game_entities_1.ControllerLink();
 let PhysicsInternalGateway = class PhysicsInternalGateway {
-    createBody(physicsWorldId, physicsEntityDefinition, material, materialDefinition, type) {
-        return exports.PhysicsInternalControllerLink.trigger('createBody', physicsWorldId, physicsEntityDefinition, material, materialDefinition, type);
+    createBody(physicsWorldID, physicsEntityDefinition, material, materialDefinition, type) {
+        return exports.PhysicsInternalControllerLink.trigger('createBody', physicsWorldID, physicsEntityDefinition, material, materialDefinition, type);
     }
-    getMaterial(physicsWorldId, name) {
-        return exports.PhysicsInternalControllerLink.trigger('getMaterial', physicsWorldId, name);
+    getMaterial(physicsWorldID, name) {
+        return exports.PhysicsInternalControllerLink.trigger('getMaterial', physicsWorldID, name);
     }
-    getMaterialDefinition(physicsWorldId, name) {
-        return exports.PhysicsInternalControllerLink.trigger('getMaterialDefinition', physicsWorldId, name);
+    getMaterialDefinition(physicsWorldID, name) {
+        return exports.PhysicsInternalControllerLink.trigger('getMaterialDefinition', physicsWorldID, name);
     }
-    getGroupConstant(physicsWorldId, group) {
-        return exports.PhysicsInternalControllerLink.trigger('getGroupConstant', physicsWorldId, group);
+    getGroupConstant(physicsWorldID, group) {
+        return exports.PhysicsInternalControllerLink.trigger('getGroupConstant', physicsWorldID, group);
     }
-    getMaskConstant(physicsWorldId, group) {
-        return exports.PhysicsInternalControllerLink.trigger('getMaskConstant', physicsWorldId, group);
+    getMaskConstant(physicsWorldID, group) {
+        return exports.PhysicsInternalControllerLink.trigger('getMaskConstant', physicsWorldID, group);
     }
-    addBody(physicsWorldId, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
-        return exports.PhysicsInternalControllerLink.trigger('addBody', physicsWorldId, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding);
+    addBody(physicsWorldID, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
+        return exports.PhysicsInternalControllerLink.trigger('addBody', physicsWorldID, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding);
     }
-    removeBody(physicsWorldId, p2Body) {
-        return exports.PhysicsInternalControllerLink.trigger('removeBody', physicsWorldId, p2Body);
+    removeBody(physicsWorldID, p2Body) {
+        return exports.PhysicsInternalControllerLink.trigger('removeBody', physicsWorldID, p2Body);
     }
-    subscribeToPhysicsStep(physicsWorldId, callback) {
-        return exports.PhysicsInternalControllerLink.trigger('subscribeToPhysicsStep', physicsWorldId, callback);
+    subscribeToPhysicsStep(physicsWorldID, callback) {
+        return exports.PhysicsInternalControllerLink.trigger('subscribeToPhysicsStep', physicsWorldID, callback);
     }
 };
 exports.PhysicsInternalGateway = PhysicsInternalGateway;

package/dist/physics/module//342/232/234/357/270/217gateways/physics.gateway.d.ts

@@ -6,14 +6,14 @@ import { CreatePhysicsWorldRequestDTO, HitTestOptions, PhysicsExplosionOptions }
 import { ExplosionHit, MapSizeDTO } from './dtos/responses.dto';
 export declare const PhysicsControllerLink: ControllerLink;
 export declare class PhysicsGateway {
-    createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): string;
-    getMapSize(physicsWorldId: string): MapSizeDTO;
-    setPaused(pause: boolean, physicsWorldId: string): void;
-    hitTest(physicsEntityId: string, options?: HitTestOptions): boolean;
-    findPath(physicsWorldId: string, startingPosition: Vector, target: Vector | string, collidableWithGroup: PhysicsBodyGroup, neighborType: GridNeighborType): PathFinderResult;
-    findPathDirection(physicsWorldId: string, startingPosition: Vector, target: Vector | string, collidableWithGroup: PhysicsBodyGroup): Radian | undefined;
-    applyImpulse(physicsEntityId: string, hitPosition: Vector, hitDirection: Vector, severity: number): void;
-    createExplosion(physicsWorldId: string, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
-    createElipticExplosion(physicsWorldId: string, explosionCenter: Vector, rotation: Radian, size: Vector, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
-    printPathfindingTestGrid(physicsWorldId: string, testLayerId: string, target: Vector | string, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize?: number): void;
+    createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): number;
+    getMapSize(physicsWorldID: number): MapSizeDTO;
+    setPaused(pause: boolean, physicsWorldID: number): void;
+    hitTest(physicsEntityID: number, options?: HitTestOptions): boolean;
+    findPath(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup, neighborType: GridNeighborType): PathFinderResult;
+    findPathDirection(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup): Radian | undefined;
+    applyImpulse(physicsEntityID: number, hitPosition: Vector, hitDirection: Vector, severity: number): void;
+    createExplosion(physicsWorldID: number, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+    createElipticExplosion(physicsWorldID: number, explosionCenter: Vector, rotation: Radian, size: Vector, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+    printPathfindingTestGrid(physicsWorldID: number, testLayerID: number, target: Vector | number, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize?: number): void;
 }

package/dist/physics/module//342/232/234/357/270/217gateways/physics.gateway.js

@@ -14,32 +14,32 @@ let PhysicsGateway = class PhysicsGateway {
     createPhysicsWorld(request) {
         return exports.PhysicsControllerLink.trigger('createPhysicsWorld', request);
     }
-    getMapSize(physicsWorldId) {
-        return exports.PhysicsControllerLink.trigger('getMapSize', physicsWorldId);
+    getMapSize(physicsWorldID) {
+        return exports.PhysicsControllerLink.trigger('getMapSize', physicsWorldID);
     }
-    setPaused(pause, physicsWorldId) {
-        return exports.PhysicsControllerLink.trigger('setPaused', pause, physicsWorldId);
+    setPaused(pause, physicsWorldID) {
+        return exports.PhysicsControllerLink.trigger('setPaused', pause, physicsWorldID);
     }
-    hitTest(physicsEntityId, options) {
-        return exports.PhysicsControllerLink.trigger('hitTest', physicsEntityId, options);
+    hitTest(physicsEntityID, options) {
+        return exports.PhysicsControllerLink.trigger('hitTest', physicsEntityID, options);
     }
-    findPath(physicsWorldId, startingPosition, target, collidableWithGroup, neighborType) {
-        return exports.PhysicsControllerLink.trigger('findPath', physicsWorldId, startingPosition, target, collidableWithGroup, neighborType);
+    findPath(physicsWorldID, startingPosition, target, collidableWithGroup, neighborType) {
+        return exports.PhysicsControllerLink.trigger('findPath', physicsWorldID, startingPosition, target, collidableWithGroup, neighborType);
     }
-    findPathDirection(physicsWorldId, startingPosition, target, collidableWithGroup) {
-        return exports.PhysicsControllerLink.trigger('findPathDirection', physicsWorldId, startingPosition, target, collidableWithGroup);
+    findPathDirection(physicsWorldID, startingPosition, target, collidableWithGroup) {
+        return exports.PhysicsControllerLink.trigger('findPathDirection', physicsWorldID, startingPosition, target, collidableWithGroup);
     }
-    applyImpulse(physicsEntityId, hitPosition, hitDirection, severity) {
-        return exports.PhysicsControllerLink.trigger('applyImpulse', physicsEntityId, hitPosition, hitDirection, severity);
+    applyImpulse(physicsEntityID, hitPosition, hitDirection, severity) {
+        return exports.PhysicsControllerLink.trigger('applyImpulse', physicsEntityID, hitPosition, hitDirection, severity);
     }
-    createExplosion(physicsWorldId, explosionCenter, radius, physicsBodyGroup, severity, options) {
-        return exports.PhysicsControllerLink.trigger('createExplosion', physicsWorldId, explosionCenter, radius, physicsBodyGroup, severity, options);
+    createExplosion(physicsWorldID, explosionCenter, radius, physicsBodyGroup, severity, options) {
+        return exports.PhysicsControllerLink.trigger('createExplosion', physicsWorldID, explosionCenter, radius, physicsBodyGroup, severity, options);
     }
-    createElipticExplosion(physicsWorldId, explosionCenter, rotation, size, physicsBodyGroup, severity, options) {
-        return exports.PhysicsControllerLink.trigger('createElipticExplosion', physicsWorldId, explosionCenter, rotation, size, physicsBodyGroup, severity, options);
+    createElipticExplosion(physicsWorldID, explosionCenter, rotation, size, physicsBodyGroup, severity, options) {
+        return exports.PhysicsControllerLink.trigger('createElipticExplosion', physicsWorldID, explosionCenter, rotation, size, physicsBodyGroup, severity, options);
     }
-    printPathfindingTestGrid(physicsWorldId, testLayerId, target, physicsBodyGroup, area, gridCellSize = path_finder_service_1.DEFAULT_GRID_CELL_SIZE) {
-        return exports.PhysicsControllerLink.trigger('printPathfindingTestGrid', physicsWorldId, testLayerId, target, physicsBodyGroup, area, gridCellSize);
+    printPathfindingTestGrid(physicsWorldID, testLayerID, target, physicsBodyGroup, area, gridCellSize = path_finder_service_1.DEFAULT_GRID_CELL_SIZE) {
+        return exports.PhysicsControllerLink.trigger('printPathfindingTestGrid', physicsWorldID, testLayerID, target, physicsBodyGroup, area, gridCellSize);
     }
 };
 exports.PhysicsGateway = PhysicsGateway;

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

@@ -2,9 +2,9 @@ import { PhysicsWorldEntity } from '../../🧊entities/physics-world.entity';
 export declare class CollisionsService {
     registerPhysicsWorld(physicsWorld: PhysicsWorldEntity): void;
     step(physicsWorld: PhysicsWorldEntity, time: number, delta: number): void;
-    private handleSpeedLimit;
-    private registerContactEquation;
-    private getCollisionDetails;
-    private getCollisionDetail;
-    private getNormals;
+    private _handleSpeedLimit;
+    private _registerContactEquation;
+    private _getCollisionDetails;
+    private _getCollisionDetail;
+    private _getNormals;
 }

package/dist/physics/module//360/237/223/220services/collision/collisions.service.js

@@ -15,26 +15,26 @@ let CollisionsService = class CollisionsService {
     registerPhysicsWorld(physicsWorld) {
         physicsWorld.p2World.on('beginContact', (event) => {
             event.contactEquations.forEach(contactEquation => {
-                this.registerContactEquation(physicsWorld, contactEquation);
+                this._registerContactEquation(physicsWorld, contactEquation);
             });
         });
     }
     step(physicsWorld, time, delta) {
         physics_entity_1.PhysicsEntity.getPhysicsEntities().forEach(entity => {
-            entity['_collisions'] = [];
+            entity._collisions = [];
         });
         // 'beginContact' event is not getting triggered for the continues collisions
         physicsWorld.p2World.narrowphase.contactEquations.forEach(contactEquation => {
-            this.registerContactEquation(physicsWorld, contactEquation);
+            this._registerContactEquation(physicsWorld, contactEquation);
         });
-        physicsWorld.bodiesInContactWith.forEach((item, bodyId) => {
-            this.handleSpeedLimit(item.p2Body);
-            item.entity['setCollisionReports'](physicsWorld.collisionReports.get(bodyId) || []);
+        physicsWorld.bodiesInContactWith.forEach((item, bodyID) => {
+            this._handleSpeedLimit(item.p2Body);
+            item.entity._setCollisionReports(physicsWorld.collisionReports.get(bodyID) || []);
         });
         physicsWorld.bodiesInContactWith.clear();
         physicsWorld.collisionReports.clear();
     }
-    handleSpeedLimit(body) {
+    _handleSpeedLimit(body) {
         let velocity = p2js_helper_1.P2JSHelper.arrayToVector(body.velocity);
         if (velocity.length > interfaces_1.SPEED_LIMIT) {
             velocity = velocity.normalize(interfaces_1.SPEED_LIMIT);
@@ -42,15 +42,15 @@ let CollisionsService = class CollisionsService {
         }
         body.angularVelocity = Math.min(Math.max(body.angularVelocity, -interfaces_1.ROTATIONAL_SPEED_LIMIT), interfaces_1.ROTATIONAL_SPEED_LIMIT);
     }
-    registerContactEquation(physicsWorld, contactEquation) {
-        let entityA = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyA.id);
-        let entityB = physics_entity_1.PhysicsEntity.getFromP2BodyId(contactEquation.bodyB.id);
+    _registerContactEquation(physicsWorld, contactEquation) {
+        let entityA = physics_entity_1.PhysicsEntity.getFromP2BodyID(contactEquation.bodyA.id);
+        let entityB = physics_entity_1.PhysicsEntity.getFromP2BodyID(contactEquation.bodyB.id);
         if (entityA && entityB) {
             physicsWorld.bodiesInContactWith.set(contactEquation.bodyA.id, { p2Body: contactEquation.bodyA, entity: entityA });
             physicsWorld.bodiesInContactWith.set(contactEquation.bodyB.id, { p2Body: contactEquation.bodyB, entity: entityB });
             let bodyACollisions = physicsWorld.collisionReports.get(contactEquation.bodyA.id) || [];
             let bodyBCollisions = physicsWorld.collisionReports.get(contactEquation.bodyB.id) || [];
-            let { collisionDetailsA, collisionDetailsB } = this.getCollisionDetails(entityA, entityB, contactEquation);
+            let { collisionDetailsA, collisionDetailsB } = this._getCollisionDetails(entityA, entityB, contactEquation);
             bodyACollisions.push({
                 self: collisionDetailsA,
                 target: collisionDetailsB
@@ -66,18 +66,18 @@ let CollisionsService = class CollisionsService {
             console.warn('ContactEquationOrganiser: Entity not found for contact equation', contactEquation);
         }
     }
-    getCollisionDetails(entityA, entityB, contactEquation) {
+    _getCollisionDetails(entityA, entityB, contactEquation) {
         let dtoA = entityA.convertToDTO();
         let dtoB = entityB.convertToDTO();
         let contactPointA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointA);
         let contactPointB = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.contactPointB);
-        let { normalA, normalB } = this.getNormals(contactEquation);
+        let { normalA, normalB } = this._getNormals(contactEquation);
         return {
-            collisionDetailsA: this.getCollisionDetail(dtoA, contactEquation.bodyA.mass, contactPointA, normalA, entityA.area),
-            collisionDetailsB: this.getCollisionDetail(dtoB, contactEquation.bodyB.mass, contactPointB, normalB, entityB.area)
+            collisionDetailsA: this._getCollisionDetail(dtoA, contactEquation.bodyA.mass, contactPointA, normalA, entityA.area),
+            collisionDetailsB: this._getCollisionDetail(dtoB, contactEquation.bodyB.mass, contactPointB, normalB, entityB.area)
         };
     }
-    getCollisionDetail(physicsBodyDTOSelf, massSelf, contactPointSelf, normalSelf, areaSelf) {
+    _getCollisionDetail(physicsBodyDTOSelf, massSelf, contactPointSelf, normalSelf, areaSelf) {
         let positionRelativeToObject;
         let collisionPosition = contactPointSelf.add(physicsBodyDTOSelf.position);
         return {
@@ -100,7 +100,7 @@ let CollisionsService = class CollisionsService {
             normal: normalSelf
         };
     }
-    getNormals(contactEquation) {
+    _getNormals(contactEquation) {
         let contactEquationNormalA = p2js_helper_1.P2JSHelper.arrayToVector(contactEquation.normalA);
         let contactEquationNormalB = contactEquationNormalA.multiplyNumber(-1);
         return { normalA: contactEquationNormalA, normalB: contactEquationNormalB };

package/dist/physics/module//360/237/223/220services/collision/hit-test.service.d.ts

@@ -2,9 +2,9 @@ import p2 from 'p2';
 import { HitTestOptions } from '../../⚜️gateways';
 import { TestVisualsService } from '../test-visuals/test-visuals.service';
 export declare class HitTestService {
-    private testVisualsService;
-    constructor(testVisualsService: TestVisualsService);
+    private _testVisualsService;
+    constructor(_testVisualsService: TestVisualsService);
     hitTest(p2Body: p2.Body, options?: HitTestOptions): boolean;
-    private applyOverriddenValues;
-    private getAABB;
+    private _applyOverriddenValues;
+    private _getAABB;
 }

package/dist/physics/module//360/237/223/220services/collision/hit-test.service.js

@@ -20,20 +20,20 @@ const physics_entity_1 = require("../../../entity-types/physics-entity");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
 const test_visuals_service_1 = require("../test-visuals/test-visuals.service");
 let HitTestService = class HitTestService {
-    constructor(testVisualsService) {
-        this.testVisualsService = testVisualsService;
+    constructor(_testVisualsService) {
+        this._testVisualsService = _testVisualsService;
     }
     hitTest(p2Body, options) {
         let p2World = p2Body.world;
-        let physicsEntity = physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(p2Body.id);
+        let physicsEntity = physics_entity_1.PhysicsEntity.getFromP2BodyIDOrFail(p2Body.id);
         let bodyClone = p2js_helper_1.P2JSHelper.cloneP2Body(p2Body);
-        this.applyOverriddenValues(bodyClone, options);
+        this._applyOverriddenValues(bodyClone, options);
         let overlappingBodyClones = p2World.broadphase
-            .aabbQuery(p2World, this.getAABB(bodyClone))
-            .map(targetBody => physics_entity_1.PhysicsEntity.getFromP2BodyIdOrFail(targetBody.id))
+            .aabbQuery(p2World, this._getAABB(bodyClone))
+            .map(targetBody => physics_entity_1.PhysicsEntity.getFromP2BodyIDOrFail(targetBody.id))
             .filter(targetEntity => targetEntity.includeInPathfinding)
             .filter(targetEntity => physicsEntity.canCollideWith(targetEntity))
-            .map(targetEntity => p2js_helper_1.P2JSHelper.cloneP2Body(targetEntity['p2Body']));
+            .map(targetEntity => p2js_helper_1.P2JSHelper.cloneP2Body(targetEntity.p2Body));
         let hitFound = false;
         if (overlappingBodyClones.length !== 0) {
             let p2WorldClone = new p2_1.default.World();
@@ -43,9 +43,9 @@ let HitTestService = class HitTestService {
             hitFound = p2WorldClone.narrowphase.contactEquations.some(contactEquation => contactEquation.bodyA === bodyClone || contactEquation.bodyB === bodyClone);
             p2WorldClone.clear();
         }
-        if (options?.testLayerId) {
+        if (options?.testLayerID) {
             let color = hitFound ? helpers_lib_1.ColorHelper.red : helpers_lib_1.ColorHelper.green;
-            this.testVisualsService.createPhysicsEntityShapeVisual(p2Body, options.testLayerId, {
+            this._testVisualsService.createPhysicsEntityShapeVisual(p2Body, options.testLayerID, {
                 overridePosition: options.overridePosition,
                 overrideRotation: options.overrideRotation,
                 color
@@ -53,7 +53,7 @@ let HitTestService = class HitTestService {
         }
         return hitFound;
     }
-    applyOverriddenValues(p2Body, options) {
+    _applyOverriddenValues(p2Body, options) {
         if (options?.overridePosition) {
             p2Body.position = p2js_helper_1.P2JSHelper.vectorToArray(options.overridePosition);
         }
@@ -61,7 +61,7 @@ let HitTestService = class HitTestService {
             p2Body.angle = options.overrideRotation.value;
         }
     }
-    getAABB(p2Body) {
+    _getAABB(p2Body) {
         p2Body.aabbNeedsUpdate = true;
         p2Body.updateAABB();
         return p2Body.aabb;

package/dist/physics/module//360/237/223/220services/collision/physics-body-group.service.d.ts

@@ -6,7 +6,7 @@ export declare class PhysicsBodyGroupService {
         readonly physicsBodyGroupToP2Group: Map<PhysicsBodyGroup, number>;
         readonly physicsBodyGroupToP2Mask: Map<PhysicsBodyGroup, number>;
     };
-    getGroupConstant(physicsWorldId: string, group: PhysicsBodyGroup): number;
-    getMaskConstant(physicsWorldId: string, group: PhysicsBodyGroup): number;
+    getGroupConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    getMaskConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
     canCollide(physicsWorld: PhysicsWorldEntity, groupType1: PhysicsBodyGroup, groupType2: PhysicsBodyGroup): boolean;
 }

package/dist/physics/module//360/237/223/220services/collision/physics-body-group.service.js

@@ -38,12 +38,12 @@ let PhysicsBodyGroupService = class PhysicsBodyGroupService {
         });
         return { physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask };
     }
-    getGroupConstant(physicsWorldId, group) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    getGroupConstant(physicsWorldID, group) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         return physicsWorld.physicsBodyGroupToP2Group.get(group);
     }
-    getMaskConstant(physicsWorldId, group) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    getMaskConstant(physicsWorldID, group) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         return physicsWorld.physicsBodyGroupToP2Mask.get(group);
     }
     canCollide(physicsWorld, groupType1, groupType2) {

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

@@ -1,6 +1,6 @@
 import { Vector } from 'helpers-lib';
 import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 export declare class BorderService {
-    createBorders(physicsWorldId: string, mapSize: Vector, borderBodyGroup: PhysicsBodyGroup): void;
-    private createBorder;
+    createBorders(physicsWorldID: number, mapSize: Vector, borderBodyGroup: PhysicsBodyGroup): void;
+    private _createBorder;
 }

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

@@ -14,25 +14,25 @@ const __gateways_1 = require("../../\u269C\uFE0Fgateways");
 const border_entity_1 = require("../../\uD83E\uDDCAentities/border.entity");
 const BORDER_WIDTH = 10000;
 let BorderService = class BorderService {
-    createBorders(physicsWorldId, mapSize, borderBodyGroup) {
-        this.createBorder(physicsWorldId, new helpers_lib_1.Vector(mapSize.x / 2, -BORDER_WIDTH / 2), new helpers_lib_1.Vector(mapSize.x + BORDER_WIDTH * 2, BORDER_WIDTH), borderBodyGroup); // Top border
-        this.createBorder(physicsWorldId, new helpers_lib_1.Vector(mapSize.x / 2, mapSize.y + BORDER_WIDTH / 2), new helpers_lib_1.Vector(mapSize.x + BORDER_WIDTH * 2, BORDER_WIDTH), borderBodyGroup); // Bottom border
-        this.createBorder(physicsWorldId, new helpers_lib_1.Vector(-BORDER_WIDTH / 2, mapSize.y / 2), new helpers_lib_1.Vector(BORDER_WIDTH, mapSize.y + BORDER_WIDTH * 2), borderBodyGroup); // Left border
-        this.createBorder(physicsWorldId, new helpers_lib_1.Vector(mapSize.x + BORDER_WIDTH / 2, mapSize.y / 2), new helpers_lib_1.Vector(BORDER_WIDTH, mapSize.y + BORDER_WIDTH * 2), borderBodyGroup); // Right border
+    createBorders(physicsWorldID, mapSize, borderBodyGroup) {
+        this._createBorder(physicsWorldID, new helpers_lib_1.Vector(mapSize.x / 2, -BORDER_WIDTH / 2), new helpers_lib_1.Vector(mapSize.x + BORDER_WIDTH * 2, BORDER_WIDTH), borderBodyGroup); // Top border
+        this._createBorder(physicsWorldID, new helpers_lib_1.Vector(mapSize.x / 2, mapSize.y + BORDER_WIDTH / 2), new helpers_lib_1.Vector(mapSize.x + BORDER_WIDTH * 2, BORDER_WIDTH), borderBodyGroup); // Bottom border
+        this._createBorder(physicsWorldID, new helpers_lib_1.Vector(-BORDER_WIDTH / 2, mapSize.y / 2), new helpers_lib_1.Vector(BORDER_WIDTH, mapSize.y + BORDER_WIDTH * 2), borderBodyGroup); // Left border
+        this._createBorder(physicsWorldID, new helpers_lib_1.Vector(mapSize.x + BORDER_WIDTH / 2, mapSize.y / 2), new helpers_lib_1.Vector(BORDER_WIDTH, mapSize.y + BORDER_WIDTH * 2), borderBodyGroup); // Right border
     }
-    createBorder(physicsWorldId, position, size, borderBodyGroup) {
-        return new border_entity_1.BorderEntity(physicsWorldId, {
+    _createBorder(physicsWorldID, position, size, borderBodyGroup) {
+        return new border_entity_1.BorderEntity(physicsWorldID, {
             shapeDefinition: {
                 materialName: __gateways_1.BORDER_MATERIAL_NAME,
                 group: borderBodyGroup,
-                shapeType: interfaces_1.PhysicsShapeType.rectangle,
+                shapeType: interfaces_1.PhysicsShapeType.Rectangle,
                 shapeData: size
             },
             position,
             rotation: helpers_lib_1.Radian.get0,
             addInEmptySpace: false,
             includeOnPathfinding: true
-        }).attach(physicsWorldId);
+        }).attachByID(physicsWorldID);
     }
 };
 exports.BorderService = BorderService;

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

@@ -5,11 +5,11 @@ export declare class MaterialsService {
         materials: Map<string, p2.Material>;
         materialDefinitions: Map<string, MaterialDefinition>;
     };
-    getMaterial(physicsWorldId: string, name: string): p2.Material;
-    getMaterialDefinition(physicsWorldId: string, name: string): MaterialDefinition;
-    private getMaterialInternal;
-    private getMaterialDefinitionInternal;
-    private addContactMaterials;
-    private getFullListOfMaterialContactDefinitions;
-    private addContactMaterialsWithBorder;
+    getMaterial(physicsWorldID: number, name: string): p2.Material;
+    getMaterialDefinition(physicsWorldID: number, name: string): MaterialDefinition;
+    private _getMaterialInternal;
+    private _getMaterialDefinitionInternal;
+    private _addContactMaterials;
+    private _getFullListOfMaterialContactDefinitions;
+    private _addContactMaterialsWithBorder;
 }

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

@@ -34,44 +34,44 @@ let MaterialsService = class MaterialsService {
         }
         materials.set(__gateways_1.BORDER_MATERIAL_NAME, BORDER_MATERIAL);
         materialDefinitionsMap.set(__gateways_1.BORDER_MATERIAL_NAME, BORDER_MATERIAL_DEFINITION);
-        this.addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions, materials);
+        this._addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions, materials);
         return { materials, materialDefinitions: materialDefinitionsMap };
     }
-    getMaterial(physicsWorldId, name) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
-        return this.getMaterialInternal(name, physicsWorld.materials);
+    getMaterial(physicsWorldID, name) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
+        return this._getMaterialInternal(name, physicsWorld.materials);
     }
-    getMaterialDefinition(physicsWorldId, name) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
-        return this.getMaterialDefinitionInternal(name, physicsWorld.materialDefinitions);
+    getMaterialDefinition(physicsWorldID, name) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
+        return this._getMaterialDefinitionInternal(name, physicsWorld.materialDefinitions);
     }
-    getMaterialInternal(name, materials) {
+    _getMaterialInternal(name, materials) {
         let material = materials.get(name);
         if (!material) {
             throw new Error(`Could not find material with name ${name}.`);
         }
         return material;
     }
-    getMaterialDefinitionInternal(name, materialDefinitions) {
+    _getMaterialDefinitionInternal(name, materialDefinitions) {
         let materialDefinition = materialDefinitions.get(name);
         if (!materialDefinition) {
             throw new Error(`Could not find material definition with name ${name}.`);
         }
         return materialDefinition;
     }
-    addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions, materials) {
-        this.getFullListOfMaterialContactDefinitions(materialDefinitions.map(definition => definition.id), materialContactDefinitions).forEach(contactDefinition => {
-            let materialA = this.getMaterialInternal(contactDefinition.materialA, materials);
-            let materialB = this.getMaterialInternal(contactDefinition.materialB, materials);
+    _addContactMaterials(p2World, borderProperties, materialDefinitions, materialContactDefinitions, materials) {
+        this._getFullListOfMaterialContactDefinitions(materialDefinitions.map(definition => definition.id), materialContactDefinitions).forEach(contactDefinition => {
+            let materialA = this._getMaterialInternal(contactDefinition.materialA, materials);
+            let materialB = this._getMaterialInternal(contactDefinition.materialB, materials);
             p2World.addContactMaterial(new p2_1.default.ContactMaterial(materialA, materialB, {
                 friction: contactDefinition.friction,
                 restitution: contactDefinition.bounciness,
                 stiffness: contactDefinition.stiffness
             }));
         });
-        this.addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions, materials);
+        this._addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions, materials);
     }
-    getFullListOfMaterialContactDefinitions(materialNames, materialContactDefinitions) {
+    _getFullListOfMaterialContactDefinitions(materialNames, materialContactDefinitions) {
         let definedCombinations = new Map();
         materialContactDefinitions.forEach(contactDefinition => {
             let materialAMap = definedCombinations.get(contactDefinition.materialA);
@@ -102,9 +102,9 @@ let MaterialsService = class MaterialsService {
         });
         return fullList;
     }
-    addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions, materials) {
+    _addContactMaterialsWithBorder(p2World, borderProperties, materialDefinitions, materials) {
         materialDefinitions.forEach(materialDefinition => {
-            let materialA = this.getMaterialInternal(materialDefinition.id, materials);
+            let materialA = this._getMaterialInternal(materialDefinition.id, materials);
             p2World.addContactMaterial(new p2_1.default.ContactMaterial(materialA, BORDER_MATERIAL, {
                 friction: borderProperties.friction,
                 restitution: borderProperties.bounciness,

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

@@ -7,15 +7,15 @@ import { AvailabilityGridService } from '../path-finding/availability-grid.servi
 import { BorderService } from './border.service';
 import { MaterialsService } from './materials.service';
 export declare class PhysicsWorldService {
-    private materialsService;
-    private borderService;
-    private availabilityGridService;
-    private collisionsService;
-    private physicsBodyGroupService;
-    constructor(materialsService: MaterialsService, borderService: BorderService, availabilityGridService: AvailabilityGridService, collisionsService: CollisionsService, physicsBodyGroupService: PhysicsBodyGroupService);
-    createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): string;
-    addBody(physicsWorldId: string, body: p2.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
-    removeBody(physicsWorldId: string, body: p2.Body): void;
-    private step;
-    setPaused(pause: boolean, physicsWorldId: string): void;
+    private _materialsService;
+    private _borderService;
+    private _availabilityGridService;
+    private _collisionsService;
+    private _physicsBodyGroupService;
+    constructor(_materialsService: MaterialsService, _borderService: BorderService, _availabilityGridService: AvailabilityGridService, _collisionsService: CollisionsService, _physicsBodyGroupService: PhysicsBodyGroupService);
+    createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): number;
+    addBody(physicsWorldID: number, body: p2.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
+    removeBody(physicsWorldID: number, body: p2.Body): void;
+    private _step;
+    setPaused(pause: boolean, physicsWorldID: number): void;
 }

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

@@ -22,50 +22,51 @@ const availability_grid_service_1 = require("../path-finding/availability-grid.s
 const border_service_1 = require("./border.service");
 const materials_service_1 = require("./materials.service");
 let PhysicsWorldService = class PhysicsWorldService {
-    constructor(materialsService, borderService, availabilityGridService, collisionsService, physicsBodyGroupService) {
-        this.materialsService = materialsService;
-        this.borderService = borderService;
-        this.availabilityGridService = availabilityGridService;
-        this.collisionsService = collisionsService;
-        this.physicsBodyGroupService = physicsBodyGroupService;
+    constructor(_materialsService, _borderService, _availabilityGridService, _collisionsService, _physicsBodyGroupService) {
+        this._materialsService = _materialsService;
+        this._borderService = _borderService;
+        this._availabilityGridService = _availabilityGridService;
+        this._collisionsService = _collisionsService;
+        this._physicsBodyGroupService = _physicsBodyGroupService;
     }
     createPhysicsWorld(request) {
         let p2World = new p2_1.default.World({ gravity: [0, 0] });
-        let { materials, materialDefinitions } = this.materialsService.createMaterials(p2World, request.borderProperties, request.materialDefinitions, request.materialContactDefinitions);
-        let { physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask } = this.physicsBodyGroupService.createBodyGroupsAndMasks(request.physicsBodyGroups, request.interactingBodyGroups);
-        let physicsWorld = new physics_world_entity_1.PhysicsWorldEntity(request.mapSize, request.modifyUpdateCycle, p2World, materials, materialDefinitions, physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask).attach(request.attachTo);
+        let { materials, materialDefinitions } = this._materialsService.createMaterials(p2World, request.borderProperties, request.materialDefinitions, request.materialContactDefinitions);
+        let { physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask } = this._physicsBodyGroupService.createBodyGroupsAndMasks(request.physicsBodyGroups, request.interactingBodyGroups);
+        let physicsWorld = new physics_world_entity_1.PhysicsWorldEntity(request.mapSize, request.modifyUpdateCycle, p2World, materials, materialDefinitions, physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask).attachByID(request.attachTo);
         physicsWorld
-            .onDestroy(() => {
+            .onDestroy()
+            .tap(() => {
             p2World.clear();
             if (request.modifyUpdateCycle) {
                 game_entities_1.UpdateCycle.cleanUpdateModifier();
             }
         })
-            .attach(physicsWorld);
-        this.borderService.createBorders(physicsWorld.id, request.mapSize, request.borderProperties.borderBodyGroup);
-        this.collisionsService.registerPhysicsWorld(physicsWorld);
+            .attachToRoot();
+        this._borderService.createBorders(physicsWorld.id, request.mapSize, request.borderProperties.borderBodyGroup);
+        this._collisionsService.registerPhysicsWorld(physicsWorld);
         if (request.modifyUpdateCycle) {
-            game_entities_1.UpdateCycle.registerUpdateModifier((time, delta) => this.step(physicsWorld, time, delta));
+            game_entities_1.UpdateCycle.registerUpdateModifier((time, delta) => this._step(physicsWorld, time, delta));
         }
         else {
             game_entities_1.UpdateCycle.beforeSceneUpdateAction
                 .subscribe(({ time, delta }) => {
-                this.step(physicsWorld, time, delta);
+                this._step(physicsWorld, time, delta);
             })
                 .attach(physicsWorld);
         }
         return physicsWorld.id;
     }
-    addBody(physicsWorldId, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
+    addBody(physicsWorldID, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
         if (addInEmptySpace) {
-            let changeVector = this.availabilityGridService.findClosestAvailableSpace(physicsWorld, body, physicsBodyGroup);
+            let changeVector = this._availabilityGridService.findClosestAvailableSpace(physicsWorld, body, physicsBodyGroup);
             if (changeVector) {
                 body.position[0] += changeVector.x;
                 body.position[1] += changeVector.y;
                 physicsWorld.p2World.addBody(body);
                 if (includeOnPathfinding) {
-                    this.availabilityGridService.onBodyAdded(physicsWorld, body, physicsBodyGroup);
+                    this._availabilityGridService.onBodyAdded(physicsWorld, body, physicsBodyGroup);
                 }
                 return true;
             }
@@ -76,15 +77,15 @@ let PhysicsWorldService = class PhysicsWorldService {
         else {
             physicsWorld.p2World.addBody(body);
             if (includeOnPathfinding) {
-                this.availabilityGridService.onBodyAdded(physicsWorld, body, physicsBodyGroup);
+                this._availabilityGridService.onBodyAdded(physicsWorld, body, physicsBodyGroup);
             }
             return true;
         }
     }
-    removeBody(physicsWorldId, body) {
-        physics_world_entity_1.PhysicsWorldEntity.getInstanceById(physicsWorldId)?.p2World.removeBody(body);
+    removeBody(physicsWorldID, body) {
+        physics_world_entity_1.PhysicsWorldEntity.getInstanceByID(physicsWorldID)?.p2World.removeBody(body);
     }
-    step(physicsWorld, previousTime, delta) {
+    _step(physicsWorld, previousTime, delta) {
         if (!physicsWorld.paused.value) {
             physicsWorld.availabilityGridCache.clear();
             physicsWorld.vectorFieldCache.clear();
@@ -93,14 +94,14 @@ let PhysicsWorldService = class PhysicsWorldService {
                 delta = physicsWorld.p2World.time - physicsWorld.lastP2Time.value;
             }
             let time = previousTime + delta;
-            this.collisionsService.step(physicsWorld, time, delta);
+            this._collisionsService.step(physicsWorld, time, delta);
             physicsWorld.onPhysicsStep.trigger({ time, delta });
             physicsWorld.lastP2Time.value = physicsWorld.p2World.time;
         }
         return delta;
     }
-    setPaused(pause, physicsWorldId) {
-        physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId).paused.set(pause);
+    setPaused(pause, physicsWorldID) {
+        physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID).paused.set(pause);
     }
 };
 exports.PhysicsWorldService = PhysicsWorldService;