bard-legends-framework 0.11.0 → 0.12.0

package/dist/physics/entity-types/movable-physics-entity.js

@@ -8,50 +8,50 @@ const p2js_helper_1 = require("../libs/p2js.helper");
 const physics_internal_gateway_1 = require("../module/\u269C\uFE0Fgateways/physics-internal.gateway");
 const physics_entity_1 = require("./physics-entity");
 class MovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
-    constructor(physicsWorldId, physicsEntityDefinition) {
-        super(physicsWorldId, physicsEntityDefinition, 'dynamic');
+    constructor(physicsWorldID, physicsEntityDefinition) {
+        super(physicsWorldID, physicsEntityDefinition, 'dynamic');
         this.position = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
         this.rotation = new actions_lib_1.Variable(helpers_lib_1.Radian.get0);
         this.velocity = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
         this.rotationalSpeed = new actions_lib_1.Variable(0);
-        this.ignorePositionUpdate = false;
-        this.ignoreRotationUpdate = false;
-        this.ignoreVelocityUpdate = false;
-        this.ignoreRotationalSpeedUpdate = false;
-        this.phsicsToLocalSync();
-        this.localToPhsicsSync();
+        this._ignorePositionUpdate = false;
+        this._ignoreRotationUpdate = false;
+        this._ignoreVelocityUpdate = false;
+        this._ignoreRotationalSpeedUpdate = false;
+        this._phsicsToLocalSync();
+        this._localToPhsicsSync();
         game_entities_1.Service.get(physics_internal_gateway_1.PhysicsInternalGateway)
-            .subscribeToPhysicsStep(physicsWorldId, ({ time, delta }) => this.step(time, delta))
+            .subscribeToPhysicsStep(physicsWorldID, ({ time, delta }) => this._step(time, delta))
             .attach(this);
     }
     convertToDTO() {
         return {
-            entityId: this.id,
-            classId: this.classId,
+            entityID: this.id,
+            classID: this.classID,
             position: this.position.value,
             rotation: this.rotation.value,
             velocity: this.velocity.value,
             rotationalSpeed: this.rotationalSpeed.value
         };
     }
-    step(time, delta) {
-        this.ignorePositionUpdate = true;
-        this.ignoreRotationUpdate = true;
-        this.ignoreVelocityUpdate = true;
-        this.ignoreRotationalSpeedUpdate = true;
-        this.phsicsToLocalSync();
+    _step(time, delta) {
+        this._ignorePositionUpdate = true;
+        this._ignoreRotationUpdate = true;
+        this._ignoreVelocityUpdate = true;
+        this._ignoreRotationalSpeedUpdate = true;
+        this._phsicsToLocalSync();
     }
-    phsicsToLocalSync() {
+    _phsicsToLocalSync() {
         this.position.value = p2js_helper_1.P2JSHelper.arrayToVector(this.p2Body.position);
         this.rotation.value = new helpers_lib_1.Radian(this.p2Body.angle);
         this.velocity.value = p2js_helper_1.P2JSHelper.arrayToVector(this.p2Body.velocity);
         this.rotationalSpeed.value = this.p2Body.angularVelocity;
     }
-    localToPhsicsSync() {
+    _localToPhsicsSync() {
         this.position
             .subscribe(position => {
-            if (this.ignorePositionUpdate) {
-                this.ignorePositionUpdate = false;
+            if (this._ignorePositionUpdate) {
+                this._ignorePositionUpdate = false;
             }
             else {
                 this.p2Body.position = [position.x, position.y];
@@ -60,8 +60,8 @@ class MovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
             .attach(this);
         this.rotation
             .subscribe(rotation => {
-            if (this.ignoreRotationUpdate) {
-                this.ignoreRotationUpdate = false;
+            if (this._ignoreRotationUpdate) {
+                this._ignoreRotationUpdate = false;
             }
             else {
                 this.p2Body.angle = rotation.value;
@@ -70,8 +70,8 @@ class MovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
             .attach(this);
         this.velocity
             .subscribe(velocity => {
-            if (this.ignoreVelocityUpdate) {
-                this.ignoreVelocityUpdate = false;
+            if (this._ignoreVelocityUpdate) {
+                this._ignoreVelocityUpdate = false;
             }
             else {
                 this.p2Body.velocity = [velocity.x, velocity.y];
@@ -80,8 +80,8 @@ class MovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
             .attach(this);
         this.rotationalSpeed
             .subscribe(rotationalSpeed => {
-            if (this.ignoreRotationalSpeedUpdate) {
-                this.ignoreRotationalSpeedUpdate = false;
+            if (this._ignoreRotationalSpeedUpdate) {
+                this._ignoreRotationalSpeedUpdate = false;
             }
             else {
                 this.p2Body.angularVelocity = rotationalSpeed;

package/dist/physics/entity-types/physics-entity.d.ts

@@ -1,34 +1,30 @@
 import { Action } from 'actions-lib';
-import p2 from 'p2';
 import { Entity } from '../../game-entities';
 import { CollisionReport, PhysicsBodyDTO, PhysicsEntityDefinition } from '../interfaces';
 import { PhysicsBodyGroup } from '../libs/physics-body-groups';
 export declare abstract class PhysicsEntity extends Entity {
-    private static p2BodyIdToPhysicsBody;
-    private static physicsEntities;
-    static getFromP2BodyId(p2BodyId: number): PhysicsEntity | undefined;
-    static getFromP2BodyIdOrFail(p2BodyId: number): PhysicsEntity;
-    static getPhysicsInstanceOrFail(id: string): PhysicsEntity;
+    private static _p2BodyIDToPhysicsBody;
+    private static _physicsEntities;
+    static getFromP2BodyID(p2BodyID: number): PhysicsEntity | undefined;
+    static getFromP2BodyIDOrFail(p2BodyID: number): PhysicsEntity;
+    static getPhysicsInstanceOrFail(id: number): PhysicsEntity;
     static getPhysicsEntities(): PhysicsEntity[];
     readonly _onCollision: Action<readonly CollisionReport[]>;
     readonly onCollision: import("actions-lib").Notifier<readonly CollisionReport[]>;
     get area(): number;
     get mass(): number;
     get collisions(): readonly CollisionReport[];
-    readonly physicsWorldId: string;
+    readonly physicsWorldID: number;
     readonly physicsBodyGroup: PhysicsBodyGroup;
     readonly includeInPathfinding: boolean;
-    protected readonly p2Body: p2.Body;
     protected readonly type: 'dynamic' | 'static';
-    private readonly physicsInternalGateway;
-    private physicsGroup;
-    private physicsMask;
+    private readonly _physicsInternalGateway;
+    private _physicsGroup;
+    private _physicsMask;
     private _area;
     private _mass;
-    private _collisions;
-    constructor(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition, type: 'dynamic' | 'static');
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition, type: 'dynamic' | 'static');
     abstract convertToDTO(): PhysicsBodyDTO;
     destroy(): void;
     canCollideWith(target: PhysicsEntity): boolean;
-    protected setCollisionReports(collisionReports: CollisionReport[]): void;
 }

package/dist/physics/entity-types/physics-entity.js

@@ -6,27 +6,27 @@ const game_entities_1 = require("../../game-entities");
 const p2js_helper_1 = require("../libs/p2js.helper");
 const physics_internal_gateway_1 = require("../module/\u269C\uFE0Fgateways/physics-internal.gateway");
 class PhysicsEntity extends game_entities_1.Entity {
-    static { this.p2BodyIdToPhysicsBody = new Map(); }
-    static { this.physicsEntities = new Map(); }
-    static getFromP2BodyId(p2BodyId) {
-        return PhysicsEntity.p2BodyIdToPhysicsBody.get(p2BodyId);
+    static { this._p2BodyIDToPhysicsBody = new Map(); }
+    static { this._physicsEntities = new Map(); }
+    static getFromP2BodyID(p2BodyID) {
+        return PhysicsEntity._p2BodyIDToPhysicsBody.get(p2BodyID);
     }
-    static getFromP2BodyIdOrFail(p2BodyId) {
-        let physicsBody = PhysicsEntity.p2BodyIdToPhysicsBody.get(p2BodyId);
+    static getFromP2BodyIDOrFail(p2BodyID) {
+        let physicsBody = PhysicsEntity._p2BodyIDToPhysicsBody.get(p2BodyID);
         if (!physicsBody) {
-            throw new Error(`PhysicsEntity with p2BodyId ${p2BodyId} not found`);
+            throw new Error(`PhysicsEntity with p2BodyID ${p2BodyID} not found`);
         }
         return physicsBody;
     }
     static getPhysicsInstanceOrFail(id) {
-        let physicsEntity = PhysicsEntity.physicsEntities.get(id);
+        let physicsEntity = PhysicsEntity._physicsEntities.get(id);
         if (!physicsEntity) {
             throw new Error(`PhysicsEntity with id ${id} not found`);
         }
         return physicsEntity;
     }
     static getPhysicsEntities() {
-        return Array.from(PhysicsEntity.physicsEntities.values());
+        return Array.from(PhysicsEntity._physicsEntities.values());
     }
     get area() {
         return this._area;
@@ -37,48 +37,49 @@ class PhysicsEntity extends game_entities_1.Entity {
     get collisions() {
         return this._collisions;
     }
-    constructor(physicsWorldId, physicsEntityDefinition, type) {
+    constructor(physicsWorldID, physicsEntityDefinition, type) {
         super();
         this._onCollision = new actions_lib_1.Action();
         this.onCollision = this._onCollision.notifier;
         this.type = 'dynamic';
         this._area = 0;
         this._mass = 0;
+        /** @internal */
         this._collisions = [];
-        this.physicsWorldId = physicsWorldId;
-        this.physicsInternalGateway = game_entities_1.Service.get(physics_internal_gateway_1.PhysicsInternalGateway);
-        let material = this.physicsInternalGateway.getMaterial(this.physicsWorldId, physicsEntityDefinition.shapeDefinition.materialName);
-        let materialDefinition = this.physicsInternalGateway.getMaterialDefinition(this.physicsWorldId, physicsEntityDefinition.shapeDefinition.materialName);
+        this.physicsWorldID = physicsWorldID;
+        this._physicsInternalGateway = game_entities_1.Service.get(physics_internal_gateway_1.PhysicsInternalGateway);
+        let material = this._physicsInternalGateway.getMaterial(this.physicsWorldID, physicsEntityDefinition.shapeDefinition.materialName);
+        let materialDefinition = this._physicsInternalGateway.getMaterialDefinition(this.physicsWorldID, physicsEntityDefinition.shapeDefinition.materialName);
         this.type = type;
         this.physicsBodyGroup = physicsEntityDefinition.shapeDefinition.group;
         this.includeInPathfinding = physicsEntityDefinition.includeOnPathfinding;
-        this.physicsGroup = this.physicsInternalGateway.getGroupConstant(this.physicsWorldId, this.physicsBodyGroup);
-        this.physicsMask = this.physicsInternalGateway.getMaskConstant(this.physicsWorldId, this.physicsBodyGroup);
-        this.p2Body = this.physicsInternalGateway.createBody(this.physicsWorldId, physicsEntityDefinition, material, materialDefinition, this.type);
+        this._physicsGroup = this._physicsInternalGateway.getGroupConstant(this.physicsWorldID, this.physicsBodyGroup);
+        this._physicsMask = this._physicsInternalGateway.getMaskConstant(this.physicsWorldID, this.physicsBodyGroup);
+        this.p2Body = this._physicsInternalGateway.createBody(this.physicsWorldID, physicsEntityDefinition, material, materialDefinition, this.type);
         this._area = this.p2Body.getArea();
         this._mass = this.p2Body.mass;
         this.p2Body.position = p2js_helper_1.P2JSHelper.vectorToArray(physicsEntityDefinition.position);
         this.p2Body.angle = physicsEntityDefinition.rotation.value;
-        let addedToTheWorld = this.physicsInternalGateway.addBody(this.physicsWorldId, this.p2Body, physicsEntityDefinition.addInEmptySpace, physicsEntityDefinition.shapeDefinition.group, physicsEntityDefinition.includeOnPathfinding);
+        let addedToTheWorld = this._physicsInternalGateway.addBody(this.physicsWorldID, this.p2Body, physicsEntityDefinition.addInEmptySpace, physicsEntityDefinition.shapeDefinition.group, physicsEntityDefinition.includeOnPathfinding);
         if (!addedToTheWorld) {
             throw new Error('PhysicsEntity was not able to be added to the world!');
         }
-        PhysicsEntity.p2BodyIdToPhysicsBody.set(this.p2Body.id, this);
-        PhysicsEntity.physicsEntities.set(this.id, this);
+        PhysicsEntity._p2BodyIDToPhysicsBody.set(this.p2Body.id, this);
+        PhysicsEntity._physicsEntities.set(this.id, this);
     }
     destroy() {
         if (!this.destroyed) {
-            this.physicsInternalGateway.removeBody(this.physicsWorldId, this.p2Body);
-            PhysicsEntity.p2BodyIdToPhysicsBody.delete(this.p2Body.id);
-            PhysicsEntity.physicsEntities.delete(this.id);
             super.destroy();
+            this._physicsInternalGateway.removeBody(this.physicsWorldID, this.p2Body);
+            PhysicsEntity._p2BodyIDToPhysicsBody.delete(this.p2Body.id);
+            PhysicsEntity._physicsEntities.delete(this.id);
         }
     }
     canCollideWith(target) {
-        return p2js_helper_1.P2JSHelper.arePhysicsGroupsCollidable(this.physicsGroup, this.physicsMask, target.physicsGroup, target.physicsMask);
+        return p2js_helper_1.P2JSHelper.arePhysicsGroupsCollidable(this._physicsGroup, this._physicsMask, target._physicsGroup, target._physicsMask);
     }
-    // Managed by CollisionsService
-    setCollisionReports(collisionReports) {
+    /** @internal */
+    _setCollisionReports(collisionReports) {
         this._collisions = collisionReports;
         if (collisionReports.length > 0) {
             this._onCollision.trigger(collisionReports);

package/dist/physics/interfaces.d.ts

@@ -4,8 +4,8 @@ import { PhysicsBodyGroup } from './libs/physics-body-groups';
 export declare const SPEED_LIMIT = 10.8;
 export declare const ROTATIONAL_SPEED_LIMIT = 10.01;
 export interface PhysicsBodyDTO {
-    readonly entityId: string;
-    readonly classId: string;
+    readonly entityID: number;
+    readonly classID: number;
     readonly position: Vector;
     readonly rotation: Radian;
     readonly velocity: Vector;
@@ -25,10 +25,10 @@ export interface CollisionReport {
     readonly target: CollisionDetails;
 }
 export declare enum PhysicsShapeType {
-    point = "point",
-    circle = "circle",
-    polygon = "polygon",
-    rectangle = "rectangle"
+    Point = 1,
+    Circle = 2,
+    Polygon = 3,
+    Rectangle = 4
 }
 export type CircleShapeData = number;
 export type RectangleShapeData = Vector;

package/dist/physics/interfaces.js

@@ -5,9 +5,9 @@ exports.SPEED_LIMIT = 10.8;
 exports.ROTATIONAL_SPEED_LIMIT = 10.01;
 var PhysicsShapeType;
 (function (PhysicsShapeType) {
-    PhysicsShapeType["point"] = "point";
-    PhysicsShapeType["circle"] = "circle";
-    PhysicsShapeType["polygon"] = "polygon";
-    PhysicsShapeType["rectangle"] = "rectangle";
+    PhysicsShapeType[PhysicsShapeType["Point"] = 1] = "Point";
+    PhysicsShapeType[PhysicsShapeType["Circle"] = 2] = "Circle";
+    PhysicsShapeType[PhysicsShapeType["Polygon"] = 3] = "Polygon";
+    PhysicsShapeType[PhysicsShapeType["Rectangle"] = 4] = "Rectangle";
 })(PhysicsShapeType || (exports.PhysicsShapeType = PhysicsShapeType = {}));
 //# sourceMappingURL=interfaces.js.map

package/dist/physics/module//342/232/234/357/270/217gateways/controllers/physics-internal.controller.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="p2" />
-import { IAttachable, NotifierCallbackFunction } from 'actions-lib';
+import { IAttachment, NotifierCallbackFunction } from 'actions-lib';
 import { PhysicsEntityDefinition } from '../../../interfaces';
 import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 import { PhysicsBodyGroupService } from '../../📐services/collision/physics-body-group.service';
@@ -9,21 +9,21 @@ import { ShapeCreationService } from '../../📐services/creation/shape-creation
 import { PhysicsQueryService } from '../../📐services/query/physics-query.service';
 import { MaterialDefinition } from '../dtos/shared-interfaces.dto';
 export declare class PhysicsInternalController {
-    private physicsWorldService;
-    private physicsMaterialsService;
-    private shapeCreationService;
-    private physicsQueryService;
-    private physicsBodyGroupService;
-    constructor(physicsWorldService: PhysicsWorldService, physicsMaterialsService: MaterialsService, shapeCreationService: ShapeCreationService, physicsQueryService: PhysicsQueryService, physicsBodyGroupService: PhysicsBodyGroupService);
-    createBody(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition, material: p2.Material, materialDefinition: MaterialDefinition, type: 'dynamic' | 'static'): p2.Body;
-    getMaterial(physicsWorldId: string, name: string): p2.Material;
-    getMaterialDefinition(physicsWorldId: string, name: string): MaterialDefinition;
-    getGroupConstant(physicsWorldId: string, group: PhysicsBodyGroup): number;
-    getMaskConstant(physicsWorldId: string, group: PhysicsBodyGroup): number;
-    addBody(physicsWorldId: string, body: p2.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
-    removeBody(physicsWorldId: string, p2Body: p2.Body): void;
-    subscribeToPhysicsStep(physicsWorldId: string, callback: NotifierCallbackFunction<{
+    private _physicsWorldService;
+    private _physicsMaterialsService;
+    private _shapeCreationService;
+    private _physicsQueryService;
+    private _physicsBodyGroupService;
+    constructor(_physicsWorldService: PhysicsWorldService, _physicsMaterialsService: MaterialsService, _shapeCreationService: ShapeCreationService, _physicsQueryService: PhysicsQueryService, _physicsBodyGroupService: PhysicsBodyGroupService);
+    createBody(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition, material: p2.Material, materialDefinition: MaterialDefinition, type: 'dynamic' | 'static'): p2.Body;
+    getMaterial(physicsWorldID: number, name: string): p2.Material;
+    getMaterialDefinition(physicsWorldID: number, name: string): MaterialDefinition;
+    getGroupConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    getMaskConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    addBody(physicsWorldID: number, body: p2.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
+    removeBody(physicsWorldID: number, p2Body: p2.Body): void;
+    subscribeToPhysicsStep(physicsWorldID: number, callback: NotifierCallbackFunction<{
         time: number;
         delta: number;
-    }>): IAttachable;
+    }>): IAttachment;
 }

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

@@ -18,36 +18,36 @@ const shape_creation_service_1 = require("../../\uD83D\uDCD0services/creation/sh
 const physics_query_service_1 = require("../../\uD83D\uDCD0services/query/physics-query.service");
 const physics_internal_gateway_1 = require("../physics-internal.gateway");
 let PhysicsInternalController = class PhysicsInternalController {
-    constructor(physicsWorldService, physicsMaterialsService, shapeCreationService, physicsQueryService, physicsBodyGroupService) {
-        this.physicsWorldService = physicsWorldService;
-        this.physicsMaterialsService = physicsMaterialsService;
-        this.shapeCreationService = shapeCreationService;
-        this.physicsQueryService = physicsQueryService;
-        this.physicsBodyGroupService = physicsBodyGroupService;
+    constructor(_physicsWorldService, _physicsMaterialsService, _shapeCreationService, _physicsQueryService, _physicsBodyGroupService) {
+        this._physicsWorldService = _physicsWorldService;
+        this._physicsMaterialsService = _physicsMaterialsService;
+        this._shapeCreationService = _shapeCreationService;
+        this._physicsQueryService = _physicsQueryService;
+        this._physicsBodyGroupService = _physicsBodyGroupService;
     }
-    createBody(physicsWorldId, physicsEntityDefinition, material, materialDefinition, type) {
-        return this.shapeCreationService.createBody(physicsWorldId, physicsEntityDefinition, material, materialDefinition, type);
+    createBody(physicsWorldID, physicsEntityDefinition, material, materialDefinition, type) {
+        return this._shapeCreationService.createBody(physicsWorldID, physicsEntityDefinition, material, materialDefinition, type);
     }
-    getMaterial(physicsWorldId, name) {
-        return this.physicsMaterialsService.getMaterial(physicsWorldId, name);
+    getMaterial(physicsWorldID, name) {
+        return this._physicsMaterialsService.getMaterial(physicsWorldID, name);
     }
-    getMaterialDefinition(physicsWorldId, name) {
-        return this.physicsMaterialsService.getMaterialDefinition(physicsWorldId, name);
+    getMaterialDefinition(physicsWorldID, name) {
+        return this._physicsMaterialsService.getMaterialDefinition(physicsWorldID, name);
     }
-    getGroupConstant(physicsWorldId, group) {
-        return this.physicsBodyGroupService.getGroupConstant(physicsWorldId, group);
+    getGroupConstant(physicsWorldID, group) {
+        return this._physicsBodyGroupService.getGroupConstant(physicsWorldID, group);
     }
-    getMaskConstant(physicsWorldId, group) {
-        return this.physicsBodyGroupService.getMaskConstant(physicsWorldId, group);
+    getMaskConstant(physicsWorldID, group) {
+        return this._physicsBodyGroupService.getMaskConstant(physicsWorldID, group);
     }
-    addBody(physicsWorldId, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
-        return this.physicsWorldService.addBody(physicsWorldId, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding);
+    addBody(physicsWorldID, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding) {
+        return this._physicsWorldService.addBody(physicsWorldID, body, addInEmptySpace, physicsBodyGroup, includeOnPathfinding);
     }
-    removeBody(physicsWorldId, p2Body) {
-        this.physicsWorldService.removeBody(physicsWorldId, p2Body);
+    removeBody(physicsWorldID, p2Body) {
+        this._physicsWorldService.removeBody(physicsWorldID, p2Body);
     }
-    subscribeToPhysicsStep(physicsWorldId, callback) {
-        return this.physicsQueryService.subscribeToPhysicsStep(physicsWorldId, callback);
+    subscribeToPhysicsStep(physicsWorldID, callback) {
+        return this._physicsQueryService.subscribeToPhysicsStep(physicsWorldID, callback);
     }
 };
 exports.PhysicsInternalController = PhysicsInternalController;

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

@@ -12,23 +12,23 @@ import { TestVisualsService } from '../../📐services/test-visuals/test-visuals
 import { CreatePhysicsWorldRequestDTO, HitTestOptions, PhysicsExplosionOptions } from '../dtos/requests.dto';
 import { ExplosionHit, MapSizeDTO } from '../dtos/responses.dto';
 export declare class PhysicsController {
-    private physicsWorldService;
-    private pathFinderService;
-    private testVisualsService;
-    private explosionService;
-    private elipticExplosionService;
-    private hitTestService;
-    private physicsQueryService;
-    private impactService;
-    constructor(physicsWorldService: PhysicsWorldService, pathFinderService: PathFinderService, testVisualsService: TestVisualsService, explosionService: ExplosionService, elipticExplosionService: ElipticExplosionService, hitTestService: HitTestService, physicsQueryService: PhysicsQueryService, impactService: ImpactService);
-    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;
+    private _physicsWorldService;
+    private _pathFinderService;
+    private _testVisualsService;
+    private _explosionService;
+    private _elipticExplosionService;
+    private _hitTestService;
+    private _physicsQueryService;
+    private _impactService;
+    constructor(_physicsWorldService: PhysicsWorldService, _pathFinderService: PathFinderService, _testVisualsService: TestVisualsService, _explosionService: ExplosionService, _elipticExplosionService: ElipticExplosionService, _hitTestService: HitTestService, _physicsQueryService: PhysicsQueryService, _impactService: ImpactService);
+    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/controllers/physics.controller.js

@@ -22,47 +22,47 @@ const physics_query_service_1 = require("../../\uD83D\uDCD0services/query/physic
 const test_visuals_service_1 = require("../../\uD83D\uDCD0services/test-visuals/test-visuals.service");
 const physics_gateway_1 = require("../physics.gateway");
 let PhysicsController = class PhysicsController {
-    constructor(physicsWorldService, pathFinderService, testVisualsService, explosionService, elipticExplosionService, hitTestService, physicsQueryService, impactService) {
-        this.physicsWorldService = physicsWorldService;
-        this.pathFinderService = pathFinderService;
-        this.testVisualsService = testVisualsService;
-        this.explosionService = explosionService;
-        this.elipticExplosionService = elipticExplosionService;
-        this.hitTestService = hitTestService;
-        this.physicsQueryService = physicsQueryService;
-        this.impactService = impactService;
+    constructor(_physicsWorldService, _pathFinderService, _testVisualsService, _explosionService, _elipticExplosionService, _hitTestService, _physicsQueryService, _impactService) {
+        this._physicsWorldService = _physicsWorldService;
+        this._pathFinderService = _pathFinderService;
+        this._testVisualsService = _testVisualsService;
+        this._explosionService = _explosionService;
+        this._elipticExplosionService = _elipticExplosionService;
+        this._hitTestService = _hitTestService;
+        this._physicsQueryService = _physicsQueryService;
+        this._impactService = _impactService;
     }
     createPhysicsWorld(request) {
-        return this.physicsWorldService.createPhysicsWorld(request);
+        return this._physicsWorldService.createPhysicsWorld(request);
     }
-    getMapSize(physicsWorldId) {
-        return this.physicsQueryService.getMapSize(physicsWorldId);
+    getMapSize(physicsWorldID) {
+        return this._physicsQueryService.getMapSize(physicsWorldID);
     }
-    setPaused(pause, physicsWorldId) {
-        this.physicsWorldService.setPaused(pause, physicsWorldId);
+    setPaused(pause, physicsWorldID) {
+        this._physicsWorldService.setPaused(pause, physicsWorldID);
     }
-    hitTest(physicsEntityId, options) {
-        let physicsEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(physicsEntityId);
-        return this.hitTestService.hitTest(physicsEntity['p2Body'], options);
+    hitTest(physicsEntityID, options) {
+        let physicsEntity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(physicsEntityID);
+        return this._hitTestService.hitTest(physicsEntity.p2Body, options);
     }
-    findPath(physicsWorldId, startingPosition, target, collidableWithGroup, neighborType) {
-        return this.pathFinderService.findPathAStar(physicsWorldId, startingPosition, target, collidableWithGroup, { neighborType });
+    findPath(physicsWorldID, startingPosition, target, collidableWithGroup, neighborType) {
+        return this._pathFinderService.findPathAStar(physicsWorldID, startingPosition, target, collidableWithGroup, { neighborType });
     }
-    findPathDirection(physicsWorldId, startingPosition, target, collidableWithGroup) {
-        return this.pathFinderService.findPathDirection(physicsWorldId, startingPosition, target, collidableWithGroup);
+    findPathDirection(physicsWorldID, startingPosition, target, collidableWithGroup) {
+        return this._pathFinderService.findPathDirection(physicsWorldID, startingPosition, target, collidableWithGroup);
     }
-    applyImpulse(physicsEntityId, hitPosition, hitDirection, severity) {
-        let entity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(physicsEntityId);
-        this.impactService.applyImpulse(entity['p2Body'], hitPosition, hitDirection, severity);
+    applyImpulse(physicsEntityID, hitPosition, hitDirection, severity) {
+        let entity = physics_entity_1.PhysicsEntity.getPhysicsInstanceOrFail(physicsEntityID);
+        this._impactService.applyImpulse(entity.p2Body, hitPosition, hitDirection, severity);
     }
-    createExplosion(physicsWorldId, explosionCenter, radius, physicsBodyGroup, severity, options) {
-        return this.explosionService.createExplosion(physicsWorldId, explosionCenter, radius, physicsBodyGroup, severity, options);
+    createExplosion(physicsWorldID, explosionCenter, radius, physicsBodyGroup, severity, options) {
+        return this._explosionService.createExplosion(physicsWorldID, explosionCenter, radius, physicsBodyGroup, severity, options);
     }
-    createElipticExplosion(physicsWorldId, explosionCenter, rotation, size, physicsBodyGroup, severity, options) {
-        return this.elipticExplosionService.createElipticExplosion(physicsWorldId, explosionCenter, rotation, size, physicsBodyGroup, severity, options);
+    createElipticExplosion(physicsWorldID, explosionCenter, rotation, size, physicsBodyGroup, severity, options) {
+        return this._elipticExplosionService.createElipticExplosion(physicsWorldID, explosionCenter, rotation, size, physicsBodyGroup, severity, options);
     }
-    printPathfindingTestGrid(physicsWorldId, testLayerId, target, physicsBodyGroup, area, gridCellSize) {
-        this.testVisualsService.printPathfindingTestGrid(physicsWorldId, testLayerId, target, physicsBodyGroup, area, gridCellSize);
+    printPathfindingTestGrid(physicsWorldID, testLayerID, target, physicsBodyGroup, area, gridCellSize) {
+        this._testVisualsService.printPathfindingTestGrid(physicsWorldID, testLayerID, target, physicsBodyGroup, area, gridCellSize);
     }
 };
 exports.PhysicsController = PhysicsController;

package/dist/physics/module//342/232/234/357/270/217gateways/dtos/requests.dto.d.ts

@@ -3,7 +3,7 @@ import { PhysicsBodyGroup } from '../../../libs/physics-body-groups';
 import { BorderProperties, MaterialContactDefinition, MaterialDefinition } from './shared-interfaces.dto';
 export type InteractingBodyGroups = readonly (readonly [PhysicsBodyGroup, PhysicsBodyGroup])[];
 export interface CreatePhysicsWorldRequestDTO {
-    readonly attachTo: string;
+    readonly attachTo: number;
     readonly mapSize: Vector;
     readonly modifyUpdateCycle: boolean;
     readonly borderProperties: BorderProperties;
@@ -13,12 +13,12 @@ export interface CreatePhysicsWorldRequestDTO {
     readonly interactingBodyGroups: InteractingBodyGroups;
 }
 export interface PhysicsExplosionOptions {
-    readonly testLayerId?: string;
+    readonly testLayerID?: number;
     readonly debugRayDuration?: number;
     readonly hitOnlyClosest?: boolean;
 }
 export interface HitTestOptions {
     readonly overridePosition?: Vector;
     readonly overrideRotation?: Radian;
-    readonly testLayerId?: string;
+    readonly testLayerID?: number;
 }

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

@@ -1,20 +1,20 @@
 /// <reference types="p2" />
-import { IAttachable, NotifierCallbackFunction } from 'actions-lib';
+import { IAttachment, NotifierCallbackFunction } from 'actions-lib';
 import { ControllerLink } from '../../../game-entities';
 import { PhysicsEntityDefinition } from '../../interfaces';
 import { PhysicsBodyGroup } from '../../libs/physics-body-groups';
 import { MaterialDefinition } from './dtos/shared-interfaces.dto';
 export declare const PhysicsInternalControllerLink: ControllerLink;
 export declare class PhysicsInternalGateway {
-    createBody(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition, material: p2.Material, materialDefinition: MaterialDefinition, type: 'dynamic' | 'static'): p2.Body;
-    getMaterial(physicsWorldId: string, name: string): p2.Material;
-    getMaterialDefinition(physicsWorldId: string, name: string): MaterialDefinition;
-    getGroupConstant(physicsWorldId: string, group: PhysicsBodyGroup): number;
-    getMaskConstant(physicsWorldId: string, group: PhysicsBodyGroup): number;
-    addBody(physicsWorldId: string, body: p2.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
-    removeBody(physicsWorldId: string, p2Body: p2.Body): void;
-    subscribeToPhysicsStep(physicsWorldId: string, callback: NotifierCallbackFunction<{
+    createBody(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition, material: p2.Material, materialDefinition: MaterialDefinition, type: 'dynamic' | 'static'): p2.Body;
+    getMaterial(physicsWorldID: number, name: string): p2.Material;
+    getMaterialDefinition(physicsWorldID: number, name: string): MaterialDefinition;
+    getGroupConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    getMaskConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    addBody(physicsWorldID: number, body: p2.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
+    removeBody(physicsWorldID: number, p2Body: p2.Body): void;
+    subscribeToPhysicsStep(physicsWorldID: number, callback: NotifierCallbackFunction<{
         time: number;
         delta: number;
-    }>): IAttachable;
+    }>): IAttachment;
 }