bard-legends-framework 0.11.0 → 0.12.0

package/dist/game-entities/service/service.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Service = exports.ServiceDecorator = void 0;
-const unit_test_helper_1 = require("../unit-test.helper");
+const hard_reset_1 = require("../hard-reset");
 require("reflect-metadata");
 function ServiceDecorator() {
     return function (ServiceClass) {
-        let paramtypes = Service.getParametersMeta(ServiceClass);
+        let paramtypes = Service._getParametersMeta(ServiceClass);
         ServiceClass.$meta = {
             paramtypes,
             type: 'service'
@@ -14,27 +14,29 @@ function ServiceDecorator() {
 }
 exports.ServiceDecorator = ServiceDecorator;
 class Service {
-    static { this.serviceInstances = new Map(); }
+    static { this._serviceInstances = new Map(); }
     static get(ServiceClass) {
-        let service = this.serviceInstances.get(ServiceClass);
+        let service = this._serviceInstances.get(ServiceClass);
         if (!service) {
             if (!ServiceClass.$meta) {
                 throw new Error(`Service: service class is not decorated by @ServiceDecorator(), class: "${ServiceClass.name}"`);
             }
-            let resolvedArgs = this.resolveParameters([], ServiceClass.$meta.paramtypes);
+            let resolvedArgs = this._resolveParameters([], ServiceClass.$meta.paramtypes);
             service = new ServiceClass(...resolvedArgs);
-            this.serviceInstances.set(ServiceClass, service);
+            this._serviceInstances.set(ServiceClass, service);
         }
         return service;
     }
-    static getParametersMeta(target) {
+    /** @internal */
+    static _getParametersMeta(target) {
         let paramtypes = Reflect.getMetadata('design:paramtypes', target) || [];
         if (paramtypes.some(type => !type)) {
             console.error(`Circular dependency: ${target.name}`);
         }
         return paramtypes;
     }
-    static resolveParameters(knownArgs, paramtypes) {
+    /** @internal */
+    static _resolveParameters(knownArgs, paramtypes) {
         let params = [...knownArgs];
         if (paramtypes.length > knownArgs.length) {
             let remainingParamTypes = paramtypes.slice(knownArgs.length);
@@ -47,14 +49,11 @@ class Service {
         }
         return params;
     }
-    static hardReset() {
-        this.serviceInstances = new Map();
-    }
 }
 exports.Service = Service;
-unit_test_helper_1.UnitTestHelper.onHardReset
+hard_reset_1.BardLegendsHardReset.onHardReset
     .subscribe(() => {
-    Service['serviceInstances'] = new Map();
+    Service['_serviceInstances'] = new Map();
 })
     .attachToRoot();
 //# sourceMappingURL=service.js.map

package/dist/game-entities/service/service.test.js

@@ -9,15 +9,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const actions_lib_1 = require("actions-lib");
 const vitest_1 = require("vitest");
 const entity_1 = require("../entity/entity");
+const hard_reset_1 = require("../hard-reset");
 const scene_1 = require("../scene/scene");
-const unit_test_helper_1 = require("../unit-test.helper");
 const view_1 = require("../view/view");
 const service_1 = require("./service");
 (0, vitest_1.describe)('SERVICE', () => {
     (0, vitest_1.beforeEach)(() => {
-        unit_test_helper_1.UnitTestHelper.hardReset();
+        hard_reset_1.BardLegendsHardReset.hardReset();
     });
     (0, vitest_1.test)('get services', () => {
         var SampleService_1;
@@ -38,9 +39,13 @@ const service_1 = require("./service");
     (0, vitest_1.test)('inject services to views', () => {
         var SampleService_2, SampleView_1;
         let SampleScene = class SampleScene extends scene_1.Scene {
-            async init() { }
+            init() {
+                return actions_lib_1.SingleEvent.instant();
+            }
             update() { }
-            async prepareToClose() { }
+            prepareToClose() {
+                return actions_lib_1.SingleEvent.instant();
+            }
         };
         SampleScene = __decorate([
             (0, scene_1.SceneDecorator)()
@@ -107,9 +112,13 @@ const service_1 = require("./service");
                 super();
                 this.service2 = service2;
             }
-            async init() { }
+            init() {
+                return actions_lib_1.SingleEvent.instant();
+            }
             update() { }
-            async prepareToClose() { }
+            prepareToClose() {
+                return actions_lib_1.SingleEvent.instant();
+            }
         };
         SampleScene = __decorate([
             (0, scene_1.SceneDecorator)(),
@@ -164,9 +173,13 @@ const service_1 = require("./service");
                 this.service2 = service2;
                 this.service3 = service3;
             }
-            async init() { }
+            init() {
+                return actions_lib_1.SingleEvent.instant();
+            }
             update() { }
-            async prepareToClose() { }
+            prepareToClose() {
+                return actions_lib_1.SingleEvent.instant();
+            }
         };
         SampleScene = __decorate([
             (0, scene_1.SceneDecorator)(),
@@ -198,9 +211,13 @@ const service_1 = require("./service");
                 super();
                 this.service = service;
             }
-            async init() { }
+            init() {
+                return actions_lib_1.SingleEvent.instant();
+            }
             update() { }
-            async prepareToClose() { }
+            prepareToClose() {
+                return actions_lib_1.SingleEvent.instant();
+            }
         };
         SampleScene = __decorate([
             (0, scene_1.SceneDecorator)(),
@@ -213,9 +230,13 @@ const service_1 = require("./service");
     (0, vitest_1.test)('resolve parameters should pass known parameters with falsely values', () => {
         var Parent_1;
         let SampleScene = class SampleScene extends scene_1.Scene {
-            async init() { }
+            init() {
+                return actions_lib_1.SingleEvent.instant();
+            }
             update() { }
-            async prepareToClose() { }
+            prepareToClose() {
+                return actions_lib_1.SingleEvent.instant();
+            }
         };
         SampleScene = __decorate([
             (0, scene_1.SceneDecorator)()

package/dist/game-entities/unit-test.helper.js

@@ -6,7 +6,7 @@ class UnitTestHelper {
     static { this._hardResetAction = new actions_lib_1.Action(); }
     static { this.onHardReset = this._hardResetAction.notifier; }
     static hardReset() {
-        actions_lib_1.ActionLibUnitTestHelper.hardReset();
+        actions_lib_1.ActionLibHardReset.hardReset();
         this._hardResetAction.trigger();
     }
 }

package/dist/game-entities/update-cycle.d.ts

@@ -1,35 +1,25 @@
-import { Action } from 'actions-lib';
+import { SingleEvent } from 'actions-lib';
 export declare class UpdateCycle {
-    static readonly _beforeSceneUpdateAction: Action<{
-        time: number;
-        delta: number;
-    }>;
+    private static readonly _beforeSceneUpdateAction;
     static readonly beforeSceneUpdateAction: import("actions-lib").Notifier<{
         time: number;
         delta: number;
     }>;
-    static readonly _sceneUpdateAction: Action<{
-        time: number;
-        delta: number;
-    }>;
+    private static readonly _sceneUpdateAction;
     static readonly sceneUpdateAction: import("actions-lib").Notifier<{
         time: number;
         delta: number;
     }>;
-    static readonly _afterSceneUpdateAction: Action<{
-        time: number;
-        delta: number;
-    }>;
+    private static readonly _afterSceneUpdateAction;
     static readonly afterSceneUpdateAction: import("actions-lib").Notifier<{
         time: number;
         delta: number;
     }>;
-    private static time;
-    private static updateModifierCallback;
-    static wait(duration: number): Promise<void>;
+    private static _updateModifierCallback;
+    static wait(duration: number): SingleEvent;
     static registerUpdateModifier(callback: (time: number, delta: number) => number): void;
     static cleanUpdateModifier(): void;
-    static triggerUpdateTick(delta: number): Promise<void>;
+    static triggerUpdateTick(delta: number): void;
     static get lastDelta(): number;
     private static _lastDelta;
 }

package/dist/game-entities/update-cycle.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateCycle = void 0;
 const actions_lib_1 = require("actions-lib");
-const unit_test_helper_1 = require("./unit-test.helper");
+const hard_reset_1 = require("./hard-reset");
 class UpdateCycle {
     static { this._beforeSceneUpdateAction = new actions_lib_1.Action(); }
     static { this.beforeSceneUpdateAction = this._beforeSceneUpdateAction.notifier; }
@@ -10,41 +10,43 @@ class UpdateCycle {
     static { this.sceneUpdateAction = this._sceneUpdateAction.notifier; }
     static { this._afterSceneUpdateAction = new actions_lib_1.Action(); }
     static { this.afterSceneUpdateAction = this._afterSceneUpdateAction.notifier; }
-    static { this.time = 0; }
-    static { this.updateModifierCallback = undefined; }
-    static async wait(duration) {
-        let targetTime = this.time + duration;
-        return new Promise(resolve => {
-            UpdateCycle.beforeSceneUpdateAction
+    /** @internal */
+    static { this._time = 0; }
+    static { this._updateModifierCallback = undefined; }
+    static wait(duration) {
+        let targetTime = this._time + duration;
+        return actions_lib_1.SingleEvent.create(resolve => {
+            let subscription = UpdateCycle.beforeSceneUpdateAction
                 .subscribe(update => {
                 if (update.time >= targetTime) {
                     resolve();
                 }
             })
                 .attachToRoot();
+            return () => subscription.destroy();
         });
     }
     static registerUpdateModifier(callback) {
-        if (!this.updateModifierCallback) {
-            this.updateModifierCallback = callback;
+        if (!this._updateModifierCallback) {
+            this._updateModifierCallback = callback;
         }
         else {
             throw new Error('UpdateCycle: There can only one update modifier!');
         }
     }
     static cleanUpdateModifier() {
-        this.updateModifierCallback = undefined;
+        this._updateModifierCallback = undefined;
     }
-    static async triggerUpdateTick(delta) {
-        if (this.updateModifierCallback) {
-            delta = this.updateModifierCallback(this.time, delta);
+    static triggerUpdateTick(delta) {
+        if (this._updateModifierCallback) {
+            delta = this._updateModifierCallback(this._time, delta);
         }
-        this.time += delta;
+        this._time += delta;
         this._lastDelta = delta;
         if (delta > 0) {
-            UpdateCycle._beforeSceneUpdateAction.trigger({ time: this.time, delta });
-            UpdateCycle._sceneUpdateAction.trigger({ time: this.time, delta });
-            UpdateCycle._afterSceneUpdateAction.trigger({ time: this.time, delta });
+            UpdateCycle._beforeSceneUpdateAction.trigger({ time: this._time, delta });
+            UpdateCycle._sceneUpdateAction.trigger({ time: this._time, delta });
+            UpdateCycle._afterSceneUpdateAction.trigger({ time: this._time, delta });
         }
     }
     static get lastDelta() {
@@ -53,9 +55,13 @@ class UpdateCycle {
     static { this._lastDelta = 0; }
 }
 exports.UpdateCycle = UpdateCycle;
-unit_test_helper_1.UnitTestHelper.onHardReset
+hard_reset_1.BardLegendsHardReset.onHardReset
     .subscribe(() => {
-    UpdateCycle['time'] = 0;
+    UpdateCycle['_beforeSceneUpdateAction'].clear();
+    UpdateCycle['_sceneUpdateAction'].clear();
+    UpdateCycle['_afterSceneUpdateAction'].clear();
+    UpdateCycle['_updateModifierCallback'] = undefined;
+    UpdateCycle['_time'] = 0;
 })
     .attachToRoot();
 //# sourceMappingURL=update-cycle.js.map

package/dist/game-entities/view/view.d.ts

@@ -1,16 +1,16 @@
-import { Attachable } from 'actions-lib';
+import { IDAttachable } from 'actions-lib';
 import { Entity, EntityClassType } from '../entity/entity';
 export type ViewClassType<EntityType extends Entity> = new (entity: EntityType, ...services: any[]) => View;
 export interface ViewDecoratorMeta<EntityType extends Entity> {
     entity: EntityClassType<EntityType>;
 }
 export declare function ViewDecorator<EntityType extends Entity>(meta: ViewDecoratorMeta<EntityType>): (ViewClass: ViewClassType<EntityType>) => any;
-export declare abstract class View extends Attachable {
-    static getInstance<T extends View>(this: new (...args: any[]) => T, entityId: string): T | undefined;
-    static getInstanceOrFail<T extends View>(this: new (...args: any[]) => T, entityId: string): T;
-    private _entityId;
+export declare abstract class View extends IDAttachable {
+    static getInstance<T extends View>(this: new (...args: any[]) => T, entityID: number): T | undefined;
+    static getInstanceOrFail<T extends View>(this: new (...args: any[]) => T, entityID: number): T;
+    private _entityID;
     constructor();
     destroy(): void;
     update(time: number, delta: number): void;
-    private getViewInstances;
+    private _getViewInstances;
 }

package/dist/game-entities/view/view.js

@@ -7,54 +7,48 @@ const service_1 = require("../service/service");
 function ViewDecorator(meta) {
     return function (ViewClass) {
         ViewClass.$meta = {
-            paramtypes: service_1.Service.getParametersMeta(ViewClass),
+            paramtypes: service_1.Service._getParametersMeta(ViewClass),
             viewInstances: new Map(),
             entity: meta.entity,
             type: 'view'
         };
-        entity_views_helper_1.EntityViewsHelper['registerView'](ViewClass, meta.entity);
+        entity_views_helper_1.EntityViewsHelper.registerView(ViewClass, meta.entity);
     };
 }
 exports.ViewDecorator = ViewDecorator;
-class View extends actions_lib_1.Attachable {
-    static getInstance(entityId) {
-        if (!this.$meta.entity.validateId(entityId)) {
+class View extends actions_lib_1.IDAttachable {
+    static getInstance(entityID) {
+        if (!this.$meta.entity.validateID(entityID)) {
             return undefined;
         }
         let viewInstances = this.$meta.viewInstances;
-        return viewInstances.get(entityId);
+        return viewInstances.get(entityID);
     }
-    static getInstanceOrFail(entityId) {
-        if (!this.$meta.entity.validateId(entityId)) {
-            throw new Error(`View: getInstance is called with entity id: "${entityId}", that is not belonging to the class: "${this.$meta.entity}"`);
+    static getInstanceOrFail(entityID) {
+        if (!this.$meta.entity.validateID(entityID)) {
+            throw new Error(`View: getInstance is called with entity id: "${entityID}", that is not belonging to the class: "${this.$meta.entity}"`);
         }
         let viewInstances = this.$meta.viewInstances;
-        let view = viewInstances.get(entityId);
+        let view = viewInstances.get(entityID);
         if (!view) {
-            throw new Error(`View: getInstanceOrFail is called with entity id: "${entityId}", that is not found!`);
+            throw new Error(`View: getInstanceOrFail is called with entity id: "${entityID}", that is not found!`);
         }
         return view;
     }
     constructor() {
         super();
         this.attachToRoot();
-        this._entityId = entity_views_helper_1.EntityViewsHelper.currentEntityId;
-        this.getViewInstances().set(this._entityId, this);
-        let originalUpdate = this.update.bind(this);
-        this.update = function (time, delta) {
-            if (!this.destroyed) {
-                originalUpdate(time, delta);
-            }
-        };
+        this._entityID = entity_views_helper_1.EntityViewsHelper.entityID;
+        this._getViewInstances().set(this._entityID, this);
     }
     destroy() {
         if (!this.destroyed) {
-            this.getViewInstances().delete(this._entityId);
             super.destroy();
+            this._getViewInstances().delete(this._entityID);
         }
     }
     update(time, delta) { }
-    getViewInstances() {
+    _getViewInstances() {
         return this.constructor.$meta.viewInstances;
     }
 }

package/dist/game-entities/view/view.test.js

@@ -12,17 +12,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const actions_lib_1 = require("actions-lib");
 const vitest_1 = require("vitest");
 const entity_1 = require("../entity/entity");
+const hard_reset_1 = require("../hard-reset");
 const scene_1 = require("../scene/scene");
-const unit_test_helper_1 = require("../unit-test.helper");
 const update_cycle_1 = require("../update-cycle");
 const view_1 = require("./view");
 (0, vitest_1.describe)('VIEW', () => {
     (0, vitest_1.beforeEach)(() => {
-        unit_test_helper_1.UnitTestHelper.hardReset();
+        hard_reset_1.BardLegendsHardReset.hardReset();
         let SampleScene = class SampleScene extends scene_1.Scene {
-            async init() { }
+            init() {
+                return actions_lib_1.SingleEvent.instant();
+            }
             update() { }
-            async prepareToClose() { }
+            prepareToClose() {
+                return actions_lib_1.SingleEvent.instant();
+            }
         };
         SampleScene = __decorate([
             (0, scene_1.SceneDecorator)()
@@ -233,9 +237,9 @@ const view_1 = require("./view");
             (0, view_1.ViewDecorator)({ entity: BaseEntity }),
             __metadata("design:paramtypes", [BaseEntity])
         ], SampleView);
-        (0, vitest_1.expect)(() => SampleView.getInstanceOrFail(sampleEntity.id)).toThrow('View: getInstance is called with entity id: "3:1", that is not belonging to the class:');
+        (0, vitest_1.expect)(() => SampleView.getInstanceOrFail(sampleEntity.id)).toThrow('View: getInstance is called with entity id: "3", that is not belonging to the class:');
     });
-    (0, vitest_1.test)('destroying entity should not prevent subscription of the view', async () => {
+    (0, vitest_1.test)('destroying entity should prevent subscription of the view (new expected case)', async () => {
         var Sample_1, SampleView_7;
         let sampleAction = new actions_lib_1.Action();
         let Sample = class Sample extends entity_1.Entity {
@@ -258,7 +262,7 @@ const view_1 = require("./view");
         let SampleView = class SampleView extends view_1.View {
             static { SampleView_7 = this; }
             static { this.triggered = false; }
-            constructor(entity) {
+            constructor(_) {
                 super();
                 sampleAction
                     .subscribe(() => {
@@ -273,8 +277,8 @@ const view_1 = require("./view");
         ], SampleView);
         let entity = new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
         sampleAction.trigger();
-        (0, vitest_1.expect)(Sample.triggered).toEqual(true);
-        (0, vitest_1.expect)(SampleView.triggered).toEqual(true);
+        (0, vitest_1.expect)(Sample.triggered).toBeTruthy();
+        (0, vitest_1.expect)(SampleView.triggered).toBeFalsy();
     });
     (0, vitest_1.test)('if view destroys the entity, the view should also be destroyed', async () => {
         var Sample_2, SampleView_8;
@@ -313,5 +317,32 @@ const view_1 = require("./view");
         (0, vitest_1.expect)(Sample.destroyed).toEqual(true);
         (0, vitest_1.expect)(SampleView.destroyed).toEqual(true);
     });
+    (0, vitest_1.test)('if entity get destroyed, the view update should not be called', () => {
+        let viewUpdateCount = 0;
+        let Sample = class Sample extends entity_1.Entity {
+            update() {
+                this.destroy();
+            }
+        };
+        Sample = __decorate([
+            (0, entity_1.EntityDecorator)()
+        ], Sample);
+        let _SampleView = class _SampleView extends view_1.View {
+            constructor(entity) {
+                super();
+            }
+            update() {
+                viewUpdateCount++;
+            }
+        };
+        _SampleView = __decorate([
+            (0, view_1.ViewDecorator)({ entity: Sample }),
+            __metadata("design:paramtypes", [Sample])
+        ], _SampleView);
+        new Sample().attach(scene_1.Scene.getActiveSceneOrFail());
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(0);
+        update_cycle_1.UpdateCycle.triggerUpdateTick(1);
+        (0, vitest_1.expect)(viewUpdateCount).toEqual(0);
+    });
 });
 //# sourceMappingURL=view.test.js.map

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

@@ -4,6 +4,6 @@ import { PhysicsEntity } from './physics-entity';
 export declare abstract class ImmovablePhysicsEntity extends PhysicsEntity {
     readonly position: Vector;
     readonly rotation: Radian;
-    constructor(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition);
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
     convertToDTO(): PhysicsBodyDTO;
 }

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

@@ -5,15 +5,15 @@ const helpers_lib_1 = require("helpers-lib");
 const p2js_helper_1 = require("../libs/p2js.helper");
 const physics_entity_1 = require("./physics-entity");
 class ImmovablePhysicsEntity extends physics_entity_1.PhysicsEntity {
-    constructor(physicsWorldId, physicsEntityDefinition) {
-        super(physicsWorldId, physicsEntityDefinition, 'static');
+    constructor(physicsWorldID, physicsEntityDefinition) {
+        super(physicsWorldID, physicsEntityDefinition, 'static');
         this.position = p2js_helper_1.P2JSHelper.arrayToVector(this.p2Body.position);
         this.rotation = new helpers_lib_1.Radian(this.p2Body.angle);
     }
     convertToDTO() {
         return {
-            entityId: this.id,
-            classId: this.classId,
+            entityID: this.id,
+            classID: this.classID,
             position: this.position,
             rotation: this.rotation,
             velocity: helpers_lib_1.Vector.zero,

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

@@ -7,5 +7,5 @@ export declare abstract class MovableEntity extends Entity {
     readonly velocity: Variable<Vector>;
     readonly rotationalSpeed: Variable<number>;
     constructor();
-    private step;
+    private _step;
 }

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

@@ -13,11 +13,11 @@ class MovableEntity extends game_entities_1.Entity {
         this.rotationalSpeed = new actions_lib_1.Variable(0);
         game_entities_1.UpdateCycle.beforeSceneUpdateAction
             .subscribe(({ time, delta }) => {
-            this.step(time, delta);
+            this._step(time, delta);
         })
             .attach(this);
     }
-    step(time, delta) {
+    _step(time, delta) {
         this.position.value = this.position.value.add(this.velocity.value.multiplyNumber(delta));
         this.rotation.value = new helpers_lib_1.Radian(this.rotation.value.value + this.rotationalSpeed.value * delta);
     }

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

@@ -7,13 +7,13 @@ export declare abstract class MovablePhysicsEntity extends PhysicsEntity {
     readonly rotation: Variable<Radian>;
     readonly velocity: Variable<Vector>;
     readonly rotationalSpeed: Variable<number>;
-    private ignorePositionUpdate;
-    private ignoreRotationUpdate;
-    private ignoreVelocityUpdate;
-    private ignoreRotationalSpeedUpdate;
-    constructor(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition);
+    private _ignorePositionUpdate;
+    private _ignoreRotationUpdate;
+    private _ignoreVelocityUpdate;
+    private _ignoreRotationalSpeedUpdate;
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
     convertToDTO(): PhysicsBodyDTO;
-    private step;
-    private phsicsToLocalSync;
-    private localToPhsicsSync;
+    private _step;
+    private _phsicsToLocalSync;
+    private _localToPhsicsSync;
 }