@woosh/meep-engine 2.127.1 → 2.128.1

package/src/engine/ecs/EntityManager.js

@@ -10,7 +10,7 @@ import { EntityComponentDataset } from "./EntityComponentDataset.js";
 import { EntityObserver } from "./EntityObserver.js";
 import { System, SystemState } from "./System.js";
 import { computeSystemComponentDependencyGraph } from "./system/computeSystemComponentDependencyGraph.js";
-import { validateSystem } from "./validateSystem.js";
+import { system_validate_class } from "./system_validate_class.js";
 
 /**
  * @readonly
@@ -25,6 +25,12 @@ export const EntityManagerState = {
     Stopped: 5
 };
 
+/**
+ * In seconds
+ * @type {number}
+ */
+const DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK = 5;
+
 /**
  * Brings together {@link System}s and an {@link EntityComponentDataset}
  * Main entry point into the simulation process
@@ -261,7 +267,7 @@ export class EntityManager {
 
         const localComponentTypeMap = this.getComponentTypeMap();
 
-        //ensure compatibility with system-used component map
+        // ensure compatibility with system-used component map
         dataset.registerManyComponentTypes(localComponentTypeMap);
 
         this.dataset = dataset;
@@ -450,7 +456,7 @@ export class EntityManager {
     /**
      * If the {@link EntityManager} is already started, the system will be started automatically before being added
      * @param {System} system
-     * @returns {Promise}
+     * @returns {Promise} resolution depends on {@link EntityManager}'s state, if running - promise resolves after system startup. Otherwise, the promise will be resolved immediately.
      * @throws {IllegalStateException}
      */
     addSystem(system) {
@@ -470,19 +476,19 @@ export class EntityManager {
 
 
         try {
-            validateSystem(system);
+            system_validate_class(system);
         } catch (e) {
-            console.error(`System validation failed '${computeSystemName(system)}' : `, e, system);
+            console.error(`Validation of '${computeSystemName(system)}' failed : `, e, system);
         }
 
         //check system state
         const systemState = system.state.getValue();
 
-        const legalStates = [SystemState.INITIAL, SystemState.STOPPED];
+        const valid_states = [SystemState.INITIAL, SystemState.STOPPED];
 
-        if (legalStates.indexOf(systemState) === -1) {
+        if (valid_states.indexOf(systemState) === -1) {
             //illegal state
-            throw new IllegalStateException(`System must be in one of these states: [${legalStates.join(",")}], instead was ${systemState}`);
+            throw new IllegalStateException(`System must be in one of these states: [${valid_states.join(",")}], instead was ${systemState}`);
         }
 
         const systems = this.systems;
@@ -495,22 +501,16 @@ export class EntityManager {
         const entityObserver = new EntityObserver(system.dependencies, system.link, system.unlink, system);
         this.systemObservers.set(system, entityObserver);
 
-        let startup_promise;
+        let result_promise;
         if (this.state === EntityManagerState.Running) {
             //initialize the system
-            startup_promise = new Promise((resolve, reject) => {
+            result_promise = new Promise((resolve, reject) => {
                 this.startSystem(system, resolve, reject);
             });
         } else {
-            startup_promise = Promise.resolve();
+            result_promise = Promise.resolve();
         }
 
-        // Link EntityManager
-        if (system.entityManager === null) {
-            system.entityManager = this;
-        } else if (system.entityManager !== this) {
-            throw new Error(`System is bound to another EntityManager`);
-        }
 
         // link dependency components
         this.dataset?.registerManyComponentTypes(system.referenced_components);
@@ -519,8 +519,7 @@ export class EntityManager {
 
         this.on.systemAdded.send1(system);
 
-
-        return startup_promise;
+        return result_promise;
     }
 
     /**
@@ -601,7 +600,13 @@ export class EntityManager {
         }
 
         try {
-            system.shutdown(self, systemReady, systemFailed);
+            const promise = system.shutdown(self);
+
+            assert.defined(promise, "promise");
+            assert.notNull(promise, "promise");
+            assert.isFunction(promise.then, "promise.then");
+
+            promise.then(systemReady, systemFailed);
         } catch (e) {
             console.error(`Failed to execute system shutdown`, e);
             errorCallback(e);
@@ -662,25 +667,53 @@ export class EntityManager {
             successCallback(system);
         }
 
-        function systemFailed(reason) {
-            errorCallback(reason);
-        }
-
         try {
-            system.startup(self, systemReady, systemFailed);
+
+            const deprecation_check = () => {
+                throw new Error("'success' callback was deprecated in meep 2.128.0, please use `async` instead.");
+            };
+
+            // Link EntityManager
+            if (system.entityManager === null || system.entityManager === undefined) {
+                system.entityManager = this;
+            } else if (system.entityManager !== this) {
+                throw new Error(`System is bound to another EntityManager`);
+            }
+
+            const promise = system.startup(self, deprecation_check);
+
+
+            assert.defined(promise, "promise");
+            assert.notNull(promise, "promise");
+            assert.isFunction(promise.then, "promise.then");
+
+            const startup_check_timeout = setTimeout(
+                () => {
+                    console.warn(`System '${computeSystemName(system)}' failed to complete startup process in ${DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK}s, check your code for potential deadlocks.`);
+                },
+                DEFAULT_SYSTEM_STARTUP_TIMEOUT_CHECK * 1000,
+            );
+
+            promise.finally(() => {
+                clearTimeout(startup_check_timeout);
+            });
+
+            promise.then(systemReady, errorCallback);
+
         } catch (e) {
             console.error(`Failed to execute system startup`, e);
-            systemFailed(e);
+            errorCallback(e);
         }
     }
 
     /**
-     * This method is asynchronous by nature, it has to wait for each individual system to finish its own statup.
-     * Make sure to register callback in order to be notified when the startup has finished
+     * This method is asynchronous by nature, it has to wait for each system to finish its own startup.
+     * Make sure to register callback to be notified when the startup has finished
      * @param {function} [readyCallback] executed once entity manager successfully completes startup
      * @param {function} [errorCallback] executed if entity manager encounters an error during startup
      */
     startup(readyCallback = noop, errorCallback = console.error) {
+
         if (this.state === EntityManagerState.Starting) {
             throw new IllegalStateException(`System is currently in starting state`);
         }
@@ -743,15 +776,15 @@ export class EntityManager {
             return;
         }
 
-        systems.forEach(function (system) {
+        for (const system of systems) {
             //ensure eventManager are there
             //start the system
             const cbOK = systemReady.bind(null, system);
             const cbError = systemError.bind(null, system);
 
-            self.startSystem(system, cbOK, cbError);
+            this.startSystem(system, cbOK, cbError);
 
-        });
+        }
     }
 
     /**
@@ -786,7 +819,6 @@ export class EntityManager {
     }
 
     /**
-     *
      * @param {Class} systemClass
      * @param {SystemState} state
      * @returns {Promise.<System>}
@@ -814,21 +846,24 @@ export class EntityManager {
     }
 
     /**
-     * This method is asynchronous by nature, it will not be done until each individual system has finished its shutdown
+     * This method is asynchronous by nature, it will not be done until each system has finished its shutdown
      * Make sure to use callback to be notified when the shutdown has completed
      * @param {function} [readyCallback] Called when shutdown finishes successfully. defaults to no-operation
-     * @param {function} [errorCallback] Called when an error occurs during shutdown process. defaults to console error output
+     * @param {function} [errorCallback] Called when an error occurs during the shutdown process. defaults to console error output
      */
     shutdown(readyCallback = noop, errorCallback = console.error) {
         if (this.state !== EntityManagerState.Running) {
             throw new IllegalStateException(`System is wrong state, expected '${EntityManagerState.Running}'`);
         }
 
+        assert.isFunction(readyCallback, 'readyCallback');
+        assert.isFunction(errorCallback, 'errorCallback');
+
         this.state = EntityManagerState.Stopping;
 
         if (this.dataset !== null) {
             // a dataset is still attached, to properly dispose of all the component-bound resources, we first detach the dataset
-            this.detachDataSet();
+            this.detachDataset();
         }
 
         const self = this;
@@ -877,18 +912,29 @@ export class EntityManager {
             finalizeShutdown();
         }
 
-        systems.forEach(function (system) {
+        for (const system of systems) {
+
             system.state.set(SystemState.STOPPING);
-            //start the system
+
             const cbOK = systemReady.bind(null, system);
             const cbError = systemError.bind(null, system);
+
             try {
-                system.shutdown(self, cbOK, cbError);
+                const promise = system.shutdown(this);
+
+                assert.defined(promise, 'promise');
+                assert.notNull(promise, 'promise');
+                assert.isFunction(promise.then, 'promise.then');
+
+                // TODO add timeout
+
+                promise.then(cbOK, cbError);
             } catch (e) {
                 //failure in shutdown function
                 cbError(e);
             }
-        });
+
+        }
     }
 }
 

package/src/engine/ecs/EntityReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityReference.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityReference.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAsHI;;;;;OAKG;IACH,gBAJW,MAAM,cACN,MAAM,GACL,eAAe,CAQ1B;IAED;;;;;OAKG;IACH,6CAHW,MAAM,GACJ,eAAe,CAQ3B;IA9ID;;;;OAIG;IACH,IAFU,MAAM,CAET;IAEP;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,YAFW,eAAe,QAKzB;IAED;;;OAGG;IACH,SAFa,eAAe,CAQ3B;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAMlB;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAYnB;IAED;;;;;OAKG;IACH,sCAFa,OAAO,CASnB;IAED;;;;OAIG;IACH,0CAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,SAHW,MAAM,cACN,MAAM,QAUhB;IA+BL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;cAWS,eAAe"}
+{"version":3,"file":"EntityReference.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityReference.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAwHI;;;;;OAKG;IACH,gBAJW,MAAM,cACN,MAAM,GACL,eAAe,CAQ1B;IAED;;;;;OAKG;IACH,6CAHW,MAAM,GACJ,eAAe,CAQ3B;IAhJD;;;;OAIG;IACH,IAFU,MAAM,CAET;IAEP;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,YAFW,eAAe,QAOzB;IAED;;;OAGG;IACH,SAFa,eAAe,CAQ3B;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAMlB;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAYnB;IAED;;;;;OAKG;IACH,sCAFa,OAAO,CASnB;IAED;;;;OAIG;IACH,0CAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,SAHW,MAAM,cACN,MAAM,QAUhB;IA+BL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;cAWS,eAAe"}

package/src/engine/ecs/EntityReference.js

@@ -42,6 +42,8 @@ export class EntityReference {
      * @param {EntityReference} other
      */
     copy(other) {
+        assert.defined(other, 'other');
+
         this.id = other.id;
         this.generation = other.generation;
     }

package/src/engine/ecs/System.d.ts

@@ -11,9 +11,9 @@ export class System<A, B = any, C = any, D = any, E = any> {
 
     protected readonly entityManager: EntityManager
 
-    startup(em: EntityManager, ready_callback: () => void, error_callback: () => void): void
+    startup(em: EntityManager): Promise<void>
 
-    shutdown(em: EntityManager, ready_callback: () => void, error_callback: () => void): void
+    shutdown(em: EntityManager): Promise<void>
 
     link(a: A, entity: number): void
     link(a: A, b: B, entity: number): void

package/src/engine/ecs/System.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;OAKG;IACH,oBAAkB;IAElB;;;;;;;;;OASG;IACH,iBAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;OAIG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,8FAGC;IAED;;;;;;;OAOG;IACH,+FAEC;IAGD;;;;OAIG;IACH,wCAEC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;;;;;OAQG;IACH,6DAEC;IAED;;;;;;;;OAQG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,yBAA4B;IAG5B;;;;;;OAMG;IACH,oBAAuB;CAvBtB;;;;0BA8CS,MAAM;;;;;;;;qBAjPK,6BAA6B"}
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;OAOG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;OAIG;IACH,wCAEC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,yBAA4B;IAG5B;;;;;;OAMG;IACH,oBAAuB;CAvBtB;0BA2BS,MAAM;;;;;;;;qBArOK,6BAA6B"}

package/src/engine/ecs/System.js

@@ -54,7 +54,9 @@ export class System {
     /**
      * Component classes which have to be present before the system links an entity.
      * NOTE: do not modify this while the system is running.
-     * see {@link link} and {@link unlink} methods.
+     * @see link
+     * @see unlink
+     * @readonly
      * @type {Array}
      */
     dependencies = [];
@@ -67,6 +69,7 @@ export class System {
      *
      * NOTE: specifying this is optional. The engine will still work.
      * NOTE: do not modify this while the system is running
+     * @readonly
      * @type {ResourceAccessSpecification[]}
      */
     components_used = [];
@@ -92,9 +95,10 @@ export class System {
     }
 
     /**
+     * Does not check if the component is present, will return 0 if not present.
      * @template T
      * @param {T} Klass
-     * @return {number}
+     * @return {number} bitmask of {@link ResourceAccessKind}
      */
     getAccessForComponent(Klass) {
         let result = 0;
@@ -127,27 +131,26 @@ export class System {
     }
 
     /**
-     * Invoked before system is used
-     * Managed by {@EntityManager}'s lifecycle. Do not call this manually.
+     * Invoked before {@link System} is used for the first time.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
      * @param {EntityManager} entityManager
-     * @param {function} readyCallback must be called by the system when the startup process is finished
-     * @param {function} errorCallback must be called by the system if any issues occur during startup process that prevent completion
+     * @returns {Promise<void>}
+     * @see shutdown
      */
-    startup(entityManager, readyCallback, errorCallback) {
-        this.entityManager = entityManager;
-        readyCallback();
+    async startup(entityManager) {
+        // override as necessary
     }
 
     /**
-     * Invoked when system is no longer needed.
+     * Invoked when {@link System} is no longer needed.
      * Good place to clean up any held resourced and terminate owned processes.
-     * Managed by {@EntityManager}'s lifecycle. Do not call this manually.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
      * @param {EntityManager} entityManager
-     * @param {function} readyCallback
-     * @param {function} errorCallback
+     * @returns {Promise<void>}
+     * @see startup
      */
-    shutdown(entityManager, readyCallback, errorCallback) {
-        readyCallback();
+    async shutdown(entityManager) {
+        // override as necessary
     }
 
 
@@ -171,10 +174,12 @@ export class System {
 
     /**
      * Invoked when a dataset is attached to the system, this happens before any entities are linked.
-     * Happens as a result of {@link EntityManager.attachDataSet}.
+     * Happens as a result of {@link EntityManager.attachDataset}.
      * It is generally advised *NOT* to modify the dataset here.
-     * Managed by {@EntityManager}'s lifecycle. Do not call this manually.
-     * Entirely optional, provides advanced functionality for situations where datasets are being switched on the fly.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
+     *
+     * This method is entirely optional, it provides advanced functionality for situations where datasets are being switched on the fly.
+     *
      * see {@link handleDatasetDetached} for the reverse.
      * @param {EntityComponentDataset} dataset
      */
@@ -184,10 +189,12 @@ export class System {
 
     /**
      * Invoked when dataset is about to be detached from the system, this happens after all entities have been unlinked.
-     * Happens as a result of {@link EntityManager.detachDataSet}.
+     * Happens as a result of {@link EntityManager.detachDataset}.
      * It is generally advised *NOT* to modify the dataset here.
-     * Managed by {@EntityManager}'s lifecycle. Do not call this manually.
-     * Entirely optional, provides advanced functionality for situations where datasets are being switched on the fly.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
+     *
+     * This method is entirely optional, it provides advanced functionality for situations where datasets are being switched on the fly.
+     *
      * see {@link handleDatasetAttached} for the reverse.
      * @param {EntityComponentDataset} dataset
      */
@@ -216,44 +223,34 @@ System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple ch
  * Note that this time step can vary depending on system conditions and hardware we are running on.
  * It is generally safe to assume that this update will happen once per frame, but it is not guaranteed.
  * Also, note that when the application window/tab is suspended, the next update step can have a very large value.
- * @param {number} timeDelta Time in seconds
+ * @param {number} timeDelta in seconds
  */
 System.prototype.update = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
 
-Object.defineProperties(System.prototype, {
-    /**
-     * @deprecated
-     */
-    componentClass: {
-        configurable: true,
-        /**
-         * @deprecated
-         * @returns {Class<C>}
-         */
-        get() {
-            console.warn(`componentClass property is deprecated and should not be used`);
-            return null;
-        }
-
-    }
-
-});
-
 /**
  * @readonly
  * @enum {number}
  */
 export const SystemState = {
     INITIAL: 0,
+    /**
+     * System is currently in the process of starting up.
+     * @see System.startup
+     */
     STARTING: 1,
+    /**
+     * System is in the main running state, after startup has successfully finished.
+     */
     RUNNING: 2,
+    /**
+     * System is currently in the process of shutting down.
+     * @see System.shutdown
+     */
     STOPPING: 3,
+    /**
+     * System has finished shutting down.
+     * @see System.shutdown
+     */
     STOPPED: 4
 }
 
-/**
- * @readonly
- * @deprecated use {@link SystemState} directly instead
- */
-System.State = SystemState;
-

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts

@@ -109,7 +109,7 @@ export class DynamicActorSystem extends AbstractContextSystem<any> {
      * @returns {DynamicRuleDescription|undefined}
      */
     match(entity: number, event: string, context: any): DynamicRuleDescription | undefined;
-    startup(entityManager: any, readyCallback: any, errorCallback: any): Promise<void>;
+    startup(entityManager: any): Promise<void>;
     /**
      *
      * @param {DynamicActor} actor

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yFAHW,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,mFAWC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAzkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB;2BAnBf,sCAAsC"}
+{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yFAHW,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB;2BAnBf,sCAAsC"}

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -553,17 +553,14 @@ export class DynamicActorSystem extends AbstractContextSystem {
         return description;
     }
 
-    async startup(entityManager, readyCallback, errorCallback) {
+    async startup(entityManager) {
         const staticKnowledge = this.engine.staticKnowledge;
 
-
         await staticKnowledge.promise();
 
         this.database = staticKnowledge.getTable('dynamic-actions');
 
         this.evaluator = this.database.buildEvaluator();
-
-        super.startup(entityManager, readyCallback, errorCallback);
     }
 
     /**

package/src/engine/ecs/fow/FogOfWarSystem.d.ts

@@ -26,12 +26,10 @@ export class FogOfWarSystem extends System<any, any, any, any, any> {
     /**
      *
      * @param {EntityManager} entityManager
-     * @param readyCallback
-     * @param errorCallback
      */
-    startup(entityManager: EntityManager, readyCallback: any, errorCallback: any): void;
+    startup(entityManager: EntityManager): Promise<void>;
     renderTarget: any;
-    shutdown(entityManager: any, readyCallback: any, errorCallback: any): void;
+    shutdown(entityManager: any): Promise<void>;
     /**
      *
      * @param {FogOfWar} fow

package/src/engine/ecs/fow/FogOfWarSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarSystem.js"],"names":[],"mappings":"AAwBA;IACI;;;OAGG;IACH,sCA0BC;IAvBG;;;OAGG;IACH,yBAAwB;IAExB,mDAAuC;IAEvC,gEAEC;IAED,mCAAoD;IAIpD;;;OAGG;IACH,eAFU,aAAa,CAEE;IAEzB,uBAAuB;IAG3B;;;OAGG;IACH,yBAFa,gBAAgB,CAuE5B;IAED;;;;;OAKG;IACH,oFA+EC;IA/DG,kBAAgC;IAiEpC,2EAIC;IAED;;;;;OAKG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAmBhB;IAED,kDAQC;IAED,6BAUC;CACJ;uBA/QsB,cAAc;oBAEjB,2BAA2B;yBADtB,eAAe;4CAiBI,oDAAoD;iCAd/D,sDAAsD;8BAQzD,0CAA0C"}
+{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarSystem.js"],"names":[],"mappings":"AAwBA;IACI;;;OAGG;IACH,sCA0BC;IAvBG;;;OAGG;IACH,yBAAwB;IAExB,mDAAuC;IAEvC,gEAEC;IAED,mCAAoD;IAIpD;;;OAGG;IACH,eAFU,aAAa,CAEE;IAEzB,uBAAuB;IAG3B;;;OAGG;IACH,yBAFa,gBAAgB,CAuE5B;IAED;;;OAGG;IACH,qDA6EC;IA7DG,kBAAgC;IA+DpC,4CAEC;IAED;;;;;OAKG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAmBhB;IAED,kDAQC;IAED,6BAUC;CACJ;uBAzPsB,cAAc;oBACjB,2BAA2B;yBACtB,eAAe;4CAdI,oDAAoD;iCAS/D,sDAAsD;8BAPzD,0CAA0C"}

package/src/engine/ecs/fow/FogOfWarSystem.js

@@ -1,23 +1,23 @@
-import { System } from "../System.js";
-import { FogOfWar } from "./FogOfWar.js";
-import Terrain from "../terrain/ecs/Terrain.js";
 import { Frustum } from "three";
-import { VisibilityFilter } from "../../graphics/render/visibility/VisibilityFilter.js";
-import Vector4 from "../../../core/geom/Vector4.js";
-import { Camera } from "../../graphics/ecs/camera/Camera.js";
-import WaterSystem from "../../graphics/ecs/water/WaterSystem.js";
 import Vector3 from "../../../core/geom/Vector3.js";
-import { BlendingType } from "../../graphics/texture/sampler/BlendingType.js";
-import { FogOfWarRenderer } from "./shader/FogOfWarRenderer.js";
-import { StandardFrameBuffers } from "../../graphics/StandardFrameBuffers.js";
-import { CompositLayer } from "../../graphics/composit/CompositLayer.js";
+import Vector4 from "../../../core/geom/Vector4.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { CompositingStages } from "../../graphics/composit/CompositingStages.js";
+import { CompositLayer } from "../../graphics/composit/CompositLayer.js";
+import { Camera } from "../../graphics/ecs/camera/Camera.js";
 import {
     compute_perspective_camera_focal_position
 } from "../../graphics/ecs/camera/compute_perspective_camera_focal_position.js";
 import { frustum_from_camera } from "../../graphics/ecs/camera/frustum_from_camera.js";
-import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
-import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+import WaterSystem from "../../graphics/ecs/water/WaterSystem.js";
+import { VisibilityFilter } from "../../graphics/render/visibility/VisibilityFilter.js";
+import { StandardFrameBuffers } from "../../graphics/StandardFrameBuffers.js";
+import { BlendingType } from "../../graphics/texture/sampler/BlendingType.js";
+import { System } from "../System.js";
+import Terrain from "../terrain/ecs/Terrain.js";
+import { FogOfWar } from "./FogOfWar.js";
+import { FogOfWarRenderer } from "./shader/FogOfWarRenderer.js";
 
 
 const frustum = new Frustum();
@@ -133,10 +133,8 @@ export class FogOfWarSystem extends System {
     /**
      *
      * @param {EntityManager} entityManager
-     * @param readyCallback
-     * @param errorCallback
      */
-    startup(entityManager, readyCallback, errorCallback) {
+    async startup(entityManager) {
         this.entityManager = entityManager;
 
         const graphics = this.graphics;
@@ -213,14 +211,10 @@ export class FogOfWarSystem extends System {
             }
         });
 
-
-        readyCallback();
     }
 
-    shutdown(entityManager, readyCallback, errorCallback) {
+    async shutdown(entityManager) {
         this.graphics.layerComposer.remove(this.compositLayer);
-
-        super.shutdown(entityManager, readyCallback, errorCallback);
     }
 
     /**

package/src/engine/ecs/gui/GUIElementSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAgCA,gFAAiF;;AAEjF;IAyBI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IA9DD,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IA2BR,iCAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,mDAQC;IAED,kDAQC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAiDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAiBpB;CACJ;uBA1RsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}
+{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAgCA,gFAAiF;;AAEjF;IAyBI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IA9DD,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IA2BR,iCAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAiDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAiBpB;CACJ;uBA/QsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}

package/src/engine/ecs/gui/GUIElementSystem.js

@@ -65,11 +65,11 @@ class GUIElementSystem extends System {
      */
     constructor(containerView, engine) {
         if (containerView === undefined) {
-            throw  new Error(`mandatory parameter containerView is undefined`);
+            throw new Error(`mandatory parameter containerView is undefined`);
         }
 
         if (containerView === null) {
-            throw  new Error(`mandatory parameter containerView is null`);
+            throw new Error(`mandatory parameter containerView is null`);
         }
 
         if (!(containerView instanceof View)) {
@@ -98,24 +98,13 @@ class GUIElementSystem extends System {
 
     }
 
-    shutdown(em, cmOk, cbFailure) {
-        try {
-            this.containerView.removeChild(this.view);
-            cmOk();
-        } catch (e) {
-            cbFailure(e);
-        }
-
+    async startup(em) {
+        this.entityManager = em;
+        this.containerView.addChild(this.view);
     }
 
-    startup(em, cbOK, cbFailure) {
-        this.entityManager = em;
-        try {
-            this.containerView.addChild(this.view);
-            cbOK();
-        } catch (e) {
-            cbFailure(e);
-        }
+    async shutdown(em) {
+        this.containerView.removeChild(this.view);
     }
 
     /**

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadsUpDisplaySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js"],"names":[],"mappings":";AAeA;;;;;GAKG;AACH;IASI;;;OAGG;IACH,4BAFW,cAAc,EAqBxB;IA/BD,wCAAgC;IAGhC,2HAGE;IAaE,yBAA8B;IAM9B;;;;OAIG;IACH,+BAAiD;IAGrD,mDAQC;IAED,kDAMC;IAED;;;;;;;OAOG;IACH,sCAwGC;IAED,6BAsBC;CACJ;uBA7MsB,iBAAiB;2BAIb,qBAAqB;uBAFzB,kBAAkB;4CALG,uDAAuD;6BAMtE,iCAAiC;+BAL/B,qCAAqC"}
+{"version":3,"file":"HeadsUpDisplaySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js"],"names":[],"mappings":";AAeA;;;;;GAKG;AACH;IASI;;;OAGG;IACH,4BAFW,cAAc,EAqBxB;IA/BD,wCAAgC;IAGhC,2HAGE;IAaE,yBAA8B;IAM9B;;;;OAIG;IACH,+BAAiD;IAGrD,iCAGC;IAED,gCAIC;IAED;;;;;;;OAOG;IACH,sCAwGC;IAED,6BAsBC;CACJ;uBAtMsB,iBAAiB;2BAIb,qBAAqB;uBAFzB,kBAAkB;4CALG,uDAAuD;6BAMtE,iCAAiC;+BAL/B,qCAAqC"}