mani-game-engine 1.0.0-pre.5 → 1.0.0-pre.50

package/lib/gameEngine.js

@@ -1,317 +1,369 @@
-import { EngineSignals } from './types';
-import { putIfAbsent } from 'mani-injector';
-import { EcsInjector, signalHandlers, staticSignalHandlers } from './ecsInjector';
-import { Clock } from './clock';
-const defaultOptions = {
-    fixedDeltaTime: 1 / 60,
-    plugins: [],
-};
-export class GameEngine {
-    constructor(injector, clock) {
-        this.injector = injector;
-        this.clock = clock;
-        this.onEarlyUpdateSet = new Set();
-        this.onUpdateSet = new Set();
-        this.onFixedUpdateSet = new Set();
-        this.onPreFixedUpdateSet = new Set();
-        this.onPhysicsUpdateSet = new Set();
-        this.onPostPhysicsUpdateSet = new Set();
-        this.onLateUpdateSet = new Set();
-        this.onRenderUpdateSet = new Set();
-        this.entitySystemMap = new Map();
-        this.serviceClasses = new Set();
-        this.services = [];
-        this.resolveFrame = () => undefined;
-        this.addQueue = [];
-        this.removeQueue = [];
-        this._started = false;
-        this._frameCount = 0;
-        this._fixedFrameCount = 0;
-        this.signalMappings = new Map();
-        this.staticSignalMappings = new Map();
-        this.signalMapBindings = new Map();
-        this.injector.map(GameEngine).toValue(this);
-        this.onPrepare = this.injector.getSignal(EngineSignals.OnPrepare);
-        this.onStart = this.injector.getSignal(EngineSignals.OnStart);
-        this.onRender = this.injector.getSignal(EngineSignals.OnRender);
-        this.onFixedUpdate = this.injector.getSignal(EngineSignals.OnFixedUpdate);
-        this.onUpdate = this.injector.getSignal(EngineSignals.OnUpdate);
-        this.onLateUpdate = this.injector.getSignal(EngineSignals.OnLateUpdate);
-        this.onPostPhysics = this.injector.getSignal(EngineSignals.OnPostPhysics);
-        this.setupClock();
-        this.prepareFrame();
-    }
-    get started() { return this._started; }
-    get frameCount() { return this._frameCount; }
-    get fixedFrameCount() { return this._fixedFrameCount; }
-    get numEntities() { return this.entitySystemMap.size; }
-    static createDefault(options) {
-        const opts = Object.assign(Object.assign({}, defaultOptions), options);
-        const clock = new Clock({
-            fixedDeltaTime: opts.fixedDeltaTime,
-            autoStart: false,
-        });
-        const injector = new EcsInjector();
-        const engine = new GameEngine(injector, clock);
-        engine.installPlugins(opts.plugins);
-        return engine;
-    }
-    static createDefaultWithInjector(injector, options) {
-        const opts = Object.assign(Object.assign({}, defaultOptions), options);
-        const clock = new Clock({
-            fixedDeltaTime: opts.fixedDeltaTime,
-            autoStart: false,
-        });
-        const engine = new GameEngine(injector, clock);
-        engine.installPlugins(opts.plugins);
-        return engine;
-    }
-    setupClock() {
-        this.clock.onPrepare.add(this.prepareFrame, this);
-        this.clock.onEarlyUpdate.add(({ time, deltaTime }) => {
-            for (const system of this.onEarlyUpdateSet) {
-                system.onEarlyUpdate(time, deltaTime);
-            }
-        });
-        this.clock.onFixedUpdate.add((params) => {
-            const { time, deltaTime } = params;
-            for (const system of this.onPreFixedUpdateSet) {
-                system.onPreFixedUpdate();
-            }
-            for (const system of this.onFixedUpdateSet) {
-                system.onFixedUpdate(time, deltaTime);
-            }
-            this.onFixedUpdate.dispatch(params);
-            for (const system of this.onPhysicsUpdateSet) {
-                system.onPhysicsUpdate(time, deltaTime);
-            }
-            this.onPostPhysics.dispatch(params);
-            for (const system of this.onPostPhysicsUpdateSet) {
-                system.onPostPhysicsUpdate(time, deltaTime);
-            }
-            this._fixedFrameCount++;
-        });
-        this.clock.onUpdate.add(onUpdateParams => {
-            const { time, deltaTime, alpha } = onUpdateParams;
-            for (const system of this.onUpdateSet) {
-                system.onUpdate(time, deltaTime, alpha);
-            }
-            this.onUpdate.dispatch(onUpdateParams);
-            for (const system of this.onLateUpdateSet) {
-                system.onLateUpdate(time, deltaTime, alpha);
-            }
-            this.onLateUpdate.dispatch(onUpdateParams);
-            for (const system of this.onRenderUpdateSet) {
-                system.onRender(time, deltaTime, alpha);
-            }
-            this.onRender.dispatch(onUpdateParams);
-            this._frameCount++;
-        });
-    }
-    installPlugins(plugins) {
-        plugins.forEach(plugin => {
-            plugin.onPrepare && plugin.onPrepare(this);
-        });
-        plugins.forEach(plugin => {
-            plugin.onStart && plugin.onStart(this);
-        });
-    }
-    registerSystem(systemClass) {
-        this.mapStaticAnnotatedSignals(systemClass);
-        if (this._started)
-            throw new Error('Register Systems before engine is started');
-        this.injector.registerSystem(systemClass);
-    }
-    registerService(serviceClass) {
-        this.mapStaticAnnotatedSignals(serviceClass);
-        if (this._started)
-            throw new Error('Register Services before engine is started');
-        this.injector.map(serviceClass).toSingleton();
-        this.serviceClasses.add(serviceClass);
-    }
-    getService(serviceClass) {
-        return this.injector.get(serviceClass);
-    }
-    start() {
-        this._started = true;
-        for (const serviceClass of this.serviceClasses) {
-            const service = this.injector.get(serviceClass);
-            this.addService(service);
-        }
-        this.clock.start();
-        this.onStart.dispatch();
-    }
-    addService(service) {
-        this.mapAnnotatedSignals(service);
-        service.onStart && service.onStart();
-        service.onPreFixedUpdate && this.onPreFixedUpdateSet.add(service);
-        service.onFixedUpdate && this.onFixedUpdateSet.add(service);
-        service.onUpdate && this.onUpdateSet.add(service);
-        service.onLateUpdate && this.onLateUpdateSet.add(service);
-        service.onPhysicsUpdate && this.onPhysicsUpdateSet.add(service);
-        service.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(service);
-        service.onRender && this.onRenderUpdateSet.add(service);
-        this.services.push(service);
-    }
-    add(entity) {
-        return new Promise(resolve => this.addQueue.push([entity, resolve]));
-    }
-    waitFrame() {
-        return this.framePromise;
-    }
-    async remove(entity) {
-        if (entity.markRemoval)
-            return;
-        entity.markRemoval = true;
-        return new Promise(resolve => this.removeQueue.push([entity, resolve]));
-    }
-    stop() {
-        this.clock.stop();
-    }
-    runAction(action) {
-        return action(this);
-    }
-    getSignal(signalId) {
-        return this.injector.getSignal(signalId);
-    }
-    mapStaticAnnotatedSignals(target) {
-        let staticSignalMap = this.getStaticSignalMap(target);
-        if (staticSignalMap.length === 0)
-            return;
-        const bindings = [];
-        for (const [key, signal] of staticSignalMap) {
-            bindings.push(signal.add(target[key], target));
-        }
-    }
-    mapAnnotatedSignals(target) {
-        const signalMap = this.getSignalMap(target.constructor);
-        if (signalMap.length === 0)
-            return;
-        const bindings = [];
-        for (const [key, signal] of signalMap) {
-            bindings.push(signal.add(target[key], target));
-        }
-        this.signalMapBindings.set(target, bindings);
-    }
-    unmapAnnotatedSignals(target) {
-        const signalBindings = this.signalMapBindings.get(target);
-        if (!signalBindings)
-            return;
-        for (const binding of signalBindings) {
-            binding.detach();
-        }
-    }
-    getSignalMap(target) {
-        return putIfAbsent(this.signalMappings, target, () => {
-            const handlers = signalHandlers.get(target);
-            if (!handlers)
-                return [];
-            const result = [];
-            for (const [key, signalId] of handlers) {
-                result.push([key, this.getSignal(signalId)]);
-            }
-            return result;
-        });
-    }
-    getStaticSignalMap(target) {
-        return putIfAbsent(this.staticSignalMappings, target, () => {
-            const handlers = staticSignalHandlers.get(target);
-            if (!handlers)
-                return [];
-            const result = [];
-            for (const [key, signalId] of handlers) {
-                result.push([key, this.getSignal(signalId)]);
-            }
-            return result;
-        });
-    }
-    dispose() {
-        this.clock.stop();
-        for (const systems of this.entitySystemMap.values()) {
-            for (const system of systems) {
-                system.system.onEnd && system.system.onEnd();
-            }
-        }
-        for (const service of this.services) {
-            service.onEnd && service.onEnd();
-        }
-    }
-    prepareFrame() {
-        for (const [entity, resolve] of this.removeQueue) {
-            const entities = entity.getAllEntities();
-            for (const entity of entities) {
-                entity.markRemoval = false;
-                if (!entity.gameEngine) {
-                    console.log(entity);
-                }
-                entity.gameEngine = undefined;
-                const systemContexts = this.entitySystemMap.get(entity);
-                this.entitySystemMap.delete(entity);
-                if (systemContexts) {
-                    for (const context of systemContexts) {
-                        context.dispose();
-                        const system = context.system;
-                        this.unmapAnnotatedSignals(system);
-                        system.onEnd && system.onEnd();
-                        system.onPreFixedUpdate && this.onPreFixedUpdateSet.delete(system);
-                        system.onFixedUpdate && this.onFixedUpdateSet.delete(system);
-                        system.onEarlyUpdate && this.onEarlyUpdateSet.delete(system);
-                        system.onUpdate && this.onUpdateSet.delete(system);
-                        system.onLateUpdate && this.onLateUpdateSet.delete(system);
-                        system.onPhysicsUpdate && this.onPhysicsUpdateSet.delete(system);
-                        system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.delete(system);
-                        system.onRender && this.onRenderUpdateSet.delete(system);
-                    }
-                }
-                entity.onRemove.dispatch();
-            }
-            resolve();
-        }
-        this.removeQueue = [];
-        for (const [entity, resolve] of this.addQueue) {
-            const preparePromises = [];
-            const nexSystemContexts = [];
-            const entities = entity.getAllEntities();
-            for (const entity of entities) {
-                if (entity.gameEngine)
-                    throw new Error('Entity already added to a gameEngine');
-                entity.gameEngine = this;
-                const systemContexts = this.injector.createSystems(entity);
-                for (const context of systemContexts) {
-                    context.system.onPrepare && preparePromises.push(context.system.onPrepare());
-                    nexSystemContexts.push(context);
-                }
-                this.entitySystemMap.set(entity, systemContexts);
-            }
-            const startSystems = () => {
-                for (const context of nexSystemContexts) {
-                    const system = context.system;
-                    this.mapAnnotatedSignals(system);
-                    system.onStart && system.onStart();
-                    system.onPreFixedUpdate && this.onPreFixedUpdateSet.add(system);
-                    system.onFixedUpdate && this.onFixedUpdateSet.add(system);
-                    system.onEarlyUpdate && this.onEarlyUpdateSet.add(system);
-                    system.onUpdate && this.onUpdateSet.add(system);
-                    system.onLateUpdate && this.onLateUpdateSet.add(system);
-                    system.onPhysicsUpdate && this.onPhysicsUpdateSet.add(system);
-                    system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(system);
-                    system.onRender && this.onRenderUpdateSet.add(system);
-                }
-                resolve();
-            };
-            if (preparePromises.length === 0) {
-                startSystems();
-            }
-            else {
-                Promise.all(preparePromises).then(startSystems);
-            }
-        }
-        this.addQueue = [];
-        this.resolveFrame();
-        this.framePromise = new Promise(resolve => {
-            this.resolveFrame = resolve;
-        });
-        this.onPrepare.dispatch();
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameEngine = void 0;
+const types_1 = require("./types");
+const ecsInjector_1 = require("./ecsInjector");
+const clock_1 = require("./clock");
+const injector_1 = require("./injector");
+const defaultOptions = {
+    fixedDeltaTime: 1 / 60,
+    plugins: [],
+};
+let id = 0;
+class GameEngine {
+    get started() { return this._started; }
+    get frameCount() { return this._frameCount; }
+    get fixedFrameCount() { return this._fixedFrameCount; }
+    get numEntities() { return this.entitySystemMap.size; }
+    constructor(injector, clock) {
+        this.injector = injector;
+        this.clock = clock;
+        this.id = id++;
+        this.onEarlyUpdateSet = new Set();
+        this.onUpdateSet = new Set();
+        this.onFixedUpdateSet = new Set();
+        this.onPreFixedUpdateSet = new Set();
+        this.onPhysicsUpdateSet = new Set();
+        this.onPrePhysicsUpdateSet = new Set();
+        this.onPostPhysicsUpdateSet = new Set();
+        this.onLateFixedUpdateSet = new Set();
+        this.onLateUpdateSet = new Set();
+        this.onRenderUpdateSet = new Set();
+        this.onAddEntitySet = new Set();
+        this.onRemoveEntitySet = new Set();
+        this.entitySystemMap = new Map();
+        this.serviceClasses = new Set();
+        this.services = [];
+        this.resolveFrame = () => undefined;
+        this.addQueue = [];
+        this.removeQueue = [];
+        this._started = false;
+        this._frameCount = 0;
+        this._fixedFrameCount = 0;
+        this.signalMappings = new Map();
+        this.staticSignalMappings = new Map();
+        this.signalMapBindings = new Map();
+        this.injector.map(GameEngine).toValue(this);
+        this.onPrepare = this.injector.getSignal(types_1.EngineSignals.OnPrepare);
+        this.onStart = this.injector.getSignal(types_1.EngineSignals.OnStart);
+        this.onEnd = this.injector.getSignal(types_1.EngineSignals.OnEnd);
+        this.onRender = this.injector.getSignal(types_1.EngineSignals.OnRender);
+        this.onFixedUpdate = this.injector.getSignal(types_1.EngineSignals.OnFixedUpdate);
+        this.onUpdate = this.injector.getSignal(types_1.EngineSignals.OnUpdate);
+        this.onLateUpdate = this.injector.getSignal(types_1.EngineSignals.OnLateUpdate);
+        this.onPrePhysicsUpdate = this.injector.getSignal(types_1.EngineSignals.OnPrePhysicsUpdate);
+        this.onPhysicsUpdate = this.injector.getSignal(types_1.EngineSignals.OnPhysicsUpdate);
+        this.onPostPhysicsUpdate = this.injector.getSignal(types_1.EngineSignals.OnPostPhysicsUpdate);
+        this.onLateFixedUpdate = this.injector.getSignal(types_1.EngineSignals.onLateFixedUpdate);
+        this.onAddEntity = this.injector.getSignal(types_1.EngineSignals.OnAddEntity);
+        this.onRemoveEntity = this.injector.getSignal(types_1.EngineSignals.OnRemoveEntity);
+        this.setupClock();
+        this.prepareFrame();
+    }
+    static createDefault(options) {
+        const opts = Object.assign(Object.assign({}, defaultOptions), options);
+        const clock = new clock_1.GameClock({
+            fixedDeltaTime: opts.fixedDeltaTime,
+            autoStart: false,
+        });
+        const injector = new ecsInjector_1.EcsInjector();
+        const engine = new GameEngine(injector, clock);
+        engine.installPlugins(opts.plugins);
+        return engine;
+    }
+    static createDefaultWithInjector(injector, options) {
+        const opts = Object.assign(Object.assign({}, defaultOptions), options);
+        const clock = new clock_1.GameClock({
+            fixedDeltaTime: opts.fixedDeltaTime,
+            autoStart: false,
+        });
+        const engine = new GameEngine(injector, clock);
+        engine.installPlugins(opts.plugins);
+        return engine;
+    }
+    addService(service) {
+        this.mapAnnotatedSignals(service);
+        service.onStart && service.onStart();
+        service.onPreFixedUpdate && this.onPreFixedUpdateSet.add(service);
+        service.onFixedUpdate && this.onFixedUpdateSet.add(service);
+        service.onUpdate && this.onUpdateSet.add(service);
+        service.onLateUpdate && this.onLateUpdateSet.add(service);
+        service.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.add(service);
+        service.onPhysicsUpdate && this.onPhysicsUpdateSet.add(service);
+        service.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(service);
+        service.onLateFixedUpdate && this.onLateFixedUpdateSet.add(service);
+        service.onRender && this.onRenderUpdateSet.add(service);
+        service.onAddEntity && this.onAddEntitySet.add(service);
+        service.onRemoveEntity && this.onRemoveEntitySet.add(service);
+        this.services.push(service);
+    }
+    installPlugins(plugins) {
+        plugins.forEach(plugin => {
+            plugin.onPrepare && plugin.onPrepare(this);
+        });
+        plugins.forEach(plugin => {
+            plugin.onStart && plugin.onStart(this);
+        });
+    }
+    registerSystem(systemClass) {
+        this.mapStaticAnnotatedSignals(systemClass);
+        if (this._started)
+            throw new Error('Register Systems before engine is started');
+        this.injector.registerSystem(systemClass);
+    }
+    registerService(serviceClass) {
+        this.mapStaticAnnotatedSignals(serviceClass);
+        if (this._started)
+            throw new Error('Register Services before engine is started');
+        this.injector.map(serviceClass).toSingleton();
+        this.serviceClasses.add(serviceClass);
+    }
+    getService(serviceClass) {
+        return this.injector.get(serviceClass);
+    }
+    start() {
+        this._started = true;
+        for (const serviceClass of this.serviceClasses) {
+            const service = this.injector.get(serviceClass);
+            this.addService(service);
+        }
+        this.clock.start();
+        this.onStart.dispatch();
+    }
+    setupClock() {
+        this.clock.onPrepare.add(this.prepareFrame, this);
+        this.clock.onEarlyUpdate.add(({ time, deltaTime }) => {
+            for (const system of this.onEarlyUpdateSet) {
+                system.onEarlyUpdate(time, deltaTime);
+            }
+        });
+        this.clock.onFixedUpdate.add((params) => {
+            const { time, deltaTime } = params;
+            for (const system of this.onPreFixedUpdateSet) {
+                system.onPreFixedUpdate(time, deltaTime);
+            }
+            for (const system of this.onFixedUpdateSet) {
+                system.onFixedUpdate(time, deltaTime);
+            }
+            this.onFixedUpdate.dispatch(params);
+            for (const system of this.onPhysicsUpdateSet) {
+                system.onPhysicsUpdate(time, deltaTime);
+            }
+            this.onPhysicsUpdate.dispatch(params);
+            this.onPostPhysicsUpdate.dispatch(params);
+            for (const system of this.onPostPhysicsUpdateSet) {
+                system.onPostPhysicsUpdate(time, deltaTime);
+            }
+            this.onLateFixedUpdate.dispatch(params);
+            for (const system of this.onLateFixedUpdateSet) {
+                system.onLateFixedUpdate(time, deltaTime);
+            }
+            this._fixedFrameCount++;
+        });
+        this.clock.onUpdate.add(onUpdateParams => {
+            const { time, deltaTime, alpha } = onUpdateParams;
+            for (const system of this.onUpdateSet) {
+                system.onUpdate(time, deltaTime, alpha);
+            }
+            this.onUpdate.dispatch(onUpdateParams);
+            for (const system of this.onLateUpdateSet) {
+                system.onLateUpdate(time, deltaTime, alpha);
+            }
+            this.onLateUpdate.dispatch(onUpdateParams);
+            for (const system of this.onRenderUpdateSet) {
+                system.onRender(time, deltaTime, alpha);
+            }
+            this.onRender.dispatch(onUpdateParams);
+            this._frameCount++;
+        });
+    }
+    add(entity) {
+        return new Promise(resolve => this.addQueue.push([entity, resolve]));
+    }
+    waitFrame() {
+        return this.framePromise;
+    }
+    async remove(entity) {
+        if (entity.markRemoval)
+            return;
+        entity.markRemoval = true;
+        return new Promise(resolve => this.removeQueue.push([entity, resolve]));
+    }
+    stop() {
+        this.clock.stop();
+    }
+    runAction(action) {
+        return action(this);
+    }
+    getSignal(signalId) {
+        return this.injector.getSignal(signalId);
+    }
+    mapStaticAnnotatedSignals(target) {
+        let staticSignalMap = this.getStaticSignalMap(target);
+        if (staticSignalMap.length === 0)
+            return;
+        const bindings = [];
+        for (const [key, signal] of staticSignalMap) {
+            bindings.push(signal.add(target[key], target));
+        }
+    }
+    mapAnnotatedSignals(target) {
+        const signalMap = this.getSignalMap(target.constructor);
+        if (signalMap.length === 0)
+            return;
+        const bindings = [];
+        for (const [key, signal] of signalMap) {
+            bindings.push(signal.add(target[key], target));
+        }
+        this.signalMapBindings.set(target, bindings);
+    }
+    unmapAnnotatedSignals(target) {
+        const signalBindings = this.signalMapBindings.get(target);
+        if (!signalBindings)
+            return;
+        for (const binding of signalBindings) {
+            binding.detach();
+        }
+    }
+    getSignalMap(target) {
+        return (0, injector_1.putIfAbsent)(this.signalMappings, target, () => {
+            const handlers = ecsInjector_1.signalHandlers.get(target);
+            if (!handlers)
+                return [];
+            const result = [];
+            for (const [key, signalId] of handlers) {
+                result.push([key, this.getSignal(signalId)]);
+            }
+            return result;
+        });
+    }
+    getStaticSignalMap(target) {
+        return (0, injector_1.putIfAbsent)(this.staticSignalMappings, target, () => {
+            const handlers = ecsInjector_1.staticSignalHandlers.get(target);
+            if (!handlers)
+                return [];
+            const result = [];
+            for (const [key, signalId] of handlers) {
+                result.push([key, this.getSignal(signalId)]);
+            }
+            return result;
+        });
+    }
+    dispose() {
+        this.clock.stop();
+        this.clock.dispose();
+        for (const systems of this.entitySystemMap.values()) {
+            for (const system of systems) {
+                system.system.onEnd && system.system.onEnd();
+            }
+        }
+        for (const service of this.services) {
+            service.onEnd && service.onEnd();
+        }
+        this.onEnd.dispatch();
+    }
+    prepareFrame() {
+        for (const [entity, resolve] of this.removeQueue) {
+            const entities = entity.getAllEntities();
+            for (const entity of entities) {
+                entity.markRemoval = false;
+                if (!entity.gameEngine) {
+                    console.log(entity);
+                }
+                entity.gameEngine = undefined;
+                const systemContexts = this.entitySystemMap.get(entity);
+                this.entitySystemMap.delete(entity);
+                if (systemContexts) {
+                    for (const context of systemContexts) {
+                        this.disposeContext(context);
+                    }
+                }
+                entity.onRemove.dispatch();
+                entity.onRemove.detachAll();
+                for (const system of this.onRemoveEntitySet) {
+                    system.onRemoveEntity(entity);
+                }
+            }
+            resolve();
+        }
+        this.removeQueue = [];
+        for (const [entity, resolve] of this.addQueue) {
+            const preparePromises = [];
+            const nextSystemContexts = [];
+            const entities = entity.getAllEntities();
+            for (const entity of entities) {
+                if (entity.gameEngine)
+                    throw new Error('Entity already added to a gameEngine');
+                entity.gameEngine = this;
+                const systemContexts = this.injector.createSystemsForEntity(entity);
+                for (const context of systemContexts) {
+                    context.system.onPrepare && preparePromises.push(context.system.onPrepare());
+                    nextSystemContexts.push(context);
+                }
+                this.entitySystemMap.set(entity, systemContexts);
+            }
+            const entityWasAdded = () => {
+                for (const system of this.onAddEntitySet) {
+                    system.onAddEntity(entity);
+                }
+                resolve();
+            };
+            if (preparePromises.length === 0) {
+                this.startSystems(nextSystemContexts, entityWasAdded);
+            }
+            else {
+                Promise.all(preparePromises).then(() => this.startSystems(nextSystemContexts, entityWasAdded));
+            }
+        }
+        this.addQueue = [];
+        this.resolveFrame();
+        this.framePromise = new Promise(resolve => {
+            this.resolveFrame = resolve;
+        });
+        this.onPrepare.dispatch();
+    }
+    startSystems(contexts, then) {
+        for (const context of contexts) {
+            const system = context.system;
+            this.mapAnnotatedSignals(system);
+            system.onStart && system.onStart();
+            system.onPreFixedUpdate && this.onPreFixedUpdateSet.add(system);
+            system.onFixedUpdate && this.onFixedUpdateSet.add(system);
+            system.onUpdate && this.onUpdateSet.add(system);
+            system.onLateUpdate && this.onLateUpdateSet.add(system);
+            system.onPhysicsUpdate && this.onPhysicsUpdateSet.add(system);
+            system.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.add(system);
+            system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(system);
+            system.onLateFixedUpdate && this.onLateFixedUpdateSet.add(system);
+            system.onRender && this.onRenderUpdateSet.add(system);
+            system.onAddEntity && this.onAddEntitySet.add(system);
+            system.onRemoveEntity && this.onRemoveEntitySet.add(system);
+        }
+        then === null || then === void 0 ? void 0 : then();
+    }
+    ;
+    disposeContext(context) {
+        const system = context.system;
+        const onEndPromise = system.onEnd && system.onEnd();
+        if (onEndPromise instanceof Promise) {
+            onEndPromise.then(() => {
+                context.dispose();
+            });
+        }
+        else {
+            context.dispose();
+        }
+        this.unmapAnnotatedSignals(system);
+        system.onPreFixedUpdate && this.onPreFixedUpdateSet.delete(system);
+        system.onFixedUpdate && this.onFixedUpdateSet.delete(system);
+        system.onUpdate && this.onUpdateSet.delete(system);
+        system.onLateUpdate && this.onLateUpdateSet.delete(system);
+        system.onPhysicsUpdate && this.onPhysicsUpdateSet.delete(system);
+        system.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.delete(system);
+        system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.delete(system);
+        system.onLateFixedUpdate && this.onLateFixedUpdateSet.delete(system);
+        system.onRender && this.onRenderUpdateSet.delete(system);
+    }
+}
+exports.GameEngine = GameEngine;
 //# sourceMappingURL=gameEngine.js.map