bard-legends-framework 0.10.9 → 0.12.0

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitTestHelper = void 0;
+const actions_lib_1 = require("actions-lib");
+class UnitTestHelper {
+    static { this._hardResetAction = new actions_lib_1.Action(); }
+    static { this.onHardReset = this._hardResetAction.notifier; }
+    static hardReset() {
+        actions_lib_1.ActionLibHardReset.hardReset();
+        this._hardResetAction.trigger();
+    }
+}
+exports.UnitTestHelper = UnitTestHelper;
+//# sourceMappingURL=unit-test.helper.js.map

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

@@ -1,24 +1,25 @@
-import { Action } from 'actions-lib';
+import { SingleEvent } from 'actions-lib';
 export declare class UpdateCycle {
-    static readonly hardResetAction: Action<void>;
-    static readonly beforeSceneUpdateAction: Action<{
+    private static readonly _beforeSceneUpdateAction;
+    static readonly beforeSceneUpdateAction: import("actions-lib").Notifier<{
         time: number;
         delta: number;
     }>;
-    static readonly sceneUpdateAction: Action<{
+    private static readonly _sceneUpdateAction;
+    static readonly sceneUpdateAction: import("actions-lib").Notifier<{
         time: number;
         delta: number;
     }>;
-    static readonly afterSceneUpdateAction: Action<{
+    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,46 +2,51 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateCycle = void 0;
 const actions_lib_1 = require("actions-lib");
+const hard_reset_1 = require("./hard-reset");
 class UpdateCycle {
-    static { this.hardResetAction = new actions_lib_1.Action(); }
-    static { this.beforeSceneUpdateAction = new actions_lib_1.Action(); }
-    static { this.sceneUpdateAction = new actions_lib_1.Action(); }
-    static { this.afterSceneUpdateAction = new actions_lib_1.Action(); }
-    static { this.time = 0; }
-    static { this.updateModifierCallback = undefined; }
-    static async wait(duration) {
-        let targetTime = this.time + duration;
-        return new Promise(resolve => {
-            UpdateCycle.beforeSceneUpdateAction
+    static { this._beforeSceneUpdateAction = new actions_lib_1.Action(); }
+    static { this.beforeSceneUpdateAction = this._beforeSceneUpdateAction.notifier; }
+    static { this._sceneUpdateAction = new actions_lib_1.Action(); }
+    static { this.sceneUpdateAction = this._sceneUpdateAction.notifier; }
+    static { this._afterSceneUpdateAction = new actions_lib_1.Action(); }
+    static { this.afterSceneUpdateAction = this._afterSceneUpdateAction.notifier; }
+    /** @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() {
@@ -50,7 +55,13 @@ class UpdateCycle {
     static { this._lastDelta = 0; }
 }
 exports.UpdateCycle = UpdateCycle;
-UpdateCycle.hardResetAction.subscribe(() => {
-    UpdateCycle['time'] = 0;
-});
+hard_reset_1.BardLegendsHardReset.onHardReset
+    .subscribe(() => {
+    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,17 +1,16 @@
-import { Attachable } from '../base/attachable';
-import { Entity } from '../entity/entity';
-export type ViewClassType<EntityType> = new (entity: EntityType, ...services: any[]) => View;
-export interface ViewDecoratorMeta<EntityType> {
-    entity: new (...args: any[]) => EntityType;
+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 {
-    private static viewClassNames;
-    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

@@ -1,74 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.View = exports.ViewDecorator = void 0;
-const attachable_1 = require("../base/attachable");
-const attachable_store_1 = require("../base/helpers/attachable.store");
+const actions_lib_1 = require("actions-lib");
 const entity_views_helper_1 = require("../entity/helpers/entity-views.helper");
 const service_1 = require("../service/service");
-const update_cycle_1 = require("../update-cycle");
 function ViewDecorator(meta) {
     return function (ViewClass) {
-        if (View['viewClassNames'].has(ViewClass.name)) {
-            throw new Error(`View class names should be unique! This view name is already taken. name: "${ViewClass.name}"`);
-        }
-        else {
-            View['viewClassNames'].add(ViewClass.name);
-        }
         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 attachable_1.Attachable {
-    static { this.viewClassNames = new Set(); }
-    static getInstance(entityId) {
-        if (!attachable_store_1.AttachableStore.validateIdForClass(entityId, this.$meta.entity)) {
+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 (!attachable_store_1.AttachableStore.validateIdForClass(entityId, this.$meta.entity)) {
-            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(); // View is always attached to its entity
-        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.attachToRoot();
+        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;
     }
 }
 exports.View = View;
-update_cycle_1.UpdateCycle.hardResetAction.subscribe(() => {
-    View['viewClassNames'].clear();
-});
 //# sourceMappingURL=view.js.map