@woosh/meep-engine 2.47.23 → 2.47.26

package/src/engine/ecs/EntityManager.js

@@ -8,6 +8,7 @@ import { computeSystemName, System } from "./System.js";
 import { assert } from "../../core/assert.js";
 import { EntityObserver } from "./EntityObserver.js";
 import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
+import { noop } from "../../core/function/Functions.js";
 
 /**
  *
@@ -39,26 +40,25 @@ export const EntityManagerState = {
  */
 function EntityManager() {
     /**
-     *
-     * @type {Array.<System>}
+     * @readonly
+     * @type {System[]}
      */
     this.systems = [];
 
     /**
-     *
-     * @type {Array<EntityObserver>}
+     * @readonly
+     * @type {EntityObserver[]}
      */
     this.systemObservers = [];
 
+    /**
+     * @readonly
+     */
     this.on = {
         systemStarted: new Signal(),
         systemStopped: new Signal(),
         systemAdded: new Signal(),
         systemRemoved: new Signal(),
-        /**
-         * @deprecated
-         */
-        reset: new Signal()
     };
 
     /**
@@ -67,6 +67,19 @@ function EntityManager() {
      */
     this.state = EntityManagerState.Initial;
 
+    /**
+     * @private
+     * @readonly
+     * @type {Map<System, number>}
+     */
+    this.systemAccumulatedFixedStepTime = new Map();
+
+    /**
+     * In seconds
+     * @type {number}
+     */
+    this.fixedUpdateStepSize = 0.015;
+
     /**
      *
      * @type {EntityComponentDataset}
@@ -141,170 +154,6 @@ EntityManager.prototype.attachDataSet = function (dataset) {
     });
 };
 
-/**
- * @deprecated
- * @returns {number}
- */
-EntityManager.prototype.createEntity = function () {
-    console.warn("EntityManager.createEntity is deprecated");
-
-    return this.dataset.createEntity();
-};
-
-/**
- * @deprecated
- * @param id
- */
-EntityManager.prototype.createEntitySpecific = function (id) {
-    console.warn("EntityManager.createEntitySpecific is deprecated");
-    this.dataset.createEntitySpecific(id);
-};
-
-
-/**
- * @deprecated
- * Remove association of specified component type from entity
- * @param {Number} entityId
- * @param {Number} componentType
- */
-EntityManager.prototype.removeComponentFromEntity = function (entityId, componentType) {
-    console.warn("EntityManager.removeComponentFromEntity is deprecated");
-
-    this.dataset.removeComponentFromEntityByIndex(entityId, componentType);
-};
-
-/**
- * @deprecated use dataset directly
- * Retrieves component instance associated with entity
- * @template T
- * @param {Number} entityId
- * @param {class.<T>} componentClass
- * @returns {T|null}
- * @nosideeffects
- */
-EntityManager.prototype.getComponent = function (entityId, componentClass) {
-    return this.dataset.getComponent(entityId, componentClass);
-};
-
-/**
- *
- * @param {number} entityIndex
- * @returns {boolean}
- */
-EntityManager.prototype.entityExists = function (entityIndex) {
-    if (this.dataset === null) {
-        //no dataset - no entities
-        return false;
-    }
-    return this.dataset.entityExists(entityIndex);
-};
-
-/**
- * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
- * @param {Number} entityId
- * @param {Class} componentClass
- * @param {function} callback
- * @param {*} [thisArg]
- */
-EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback, thisArg) {
-    const self = this;
-    const component = this.getComponent(entityId, componentClass);
-
-    function handler(options) {
-        if (options.klass === componentClass) {
-            self.removeEntityEventListener(entityId, EventType.ComponentAdded, handler);
-            callback.call(thisArg, options.instance);
-        }
-    }
-
-    if (component === void 0 || component === null) {
-        this.addEntityEventListener(entityId, EventType.ComponentAdded, handler);
-    } else {
-        callback.call(thisArg, component);
-    }
-};
-
-/**
- * @deprecated Use {@link EntityManager#dataset} direction
- * @param entity
- * @returns {Array}
- */
-EntityManager.prototype.getComponents = function (entity) {
-    console.warn("EntityManager.getComponents is deprecated");
-
-    return this.dataset.getAllComponents(entity);
-};
-
-/**
- * @deprecated
- * Retrieves component instance associated with entity
- * @param {Number} entityId
- * @param {Number} componentType
- * @returns {*|undefined} component of specified type or undefined if it was not found
- */
-EntityManager.prototype.getComponentByType = function (entityId, componentType) {
-    console.warn("EntityManager.getComponentByType is deprecated");
-    return this.dataset.getComponentByIndex(entityId, componentType);
-};
-
-/**
- * @deprecated
- * does traversal on a subset of entities which have specified components.
- * @example traverseEntities([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
- * @param {Array.<class>} classes
- * @param {Function} callback
- * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
- */
-EntityManager.prototype.traverseEntities = function (classes, callback, thisArg) {
-    if (this.dataset === null) {
-        //no data to traverse
-        return;
-    }
-    this.dataset.traverseEntities(classes, callback, thisArg);
-};
-
-/**
- * @deprecated
- * @param entity
- * @param eventName
- * @param listener
- */
-EntityManager.prototype.addEntityEventListener = function (entity, eventName, listener) {
-    this.dataset.addEntityEventListener(entity, eventName, listener);
-};
-
-/**
- * @deprecated
- * @param {number} entity
- * @param {string} eventName
- * @param {function} listener
- */
-EntityManager.prototype.removeEntityEventListener = function (entity, eventName, listener) {
-    this.dataset.removeEntityEventListener(entity, eventName, listener);
-};
-
-/**
- * @deprecated use dataset directly instead
- * @param entity
- * @param eventName
- * @param event
- */
-EntityManager.prototype.sendEvent = function (entity, eventName, event) {
-    this.dataset.sendEvent(entity, eventName, event);
-};
-
-/**
- * @deprecated
- * @param {function} klazz
- * @param {function(component: *, entity: number):boolean} callback
- * @param {*} [thisArg]
- * @deprecated
- */
-EntityManager.prototype.traverseComponents = function (klazz, callback, thisArg) {
-    if (this.dataset !== null) {
-        this.dataset.traverseComponents(klazz, callback, thisArg);
-    }
-};
 
 /**
  * @template T
@@ -336,33 +185,6 @@ EntityManager.prototype.getSystem = function (systemClass) {
     return null;
 };
 
-/**
- * @deprecated Use {@link #getSystem} instead
- * @template T,C
- * @param {C} klazz
- * @returns {System|T}
- */
-EntityManager.prototype.getOwnerSystemByComponentClass = function (klazz) {
-    const index = this.getOwnerSystemIdByComponentClass(klazz);
-    return this.systems[index];
-};
-
-/**
- * @deprecated
- * @param {function} clazz
- * @returns {number} value >= 0, representing system Id, or -1 if system was not found
- */
-EntityManager.prototype.getOwnerSystemIdByComponentClass = function (clazz) {
-    const systems = this.systems;
-    let i = 0;
-    const l = systems.length;
-    for (; i < l; i++) {
-        if (systems[i].componentClass === clazz) {
-            return i;
-        }
-    }
-    return -1;
-};
 
 /**
  * @template T
@@ -384,19 +206,6 @@ EntityManager.prototype.getComponentClassByName = function (className) {
     return null;
 };
 
-/**
- *
- * @param {System} system
- * @param {number} timeDelta
- */
-function tryUpdateSystem(system, timeDelta) {
-    try {
-        system.update(timeDelta);
-    } catch (e) {
-        console.error(`Failed to update system '${computeSystemName(system)}': `, e);
-    }
-}
-
 /**
  * Advance simulation forward by a specified amount of time
  * @param {number} timeDelta in seconds, real number
@@ -406,12 +215,51 @@ EntityManager.prototype.simulate = function (timeDelta) {
     assert.notNaN(timeDelta, 'timeDelta');
     assert.greaterThanOrEqual(timeDelta, 0, 'timeDelta must be >= 0');
 
+    /**
+     *
+     * @type {System[]}
+     */
     const systems = this.systems;
-    let i = 0;
-    const l = systems.length;
-    for (; i < l; i++) {
+
+    const system_count = systems.length;
+
+    const fixed_step = this.fixedUpdateStepSize;
+    const accumulatedTime = this.systemAccumulatedFixedStepTime;
+
+    for (let i = 0; i < system_count; i++) {
+
         const system = systems[i];
-        tryUpdateSystem(system, timeDelta);
+
+        if (system.fixedUpdate !== noop) {
+            let accumulated_time = accumulatedTime.get(system) + timeDelta;
+
+
+            while (accumulated_time > fixed_step) {
+
+                try {
+                    system.fixedUpdate(fixed_step)
+                } catch (e) {
+                    console.error(`Failed during fixedUpdate of system '${computeSystemName(system)}': `, e);
+                }
+
+                accumulated_time -= fixed_step;
+            }
+
+            // record whatever remains
+            accumulatedTime.set(system, accumulated_time);
+
+        }
+
+        if (system.update !== noop) {
+
+            try {
+                system.update(timeDelta);
+            } catch (e) {
+                console.error(`Failed during update of system '${computeSystemName(system)}': `, e);
+            }
+
+        }
+
     }
 };
 
@@ -534,6 +382,8 @@ EntityManager.prototype.addSystem = async function (system) {
         this.dataset.addObserver(linkObserver);
     }
 
+    this.systemAccumulatedFixedStepTime.set(system, 0);
+
     this.on.systemAdded.send1(system);
 
     await startup_promise;
@@ -577,6 +427,8 @@ EntityManager.prototype.removeSystem = async function (system) {
         });
     });
 
+    this.systemAccumulatedFixedStepTime.delete(system);
+
     this.on.systemRemoved.send1(system);
 };
 
@@ -875,17 +727,208 @@ EntityManager.prototype.shutdown = function (readyCallback, errorCallback) {
     });
 };
 
+
+/**
+ * @deprecated
+ * @returns {number}
+ */
+EntityManager.prototype.createEntity = function () {
+    console.warn("EntityManager.createEntity is deprecated");
+
+    return this.dataset.createEntity();
+};
+
+/**
+ * @deprecated
+ * @param id
+ */
+EntityManager.prototype.createEntitySpecific = function (id) {
+    console.warn("EntityManager.createEntitySpecific is deprecated");
+    this.dataset.createEntitySpecific(id);
+};
+
+
+/**
+ * @deprecated
+ * Remove association of specified component type from entity
+ * @param {Number} entityId
+ * @param {Number} componentType
+ */
+EntityManager.prototype.removeComponentFromEntity = function (entityId, componentType) {
+    console.warn("EntityManager.removeComponentFromEntity is deprecated");
+
+    this.dataset.removeComponentFromEntityByIndex(entityId, componentType);
+};
+
+/**
+ * @deprecated use dataset directly
+ * Retrieves component instance associated with entity
+ * @template T
+ * @param {Number} entityId
+ * @param {class.<T>} componentClass
+ * @returns {T|null}
+ * @nosideeffects
+ */
+EntityManager.prototype.getComponent = function (entityId, componentClass) {
+    console.warn("EntityManager.getComponent is deprecated");
+
+    return this.dataset.getComponent(entityId, componentClass);
+};
+
+/**
+ * @deprecated use {@link EntityComponentDataset.entityExists} instead
+ * @param {number} entityIndex
+ * @returns {boolean}
+ */
+EntityManager.prototype.entityExists = function (entityIndex) {
+    console.warn("EntityManager.entityExists is deprecated");
+    if (this.dataset === null) {
+        //no dataset - no entities
+        return false;
+    }
+    return this.dataset.entityExists(entityIndex);
+};
+
+
+/**
+ * @deprecated Use {@link EntityManager#dataset} direction
+ * @param entity
+ * @returns {Array}
+ */
+EntityManager.prototype.getComponents = function (entity) {
+    console.warn("EntityManager.getComponents is deprecated");
+
+    return this.dataset.getAllComponents(entity);
+};
+
 /**
  * @deprecated
+ * Retrieves component instance associated with entity
+ * @param {Number} entityId
+ * @param {Number} componentType
+ * @returns {*|undefined} component of specified type or undefined if it was not found
  */
-EntityManager.prototype.reset = function () {
-    console.warn("EntityManager.reset is deprecated and should no longer be used, reset dataset instead");
+EntityManager.prototype.getComponentByType = function (entityId, componentType) {
+    console.warn("EntityManager.getComponentByType is deprecated");
+    return this.dataset.getComponentByIndex(entityId, componentType);
+};
 
-    this.dataset.clear();
+/**
+ * @deprecated
+ * does traversal on a subset of entities which have specified components.
+ * @example traverseEntities([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
+ * @param {Array.<class>} classes
+ * @param {Function} callback
+ * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
+ */
+EntityManager.prototype.traverseEntities = function (classes, callback, thisArg) {
+    console.warn("EntityManager.traverseEntities is deprecated");
+
+    if (this.dataset === null) {
+        //no data to traverse
+        return;
+    }
+    this.dataset.traverseEntities(classes, callback, thisArg);
+};
+
+/**
+ * @deprecated
+ * @param entity
+ * @param eventName
+ * @param listener
+ */
+EntityManager.prototype.addEntityEventListener = function (entity, eventName, listener) {
+    console.warn("EntityManager.addEntityEventListener is deprecated");
+    this.dataset.addEntityEventListener(entity, eventName, listener);
+};
+
+/**
+ * @deprecated
+ * @param {number} entity
+ * @param {string} eventName
+ * @param {function} listener
+ */
+EntityManager.prototype.removeEntityEventListener = function (entity, eventName, listener) {
+    console.warn("EntityManager.removeEntityEventListener is deprecated");
+    this.dataset.removeEntityEventListener(entity, eventName, listener);
+};
+
+/**
+ * @deprecated use dataset directly instead
+ * @param entity
+ * @param eventName
+ * @param event
+ */
+EntityManager.prototype.sendEvent = function (entity, eventName, event) {
+    console.warn("EntityManager.sendEvent is deprecated");
+    this.dataset.sendEvent(entity, eventName, event);
+};
+
+/**
+ * @deprecated
+ * @param {function} klazz
+ * @param {function(component: *, entity: number):boolean} callback
+ * @param {*} [thisArg]
+ * @deprecated
+ */
+EntityManager.prototype.traverseComponents = function (klazz, callback, thisArg) {
+    console.warn("EntityManager.traverseComponents is deprecated");
+    if (this.dataset !== null) {
+        this.dataset.traverseComponents(klazz, callback, thisArg);
+    }
+};
+
+/**
+ * @deprecated Use {@link #getSystem} instead
+ * @template T,C
+ * @param {C} klazz
+ * @returns {System|T}
+ */
+EntityManager.prototype.getOwnerSystemByComponentClass = function (klazz) {
+
+    console.warn("EntityManager.getOwnerSystemByComponentClass is deprecated, use .getSystem instead");
+    const index = this.getOwnerSystemIdByComponentClass(klazz);
+    return this.systems[index];
+};
+
+/**
+ * @deprecated
+ * @param {function} clazz
+ * @returns {number} value >= 0, representing system Id, or -1 if system was not found
+ */
+EntityManager.prototype.getOwnerSystemIdByComponentClass = function (clazz) {
+    console.warn("EntityManager.getOwnerSystemIdByComponentClass is deprecated, use .getSystem instead");
+
+    const systems = this.systems;
+    let i = 0;
+    const l = systems.length;
+    for (; i < l; i++) {
+        if (systems[i].componentClass === clazz) {
+            return i;
+        }
+    }
+    return -1;
+};
+
+
+/**
+ * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
+ * @param {Number} entityId
+ * @param {Class} componentClass
+ * @param {function} callback
+ * @param {*} [thisArg]
+ */
+EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback, thisArg) {
+    console.warn("EntityManager.getComponentAsync is deprecated");
+
+    const dataset = this.dataset;
+
+    if (dataset === undefined) {
+        throw new Error('No dataset attached');
+    }
 
-    this.on.reset.send0();
+    dataset.getComponentAsync(entityId, componentClass, callback, thisArg);
 
-    console.log("Entity Manager completed reset");
 };
 
 export {

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

@@ -27,4 +27,6 @@ export class System<A, B = any, C = any, D = any, E = any> {
     unlink(a: A, b: B, c: C, d: D, e: E, entity: number): void
 
     update(time_delta: number): void
+
+    fixedUpdate(time_delta: number): void
 }

package/src/engine/ecs/System.js

@@ -5,39 +5,39 @@
 
 import { array_copy_unique } from "../../core/collection/array/array_copy_unique.js";
 import ObservedValue from "../../core/model/ObservedValue.js";
+import { noop } from "../../core/function/Functions.js";
 
 /**
  *
  * @template C
  */
 class System {
-    constructor() {
 
-        /**
-         *
-         * @type {EntityManager}
-         */
-        this.entityManager = null;
+    /**
+     * @protected
+     * @type {EntityManager}
+     */
+    entityManager = null;
 
-        /**
-         *
-         * @type {ObservedValue.<System.State>}
-         */
-        this.state = new ObservedValue(System.State.INITIAL);
+    /**
+     * @readonly
+     * @type {ObservedValue.<System.State>}
+     */
+    state = new ObservedValue(System.State.INITIAL);
 
-        /**
-         * Other components which have to be present before the system links component
-         * @type {Array}
-         */
-        this.dependencies = [];
+    /**
+     * Other components which have to be present before the system links component
+     * @type {Array}
+     */
+    dependencies = [];
+
+    /**
+     * Component types that are used internally by the system
+     * Declaring this helps EntityManager to ensure that all relevant component types are properly registered for the system
+     * @type {Array}
+     */
+    components_used = [];
 
-        /**
-         * Component types that are used internally by the system
-         * Declaring this helps EntityManager to ensure that all relevant component types are properly registered for the system
-         * @type {Array}
-         */
-        this.components_used = [];
-    }
 
     /**
      * @returns {[]}
@@ -68,15 +68,22 @@ class System {
 
     }
 
-    /**
-     *
-     * @param {number} timeDelta Time in seconds
-     */
-    update(timeDelta) {
-
-    }
 }
 
+/**
+ * Fixed update function, every step happens with the same exact time increment
+ * useful for systems that must have a fixed time step to be predictable and stable, such as physics
+ * @param {number} timeDelta in seconds
+ */
+System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
+
+
+/**
+ * This update is generally synchronized with the render loop
+ * @param {number} timeDelta Time 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

package/src/engine/ecs/gui/menu/radial/RadialContextMenu.js

@@ -196,10 +196,6 @@ export function makeMenu({
 
         selectionMade = true;
 
-        if (event !== undefined && event !== null) {
-            event.stopPropagation();
-        }
-
         try {
             mainView.runSelected();
         } catch (e) {