@woosh/meep-engine 2.60.1 → 2.61.0

package/src/engine/ecs/EntityManager.js

@@ -2,22 +2,23 @@
  * Created by Alex on 01/04/2014.
  */
 
-import { array_copy_unique } from "../../core/collection/array/array_copy_unique.js";
+import {assert} from "../../core/assert.js";
+import {array_copy_unique} from "../../core/collection/array/array_copy_unique.js";
 import Signal from "../../core/events/signal/Signal.js";
-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";
-import { ResourceAccessKind } from "../../core/model/ResourceAccessKind.js";
-import { computeSystemComponentDependencyGraph } from "./system/computeSystemComponentDependencyGraph.js";
+import {IllegalStateException} from "../../core/fsm/exceptions/IllegalStateException.js";
+import {noop} from "../../core/function/Functions.js";
+import {ResourceAccessKind} from "../../core/model/ResourceAccessKind.js";
+import {EntityObserver} from "./EntityObserver.js";
+import {computeSystemName, System, SystemState} from "./System.js";
+import {computeSystemComponentDependencyGraph} from "./system/computeSystemComponentDependencyGraph.js";
+import {validateSystem} from "./validateSystem.js";
 
 /**
  *
  * @enum {string}
  * @readonly
  */
-const EventType = {
+export const EventType = {
     EntityRemoved: "entityRemoved",
     ComponentAdded: "componentAdded",
     ComponentRemoved: "componentRemoved"
@@ -36,33 +37,30 @@ export const EntityManagerState = {
     Stopped: 5
 };
 
-/**
- *
- * @constructor
- */
-function EntityManager() {
+export class EntityManager {
+
     /**
      * @readonly
      * @type {System[]}
      */
-    this.systems = [];
+    systems = [];
 
     /**
      * @readonly
      * @type {System[]}
      */
-    this.systemsExecutionOrder = [];
+    systemsExecutionOrder = [];
 
     /**
      * @readonly
      * @type {EntityObserver[]}
      */
-    this.systemObservers = [];
+    systemObservers = [];
 
     /**
      * @readonly
      */
-    this.on = {
+    on = {
         systemStarted: new Signal(),
         systemStopped: new Signal(),
         systemAdded: new Signal(),
@@ -73,819 +71,724 @@ function EntityManager() {
      *
      * @type {EntityManagerState}
      */
-    this.state = EntityManagerState.Initial;
+    state = EntityManagerState.Initial;
 
     /**
      * @private
      * @readonly
      * @type {Map<System, number>}
      */
-    this.systemAccumulatedFixedStepTime = new Map();
+    systemAccumulatedFixedStepTime = new Map();
 
     /**
+     * Value used to execute {@link System#fixedUpdate}
      * In seconds
      * @type {number}
      */
-    this.fixedUpdateStepSize = 0.015;
+    fixedUpdateStepSize = 0.015;
 
     /**
      *
      * @type {EntityComponentDataset}
      */
-    this.dataset = null;
+    dataset = null;
 
     /**
      *
      * @type {boolean}
      * @private
      */
-    this.__execution_order_needs_update = true;
-}
-
-/**
- * Rebuild execution order
- */
-EntityManager.prototype.updateExecutionOrder = function () {
-    // console.time('updateExecutionOrder')
-
-    const order = this.systemsExecutionOrder;
-
-    order.splice(0, order.length);
-
-    const systems = this.systems;
-    const system_count = systems.length;
-
-    let executable_system_count = 0;
-
-    for (let i = 0; i < system_count; i++) {
-        const system = systems[i];
-
-        if (system.update === noop && system.fixedUpdate === noop) {
-            // not a simulation system
-            continue;
-        }
-
-        order[executable_system_count++] = system;
-    }
-
-    // build dependency graphs amongst components
-    const dependency_graph = computeSystemComponentDependencyGraph(executable_system_count, order);
-
+    __execution_order_needs_update = true;
 
     /**
-     *
-     * @param {System} system
-     * @returns {number} higher values means it should be scheduled before others
+     * Rebuild execution order
+     * @private
      */
-    function scoreSystem(system) {
-        let result = 0;
-
-        const components = system.referenced_components;
-        const component_count = components.length;
+    updateExecutionOrder() {
+        // console.time('updateExecutionOrder')
 
-        for (let i = 0; i < component_count; i++) {
-            const component = components[i];
+        const order = this.systemsExecutionOrder;
 
-            result += 0.0001;
+        order.splice(0, order.length);
 
+        const systems = this.systems;
+        const system_count = systems.length;
 
-            // count number of incoming edges
-            const attached_edge_count = dependency_graph.getNodeContainer(component).getIncomingEdgeCount();
+        let executable_system_count = 0;
 
-            const access = system.getAccessForComponent(component);
+        for (let i = 0; i < system_count; i++) {
+            const system = systems[i];
 
-            if ((access & ResourceAccessKind.Create) !== 0) {
-                result += attached_edge_count * 4
-            } else if ((access & ResourceAccessKind.Write) !== 0) {
-                result += attached_edge_count * 2
-            } else {
-                result += attached_edge_count;
+            if (system.update === noop && system.fixedUpdate === noop) {
+                // not a simulation system
+                continue;
             }
 
+            order[executable_system_count++] = system;
         }
 
-        return result;
-    }
+        // build dependency graphs amongst components
+        const dependency_graph = computeSystemComponentDependencyGraph(executable_system_count, order);
 
-    // pre-score systems for faster sorting
-    const scores = new Map();
 
-    for (let i = 0; i < executable_system_count; i++) {
-        const system = order[i];
+        /**
+         *
+         * @param {System} system
+         * @returns {number} higher values means it should be scheduled before others
+         */
+        function scoreSystem(system) {
+            let result = 0;
 
-        scores.set(system, scoreSystem(system));
-    }
+            const components = system.referenced_components;
+            const component_count = components.length;
 
-    order.sort((a, b) => {
-        return scores.get(b) - scores.get(a);
-    });
+            for (let i = 0; i < component_count; i++) {
+                const component = components[i];
 
-    // clear update flag
-    this.__execution_order_needs_update = false;
-    // console.timeEnd('updateExecutionOrder')
-};
+                result += 0.0001;
 
-EntityManager.prototype.detachDataSet = function () {
-    const dataset = this.dataset;
 
-    if (dataset === null) {
-        //no dataset attached
-        return;
-    }
+                // count number of incoming edges
+                const attached_edge_count = dependency_graph.getNodeContainer(component).getIncomingEdgeCount();
 
-    //remove system observers
-    this.systemObservers.forEach(function (observer) {
-        dataset.removeObserver(observer, true);
-    });
+                const access = system.getAccessForComponent(component);
 
-    this.dataset = null;
-};
+                if ((access & ResourceAccessKind.Create) !== 0) {
+                    result += attached_edge_count * 4
+                } else if ((access & ResourceAccessKind.Write) !== 0) {
+                    result += attached_edge_count * 2
+                } else {
+                    result += attached_edge_count;
+                }
 
-/**
- * Get list of all components referenced by active systems
- * @returns {Class[]}
- */
-EntityManager.prototype.getComponentTypeMap = function () {
-    const componentTypes = [];
+            }
 
-    const systems = this.systems;
+            return result;
+        }
 
-    const systemCount = systems.length;
+        // pre-score systems for faster sorting
+        const scores = new Map();
 
-    for (let i = 0; i < systemCount; i++) {
-        /**
-         *
-         * @type {System}
-         */
-        const system = systems[i];
+        for (let i = 0; i < executable_system_count; i++) {
+            const system = order[i];
 
+            scores.set(system, scoreSystem(system));
+        }
 
-        const referencedComponents = system.referenced_components;
+        order.sort((a, b) => {
+            return scores.get(b) - scores.get(a);
+        });
 
-        array_copy_unique(referencedComponents, 0, componentTypes, componentTypes.length, referencedComponents.length);
+        // clear update flag
+        this.__execution_order_needs_update = false;
+        // console.timeEnd('updateExecutionOrder')
     }
 
-    return componentTypes;
-};
-
-/**
- *
- * @param {EntityComponentDataset} dataset
- * @throws {Error} if another dataset is attached
- * @throws {Error} if dataset is incompatible with current system set
- */
-EntityManager.prototype.attachDataSet = function (dataset) {
-    //check if another dataset is attached
-    if (this.dataset !== null) {
+    detachDataSet() {
+        const dataset = this.dataset;
 
-        if (this.dataset === dataset) {
-            // special case, we already have this dataset attached. Nothing to more to do
+        if (dataset === null) {
+            //no dataset attached
             return;
         }
 
-        throw new Error("Illegal status, another dataset is currently attached");
-    }
-
-    const localComponentTypeMap = this.getComponentTypeMap();
-
-    //ensure compatibility with system-used component map
-    dataset.registerManyComponentTypes(localComponentTypeMap);
-
-    this.dataset = dataset;
-
-    this.systemObservers.forEach(function (observer) {
-        dataset.addObserver(observer, true);
-    });
-};
-
+        //remove system observers
+        this.systemObservers.forEach(function (observer) {
+            dataset.removeObserver(observer, true);
+        });
 
-/**
- * @template T
- * @param {Class<T>} systemClass
- * @returns {boolean}
- */
-EntityManager.prototype.hasSystem = function (systemClass) {
-    return this.getSystem(systemClass) !== null;
-};
+        this.dataset = null;
+    }
 
-/**
- * @template T
- * @param {Class<T>} systemClass
- * @returns {T|null}
- */
-EntityManager.prototype.getSystem = function (systemClass) {
-    const systems = this.systems;
-    const numSystems = systems.length;
+    /**
+     * Get list of all components referenced by active systems
+     * @returns {Class[]}
+     */
+    getComponentTypeMap() {
+        const componentTypes = [];
 
-    for (let i = 0; i < numSystems; i++) {
-        const system = systems[i];
+        const systems = this.systems;
 
-        if (system instanceof systemClass) {
-            return system;
-        }
-    }
+        const systemCount = systems.length;
 
-    //not found
-    return null;
-};
+        for (let i = 0; i < systemCount; i++) {
+            /**
+             *
+             * @type {System}
+             */
+            const system = systems[i];
 
 
-/**
- * @deprecated use {@link EntityComponentDataset.getComponentClassByName} instead
- * @template T
- * @param {string} className
- * @returns {null|Class<T>}
- */
-EntityManager.prototype.getComponentClassByName = function (className) {
-    const componentTypes = this.getComponentTypeMap();
+            const referencedComponents = system.referenced_components;
 
-    let i = 0;
-    const l = componentTypes.length;
-    for (; i < l; i++) {
-        const componentClass = componentTypes[i];
-        const name = componentClass.typeName;
-        if (name === className) {
-            return componentClass;
+            array_copy_unique(referencedComponents, 0, componentTypes, componentTypes.length, referencedComponents.length);
         }
-    }
-    return null;
-};
 
-/**
- * Advance simulation forward by a specified amount of time
- * @param {number} timeDelta in seconds, real number
- */
-EntityManager.prototype.simulate = function (timeDelta) {
-    assert.isNumber(timeDelta, 'timeDelta');
-    assert.notNaN(timeDelta, 'timeDelta');
-    assert.greaterThanOrEqual(timeDelta, 0, 'timeDelta must be >= 0');
-
-    if (this.__execution_order_needs_update) {
-        this.updateExecutionOrder();
+        return componentTypes;
     }
 
-
     /**
      *
-     * @type {System[]}
+     * @param {EntityComponentDataset} dataset
+     * @throws {Error} if another dataset is attached
+     * @throws {Error} if dataset is incompatible with current system set
      */
-    const systems = this.systems;
+    attachDataSet(dataset) {
+        //check if another dataset is attached
+        if (this.dataset !== null) {
 
-    const system_count = systems.length;
+            if (this.dataset === dataset) {
+                // special case, we already have this dataset attached. Nothing to more to do
+                return;
+            }
 
-    const fixed_step = this.fixedUpdateStepSize;
-    const accumulatedTime = this.systemAccumulatedFixedStepTime;
+            throw new Error("Illegal status, another dataset is currently attached");
+        }
 
-    assert.notNaN(fixed_step, 'fixed_step');
-    assert.greaterThan(fixed_step, 0, 'fixed_step must be greater than 0');
+        const localComponentTypeMap = this.getComponentTypeMap();
 
-    for (let i = 0; i < system_count; i++) {
+        //ensure compatibility with system-used component map
+        dataset.registerManyComponentTypes(localComponentTypeMap);
 
-        const system = systems[i];
+        this.dataset = dataset;
 
-        if (system.fixedUpdate !== noop) {
-            let accumulated_time = accumulatedTime.get(system) + timeDelta;
+        this.systemObservers.forEach(function (observer) {
+            dataset.addObserver(observer, true);
+        });
+    }
 
+    /**
+     * @template T
+     * @param {Class<T>} systemClass
+     * @returns {boolean}
+     */
+    hasSystem(systemClass) {
+        return this.getSystem(systemClass) !== null;
+    }
 
-            while (accumulated_time >= fixed_step) {
+    /**
+     * @template T
+     * @param {Class<T>} systemClass
+     * @returns {T|null}
+     */
+    getSystem(systemClass) {
+        const systems = this.systems;
+        const numSystems = systems.length;
 
-                try {
-                    system.fixedUpdate(fixed_step)
-                } catch (e) {
-                    console.error(`Failed during fixedUpdate of system '${computeSystemName(system)}': `, e);
-                }
+        for (let i = 0; i < numSystems; i++) {
+            const system = systems[i];
 
-                accumulated_time -= fixed_step;
+            if (system instanceof systemClass) {
+                return system;
             }
-
-            // record whatever remains
-            accumulatedTime.set(system, accumulated_time);
-
         }
 
-        if (system.update !== noop) {
+        //not found
+        return null;
+    }
 
-            try {
-                system.update(timeDelta);
-            } catch (e) {
-                console.error(`Failed during update of system '${computeSystemName(system)}': `, e);
+    /**
+     * @deprecated use {@link EntityComponentDataset.getComponentClassByName} instead
+     * @template T
+     * @param {string} className
+     * @returns {null|Class<T>}
+     */
+    getComponentClassByName(className) {
+        const componentTypes = this.getComponentTypeMap();
+
+        let i = 0;
+        const l = componentTypes.length;
+        for (; i < l; i++) {
+            const componentClass = componentTypes[i];
+            const name = componentClass.typeName;
+            if (name === className) {
+                return componentClass;
             }
-
         }
-
+        return null;
     }
-};
 
-/**
- *
- * @param {System} system
- * @throws if system fails validation
- */
-function validateSystem(system) {
-    if (system === undefined) {
-        throw new Error("System is undefined");
-    }
+    /**
+     * Advance simulation forward by a specified amount of time
+     * @param {number} timeDelta in seconds
+     */
+    simulate(timeDelta) {
+        assert.isNumber(timeDelta, 'timeDelta');
+        assert.notNaN(timeDelta, 'timeDelta');
+        assert.greaterThanOrEqual(timeDelta, 0, 'timeDelta must be >= 0');
 
-    if (system === null) {
-        throw  new Error("System is null");
-    }
+        if (this.__execution_order_needs_update) {
+            this.updateExecutionOrder();
+        }
 
-    if (!(system instanceof System)) {
-        throw new TypeError("System does not inherit from \"System\" class");
-    }
 
-    if (typeof system.add === "function") {
-        throw new Error(`uses deprecated 'add' method, should use 'link' instead`);
-    }
+        /**
+         *
+         * @type {System[]}
+         */
+        const systems = this.systems;
 
-    if (typeof system.remove === "function") {
-        throw new Error(`uses deprecated 'remove' method, should use 'unlink' instead`);
-    }
+        const system_count = systems.length;
 
-    // validate 'components_used' section
-    const components_used = system.components_used;
-    const components_used_count = components_used.length;
+        const fixed_step = this.fixedUpdateStepSize;
+        const accumulatedTime = this.systemAccumulatedFixedStepTime;
 
-    for (let i = 0; i < components_used_count; i++) {
-        const spec = components_used[i];
+        assert.notNaN(fixed_step, 'fixed_step');
+        assert.greaterThan(fixed_step, 0, 'fixed_step must be greater than 0');
 
-        if (spec === undefined || spec === null || spec.isResourceAccessSpecification !== true) {
-            throw new Error(`Invalid access specification[${i}], expected an instance of ResourceAccessSpecification, but got something else`);
-        }
+        for (let i = 0; i < system_count; i++) {
 
-        if (spec.resource === null) {
-            throw new Error(`No component specified for element [${i}]`);
-        }
+            const system = systems[i];
 
-        if (spec.access === 0) {
-            throw new Error('No access modifiers specified, must have at least one (such as Read, Write, Create)');
-        }
+            if (system.fixedUpdate !== noop) {
+                let accumulated_time = accumulatedTime.get(system) + timeDelta;
 
-        // backtrace to make sure there are no duplicates
-        for (let j = 0; j < i - 1; j++) {
-            const spec_other = components_used[j];
 
-            if (spec_other.resource === spec.resource) {
-                throw new Error(`Duplicate specification of component [${j}] and [${i}]`);
-            }
-        }
-    }
+                while (accumulated_time >= fixed_step) {
 
-    //validate dependencies
-    const dependencies = system.dependencies;
+                    try {
+                        system.fixedUpdate(fixed_step)
+                    } catch (e) {
+                        console.error(`Failed during fixedUpdate of system '${computeSystemName(system)}': `, e);
+                    }
 
-    const numDependencies = dependencies.length;
+                    accumulated_time -= fixed_step;
+                }
 
-    if (numDependencies < 1) {
-        throw  new Error(`A system must declare at least one dependency`);
-    }
+                // record whatever remains
+                accumulatedTime.set(system, accumulated_time);
 
-    if (numDependencies > 1) {
-        //check for duplicates
-        for (let i = 0; i < numDependencies; i++) {
-            const dependencyA = dependencies[i];
-            for (let j = i + 1; j < numDependencies; j++) {
-                if (dependencyA === dependencies[j]) {
-                    throw new Error(`Detected duplicate dependency: ${dependencyA.constructor.typeName}`);
-                }
             }
-        }
-    }
 
+            if (system.update !== noop) {
 
-    const linkArgumentCount = numDependencies + 1;
+                try {
+                    system.update(timeDelta);
+                } catch (e) {
+                    console.error(`Failed during update of system '${computeSystemName(system)}': `, e);
+                }
 
-    if (system.link !== System.prototype.link && system.link.length !== linkArgumentCount && system.__validation_ignore_link_argument_count !== true) {
-        throw new Error(`'link' method declares ${system.link.length} instead of expected ${linkArgumentCount} based on it's ${numDependencies} dependencies`);
-    }
+            }
 
-    if (system.unlink !== System.prototype.unlink && system.unlink.length !== linkArgumentCount && system.__validation_ignore_link_argument_count !== true) {
-        throw new Error(`'unlink' method declares ${system.unlink.length} instead of expected ${linkArgumentCount} based on it's ${numDependencies} dependencies`);
+        }
     }
-}
 
+    /**
+     * If the {@link EntityManager} is already started, the system will be started automatically before being added
+     * @param {System} system
+     * @returns {Promise}
+     * @throws {IllegalStateException}
+     */
+    addSystem(system) {
+        assert.defined(system, "system");
+        assert.isInstanceOf(system, System, 'system', 'System');
 
-/**
- * If the {@link EntityManager} is already started, the system will be started automatically before being added
- * @param {System} system
- * @returns {Promise}
- * @throws {IllegalStateException}
- */
-EntityManager.prototype.addSystem = function (system) {
-    assert.defined(system, "system");
-    assert.isInstanceOf(system, System, 'system', 'System');
-
-    const existing = this.getSystem(Object.getPrototypeOf(system).constructor);
+        const existing = this.getSystem(Object.getPrototypeOf(system).constructor);
 
-    if (existing !== null) {
-        if (existing === system) {
-            //system already added, do nothing
-            return Promise.resolve();
-        } else {
-            throw new IllegalStateException(`Another instance of system '${computeSystemName(system)}' is already registered`);
+        if (existing !== null) {
+            if (existing === system) {
+                //system already added, do nothing
+                return Promise.resolve();
+            } else {
+                throw new IllegalStateException(`Another instance of system '${computeSystemName(system)}' is already registered`);
+            }
         }
-    }
 
 
-    try {
-        validateSystem(system);
-    } catch (e) {
-        console.error(`System validation failed '${computeSystemName(system)}' : `, e, system);
-    }
+        try {
+            validateSystem(system);
+        } catch (e) {
+            console.error(`System validation failed '${computeSystemName(system)}' : `, e, system);
+        }
 
-    //check system state
-    const systemState = system.state.getValue();
+        //check system state
+        const systemState = system.state.getValue();
 
-    const legalStates = [System.State.INITIAL, System.State.STOPPED];
+        const legalStates = [SystemState.INITIAL, SystemState.STOPPED];
 
-    if (legalStates.indexOf(systemState) === -1) {
-        //illegal state
-        throw new IllegalStateException(`System must be in one of these states: [${legalStates.join(",")}], instead was ${systemState}`);
-    }
+        if (legalStates.indexOf(systemState) === -1) {
+            //illegal state
+            throw new IllegalStateException(`System must be in one of these states: [${legalStates.join(",")}], instead was ${systemState}`);
+        }
 
-    const systems = this.systems;
-    const systemIndex = systems.length;
+        const systems = this.systems;
+        const systemIndex = systems.length;
 
-    systems[systemIndex] = system;
+        systems[systemIndex] = system;
 
-    // request exec order update
-    this.__execution_order_needs_update = true;
+        // request exec order update
+        this.__execution_order_needs_update = true;
 
-    //build observer
-    const linkObserver = new EntityObserver(system.dependencies, system.link, system.unlink, system);
-    this.systemObservers[systemIndex] = linkObserver;
+        //build observer
+        const linkObserver = new EntityObserver(system.dependencies, system.link, system.unlink, system);
+        this.systemObservers[systemIndex] = linkObserver;
 
-    let startup_promise;
-    if (this.state === EntityManagerState.Running) {
-        //initialize the system
-        startup_promise = new Promise((resolve, reject) => {
-            this.startSystem(system, resolve, reject);
-        });
-    } else {
-        startup_promise = Promise.resolve();
-    }
+        let startup_promise;
+        if (this.state === EntityManagerState.Running) {
+            //initialize the system
+            startup_promise = new Promise((resolve, reject) => {
+                this.startSystem(system, resolve, reject);
+            });
+        } else {
+            startup_promise = Promise.resolve();
+        }
 
-    if (this.dataset !== null) {
+        if (this.dataset !== null) {
 
-        // link dependency components
-        this.dataset.registerManyComponentTypes(system.referenced_components);
+            // link dependency components
+            this.dataset.registerManyComponentTypes(system.referenced_components);
 
-        this.dataset.addObserver(linkObserver);
-    }
+            this.dataset.addObserver(linkObserver);
+        }
 
-    this.systemAccumulatedFixedStepTime.set(system, 0);
+        this.systemAccumulatedFixedStepTime.set(system, 0);
 
-    this.on.systemAdded.send1(system);
+        this.on.systemAdded.send1(system);
 
-    return startup_promise;
-};
+        return startup_promise;
+    }
 
-/**
- *
- * @param {System} system
- * @returns {Promise<boolean>}
- */
-EntityManager.prototype.removeSystem = async function (system) {
-    assert.defined(system, "system");
-    assert.isInstanceOf(system, System, 'system', 'System');
+    /**
+     *
+     * @param {System} system
+     * @returns {Promise<boolean>}
+     */
+    async removeSystem(system) {
+        assert.defined(system, "system");
+        assert.isInstanceOf(system, System, 'system', 'System');
 
 
-    const systemIndex = this.systems.indexOf(system);
+        const systemIndex = this.systems.indexOf(system);
 
-    if (systemIndex === -1) {
-        //system not found
-        return false;
-    }
+        if (systemIndex === -1) {
+            //system not found
+            return false;
+        }
 
-    //unlink system observer
-    const systemObserver = this.systemObservers[systemIndex];
-    this.systemObservers.splice(systemIndex, 1);
+        //unlink system observer
+        const systemObserver = this.systemObservers[systemIndex];
+        this.systemObservers.splice(systemIndex, 1);
 
-    assert.notEqual(systemObserver, undefined, "System observer is undefined, it was possibly removed illegally or was not created");
+        assert.notEqual(systemObserver, undefined, "System observer is undefined, it was possibly removed illegally or was not created");
 
 
-    //shutdown system
-    this.systems.splice(systemIndex, 1);
+        //shutdown system
+        this.systems.splice(systemIndex, 1);
 
-    // request exec order update
-    this.__execution_order_needs_update = true;
+        // request exec order update
+        this.__execution_order_needs_update = true;
 
-    if (this.dataset !== null) {
-        this.dataset.removeObserver(systemObserver);
-    }
+        if (this.dataset !== null) {
+            this.dataset.removeObserver(systemObserver);
+        }
 
-    await new Promise((resolve, reject) => {
-        this.stopSystem(system, resolve, (reason) => {
+        await new Promise((resolve, reject) => {
+            this.stopSystem(system, resolve, (reason) => {
 
-            reject(`system ${computeSystemName(system)} shutdown failed: ${reason}`);
+                reject(`system ${computeSystemName(system)} shutdown failed: ${reason}`);
+            });
         });
-    });
 
-    this.systemAccumulatedFixedStepTime.delete(system);
+        this.systemAccumulatedFixedStepTime.delete(system);
 
-    this.on.systemRemoved.send1(system);
+        this.on.systemRemoved.send1(system);
 
-    return true;
-};
+        return true;
+    }
 
+    /**
+     * @private
+     * @param {System} system
+     * @param {function(system: System)} successCallback
+     * @param {function(reason:*)} errorCallback
+     */
+    stopSystem(system, successCallback, errorCallback) {
+        const self = this;
 
-/**
- * @private
- * @param {System} system
- * @param {function(system: System)} successCallback
- * @param {function(reason:*)} errorCallback
- */
-EntityManager.prototype.stopSystem = function (system, successCallback, errorCallback) {
-    const self = this;
-
-    try {
-        system.state.set(System.State.STOPPING);
-    } catch (e) {
-        console.error(`Failed to set system state to STOPPING`, e);
-        errorCallback(e);
-        return;
-    }
+        try {
+            system.state.set(SystemState.STOPPING);
+        } catch (e) {
+            console.error(`Failed to set system state to STOPPING`, e);
+            errorCallback(e);
+            return;
+        }
 
-    function systemReady() {
-        system.state.set(System.State.STOPPED);
+        function systemReady() {
+            system.state.set(SystemState.STOPPED);
 
-        self.on.systemStopped.send1(system);
+            self.on.systemStopped.send1(system);
 
-        successCallback(system);
-    }
+            successCallback(system);
+        }
 
-    function systemFailed(reason) {
-        errorCallback(reason);
-    }
+        function systemFailed(reason) {
+            errorCallback(reason);
+        }
 
-    try {
-        system.shutdown(self, systemReady, systemFailed);
-    } catch (e) {
-        console.error(`Failed to execute system shutdown`, e);
-        errorCallback(e);
+        try {
+            system.shutdown(self, systemReady, systemFailed);
+        } catch (e) {
+            console.error(`Failed to execute system shutdown`, e);
+            errorCallback(e);
+        }
     }
-};
 
-/**
- * @private
- * @param {System} system
- * @param {function(system: System)} successCallback
- * @param {function(reason:*)} errorCallback
- */
-EntityManager.prototype.startSystem = function (system, successCallback, errorCallback) {
-    assert.defined(system, "system");
-    assert.isFunction(successCallback, "successCallback");
-    assert.isFunction(errorCallback, "errorCallback");
-
-    if (system.state.getValue() === System.State.RUNNING) {
-        //system is already running
-        console.warn(`System '${computeSystemName(system)}' is already running, nothing to do`);
-        successCallback(system);
-        return;
-    }
+    /**
+     * @private
+     * @param {System} system
+     * @param {function(system: System)} successCallback
+     * @param {function(reason:*)} errorCallback
+     */
+    startSystem(system, successCallback, errorCallback) {
+        assert.defined(system, "system");
+        assert.isFunction(successCallback, "successCallback");
+        assert.isFunction(errorCallback, "errorCallback");
+
+        if (system.state.getValue() === SystemState.RUNNING) {
+            //system is already running
+            console.warn(`System '${computeSystemName(system)}' is already running, nothing to do`);
+            successCallback(system);
+            return;
+        }
 
-    const self = this;
+        const self = this;
 
-    try {
-        system.state.set(System.State.STARTING);
-    } catch (e) {
-        console.error(`Failed to set system state to STARTING`, e);
-        errorCallback(e);
-        return;
-    }
+        try {
+            system.state.set(SystemState.STARTING);
+        } catch (e) {
+            console.error(`Failed to set system state to STARTING`, e);
+            errorCallback(e);
+            return;
+        }
 
-    function systemReady() {
-        system.state.set(System.State.RUNNING);
+        function systemReady() {
+            system.state.set(SystemState.RUNNING);
 
-        self.on.systemStarted.dispatch(system);
+            self.on.systemStarted.dispatch(system);
 
-        successCallback(system);
-    }
+            successCallback(system);
+        }
 
-    function systemFailed(reason) {
-        errorCallback(reason);
-    }
+        function systemFailed(reason) {
+            errorCallback(reason);
+        }
 
-    try {
-        system.startup(self, systemReady, systemFailed);
-    } catch (e) {
-        console.error(`Failed to execute system startup`, e);
-        systemFailed(e);
+        try {
+            system.startup(self, systemReady, systemFailed);
+        } catch (e) {
+            console.error(`Failed to execute system startup`, e);
+            systemFailed(e);
+        }
     }
-};
 
-/**
- *
- * @param {function} readyCallback executed once entity manager successfully completes startup
- * @param {function} errorCallback executed if entity manager encounters an error during startup
- */
-EntityManager.prototype.startup = function (readyCallback, errorCallback) {
-    if (this.state === EntityManagerState.Starting) {
-        throw new IllegalStateException(`System is currently in starting state`);
-    }
+    /**
+     *
+     * @param {function} readyCallback executed once entity manager successfully completes startup
+     * @param {function} errorCallback executed if entity manager encounters an error during startup
+     */
+    startup(readyCallback, errorCallback) {
+        if (this.state === EntityManagerState.Starting) {
+            throw new IllegalStateException(`System is currently in starting state`);
+        }
 
-    if (this.state === EntityManagerState.Running) {
-        // already running, do nothing
-        readyCallback();
-        return;
-    }
+        if (this.state === EntityManagerState.Running) {
+            // already running, do nothing
+            readyCallback();
+            return;
+        }
 
-    assert.isFunction(readyCallback, 'readyCallback');
-    assert.isFunction(errorCallback, 'errorCallback');
+        assert.isFunction(readyCallback, 'readyCallback');
+        assert.isFunction(errorCallback, 'errorCallback');
 
-    this.state = EntityManagerState.Starting;
+        this.state = EntityManagerState.Starting;
 
-    const self = this;
-    const systems = this.systems;
-    let readyCount = 0;
-    const expectedReadyCount = systems.length;
+        const self = this;
+        const systems = this.systems;
+        let readyCount = 0;
+        const expectedReadyCount = systems.length;
 
-    console.log(`EntityManager startup initialized, starting ${expectedReadyCount} systems.`);
+        console.log(`EntityManager startup initialized, starting ${expectedReadyCount} systems.`);
 
-    function finalizeStartup() {
-        self.state = EntityManagerState.Running;
+        function finalizeStartup() {
+            self.state = EntityManagerState.Running;
 
-        console.log(`EntityManager startup finished, all systems started`);
-        try {
-            readyCallback();
-        } catch (e) {
-            console.error("All systems were started OK, but readyCallback failed.", e);
+            console.log(`EntityManager startup finished, all systems started`);
+            try {
+                readyCallback();
+            } catch (e) {
+                console.error("All systems were started OK, but readyCallback failed.", e);
+            }
         }
-    }
 
-    function systemReady() {
-        //startup all systems
-        readyCount++;
+        function systemReady() {
+            //startup all systems
+            readyCount++;
 
-        if (readyCount === expectedReadyCount) {
-            finalizeStartup();
+            if (readyCount === expectedReadyCount) {
+                finalizeStartup();
+            }
         }
-    }
 
-    let firstFailure = true;
+        let firstFailure = true;
 
-    function systemError(system, error) {
-        console.error("Failed to start system", system, 'Error:', error);
+        function systemError(system, error) {
+            console.error("Failed to start system", system, 'Error:', error);
 
-        if (firstFailure) {
-            firstFailure = false;
+            if (firstFailure) {
+                firstFailure = false;
 
-            self.state = EntityManagerState.Failed;
+                self.state = EntityManagerState.Failed;
 
-            errorCallback(error);
+                errorCallback(error);
+            }
         }
-    }
 
-    if (expectedReadyCount === 0) {
-        //no systems registered, we're done
-        finalizeStartup();
-        return;
-    }
+        if (expectedReadyCount === 0) {
+            //no systems registered, we're done
+            finalizeStartup();
+            return;
+        }
 
-    systems.forEach(function (system) {
-        //ensure eventManager are there
-        //start the system
-        const cbOK = systemReady.bind(null, system);
-        const cbError = systemError.bind(null, system);
+        systems.forEach(function (system) {
+            //ensure eventManager are there
+            //start the system
+            const cbOK = systemReady.bind(null, system);
+            const cbError = systemError.bind(null, system);
 
-        self.startSystem(system, cbOK, cbError);
+            self.startSystem(system, cbOK, cbError);
 
-    });
-};
+        });
+    }
 
-/**
- *
- * @param {Class} systemClass
- * @returns {Promise.<System>}
- */
-EntityManager.prototype.promiseSystem = function (systemClass) {
     /**
      *
-     * @type {EntityManager}
+     * @param {Class} systemClass
+     * @returns {Promise.<System>}
      */
-    const em = this;
+    promiseSystem(systemClass) {
+        /**
+         *
+         * @type {EntityManager}
+         */
+        const em = this;
 
-    return new Promise(function (resolve, reject) {
+        return new Promise(function (resolve, reject) {
 
-        function systemAdded(s) {
-            if (s instanceof systemClass) {
-                //unregister listener
-                em.on.systemAdded.remove(systemAdded);
-                resolve(s);
+            function systemAdded(s) {
+                if (s instanceof systemClass) {
+                    //unregister listener
+                    em.on.systemAdded.remove(systemAdded);
+                    resolve(s);
+                }
             }
-        }
 
-        const system = em.getSystem(systemClass);
-        if (system !== null) {
-            resolve(system);
-        } else {
-            em.on.systemAdded.add(systemAdded);
-        }
-    });
-};
+            const system = em.getSystem(systemClass);
+            if (system !== null) {
+                resolve(system);
+            } else {
+                em.on.systemAdded.add(systemAdded);
+            }
+        });
+    }
 
-/**
- *
- * @param {Class} systemClass
- * @param {System.State} state
- * @returns {Promise.<System>}
- */
-EntityManager.prototype.promiseSystemInState = function (systemClass, state) {
-    const em = this;
+    /**
+     *
+     * @param {Class} systemClass
+     * @param {SystemState} state
+     * @returns {Promise.<System>}
+     */
+    promiseSystemInState(systemClass, state) {
+        const em = this;
 
-    return new Promise(function (resolve, reject) {
+        return new Promise(function (resolve, reject) {
 
-        const pSystem = em.promiseSystem(systemClass);
+            const pSystem = em.promiseSystem(systemClass);
 
-        pSystem.then(function (system) {
-            function tryProcessSystem() {
-                if (system.state.get() !== state) {
-                    system.state.onChanged.addOne(tryProcessSystem);
-                } else {
-                    resolve(system);
+            pSystem.then(function (system) {
+                function tryProcessSystem() {
+                    if (system.state.get() !== state) {
+                        system.state.onChanged.addOne(tryProcessSystem);
+                    } else {
+                        resolve(system);
+                    }
                 }
-            }
 
-            tryProcessSystem();
-        }, reject);
+                tryProcessSystem();
+            }, reject);
 
-    });
-};
+        });
+    }
 
-/**
- *
- * @param {function} readyCallback
- * @param {function} errorCallback
- */
-EntityManager.prototype.shutdown = function (readyCallback, errorCallback) {
-    this.state = EntityManagerState.Stopping;
+    /**
+     *
+     * @param {function} readyCallback
+     * @param {function} errorCallback
+     */
+    shutdown(readyCallback, 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();
-    }
+        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();
+        }
 
-    const self = this;
-    const systems = this.systems;
-    let readyCount = 0;
-    const expectedReadyCount = systems.length;
+        const self = this;
+        const systems = this.systems;
+        let readyCount = 0;
+        const expectedReadyCount = systems.length;
 
-    function finalizeShutdown() {
-        self.state = EntityManagerState.Stopped;
+        function finalizeShutdown() {
+            self.state = EntityManagerState.Stopped;
 
-        try {
-            readyCallback();
-        } catch (e) {
-            console.error("All systems were shutdown OK, but readyCallback failed.", e);
+            try {
+                readyCallback();
+            } catch (e) {
+                console.error("All systems were shutdown OK, but readyCallback failed.", e);
+            }
         }
-    }
 
-    function systemReady(system) {
-        //startup all systems
-        readyCount++;
+        function systemReady(system) {
+            //startup all systems
+            readyCount++;
 
-        system.state.set(System.State.STOPPED);
+            system.state.set(SystemState.STOPPED);
 
-        self.on.systemStopped.send1(system);
-        if (readyCount === expectedReadyCount) {
-            finalizeShutdown();
+            self.on.systemStopped.send1(system);
+            if (readyCount === expectedReadyCount) {
+                finalizeShutdown();
+            }
         }
-    }
 
-    let firstFailure = true;
+        let firstFailure = true;
 
-    function systemError(system) {
-        console.error("Failed to shutdown system", system);
+        function systemError(system) {
+            console.error("Failed to shutdown system", system);
 
-        if (firstFailure) {
-            firstFailure = false;
+            if (firstFailure) {
+                firstFailure = false;
 
-            self.state = EntityManagerState.Failed;
+                self.state = EntityManagerState.Failed;
 
-            errorCallback();
+                errorCallback();
+            }
         }
-    }
-
-    if (expectedReadyCount === 0) {
-        //no systems registered, we're done
-        finalizeShutdown();
-    }
 
-    systems.forEach(function (system) {
-        system.state.set(System.State.STOPPING);
-        //start the system
-        const cbOK = systemReady.bind(null, system);
-        const cbError = systemError.bind(null, system);
-        try {
-            system.shutdown(self, cbOK, cbError);
-        } catch (e) {
-            //failure in shutdown function
-            cbError(e);
+        if (expectedReadyCount === 0) {
+            //no systems registered, we're done
+            finalizeShutdown();
         }
-    });
-};
 
-export {
-    EventType,
-    EntityManager
-};
+        systems.forEach(function (system) {
+            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);
+            } catch (e) {
+                //failure in shutdown function
+                cbError(e);
+            }
+        });
+    }
+}