mani-game-engine 1.0.0-pre.7 → 1.0.0-pre.71

package/src/gameEngine.ts

@@ -1,413 +1,543 @@
 import {Action, Class, EngineSignals, GameEnginePlugin, OnFixedUpdateParams, OnUpdateParams, Service, System} from './types';
 import {Signal, SignalBinding} from 'mani-signal';
 import {Entity} from './entity';
-import {ID, putIfAbsent} from 'mani-injector';
 import {EcsInjector, signalHandlers, staticSignalHandlers} from './ecsInjector';
 import {Clock, GameClock} from './clock';
 import {SystemContext} from './systemContext';
+import {ID, putIfAbsent} from './injector';
 
 type AddEntry = [Entity, () => void];
 type RemoveEntry = [Entity, () => void];
 
 const defaultOptions = {
-    fixedDeltaTime: 1 / 60,
-    plugins: [] as GameEnginePlugin[],
+  fixedDeltaTime: 1 / 60,
+  plugins: [] as GameEnginePlugin[],
 };
 
 export type GameEngineOptions = Partial<typeof defaultOptions>;
 declare global {
-    interface GameEngineActions {
-        'testAction': string
-    }
+  interface GameEngineActions {
+    'testAction': string;
+  }
 }
 
 type GameEngineActionParams<K extends keyof GameEngineActions> = GameEngineActions[K];
 type GameAction<K extends keyof GameEngineActions> = (engine: GameEngine, params: GameEngineActionParams<K>) => Promise<any> | any;
 
+let id = 0;
 export class GameEngine {
+  readonly id = id++;
+  readonly onPrepare: Signal;
+  readonly onStart: Signal;
+  readonly onEnd: Signal;
+  readonly onRender: Signal<OnUpdateParams>;
+  readonly onUpdate: Signal<OnUpdateParams>;
+  readonly onFixedUpdate: Signal<OnFixedUpdateParams>;
+  readonly onPrePhysicsUpdate: Signal<OnFixedUpdateParams>;
+  readonly onPhysicsUpdate: Signal<OnFixedUpdateParams>;
+  readonly onPostPhysicsUpdate: Signal<OnFixedUpdateParams>;
+  readonly onLateFixedUpdate: Signal<OnFixedUpdateParams>;
+  readonly onLateUpdate: Signal<OnUpdateParams>;
+  readonly onAddEntity: Signal<Entity>;
+  readonly onRemoveEntity: Signal<Entity>;
+
+  private readonly onEarlyUpdateSet = new Set<System>();
+  private readonly onUpdateSet = new Set<System>();
+  private readonly onFixedUpdateSet = new Set<System>();
+  private readonly onPreFixedUpdateSet = new Set<System>();
+  private readonly onPhysicsUpdateSet = new Set<System>();
+  private readonly onPrePhysicsUpdateSet = new Set<System>();
+  private readonly onPostPhysicsUpdateSet = new Set<System>();
+  private readonly onLateFixedUpdateSet = new Set<System>();
+  private readonly onLateUpdateSet = new Set<System>();
+  private readonly onRenderUpdateSet = new Set<System>();
+  private readonly onAddEntitySet = new Set<System>();
+  private readonly onRemoveEntitySet = new Set<System>();
 
-    readonly onPrepare: Signal;
-    readonly onStart: Signal;
-    readonly onRender: Signal<OnUpdateParams>;
-    readonly onUpdate: Signal<OnUpdateParams>;
-    readonly onFixedUpdate: Signal<OnFixedUpdateParams>;
-    readonly onPostPhysics: Signal<OnFixedUpdateParams>;
-    readonly onLateFixedUpdate: Signal<OnFixedUpdateParams>;
-    readonly onLateUpdate: Signal<OnUpdateParams>;
+  // TODO: for performance, we could store the systems directly in the entity
+  private readonly entitySystemMap = new Map<Entity, Set<SystemContext>>();
 
-    private readonly onEarlyUpdateSet = new Set<System>();
-    private readonly onUpdateSet = new Set<System>();
-    private readonly onFixedUpdateSet = new Set<System>();
-    private readonly onPreFixedUpdateSet = new Set<System>();
-    private readonly onPhysicsUpdateSet = new Set<System>();
-    private readonly onPostPhysicsUpdateSet = new Set<System>();
-    private readonly onLateFixedUpdateSet = new Set<System>();
-    private readonly onLateUpdateSet = new Set<System>();
-    private readonly onRenderUpdateSet = new Set<System>();
+  private readonly registeredServices = new Set<Class<Service>>();
+  private readonly services: Service[] = [];
+  private readonly systemChildInjectors = new Map<object, EcsInjector>();
 
-    private readonly entitySystemMap = new Map<Entity, SystemContext[]>();
+  private framePromise!: Promise<any>;
+  private resolveFrame: () => void = () => undefined;
 
-    private readonly serviceClasses = new Set<Class<Service>>();
-    private readonly services: Service[] = [];
+  private addQueue: AddEntry[] = [];
+  private removeQueue: RemoveEntry[] = [];
 
-    private framePromise!: Promise<any>;
-    private resolveFrame: () => void = () => undefined;
+  private _started = false;
 
-    private addQueue: AddEntry[] = [];
-    private removeQueue: RemoveEntry[] = [];
+  get started(): boolean { return this._started; }
 
-    private _started = false;
+  private _frameCount = 0;
+  get frameCount(): number { return this._frameCount; }
 
-    get started(): boolean { return this._started; }
+  private _fixedFrameCount = 0;
+  get fixedFrameCount(): number { return this._fixedFrameCount; }
 
-    private _frameCount = 0;
-    get frameCount(): number { return this._frameCount; }
+  get numEntities(): number { return this.entitySystemMap.size;}
 
-    private _fixedFrameCount = 0;
-    get fixedFrameCount(): number { return this._fixedFrameCount; }
 
-    get numEntities(): number { return this.entitySystemMap.size;}
 
 // TODO inject clock into game engine
 // TODO inject space into game engine
 
-    constructor(
-        readonly injector: EcsInjector<Class<System>>,
-        readonly clock: Clock,
-    ) {
-        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.onLateFixedUpdate = this.injector.getSignal(EngineSignals.onLateFixedUpdate);
-
-        this.setupClock();
-        this.prepareFrame();
+  constructor(
+    readonly injector: EcsInjector<Class<System>>,
+    readonly clock: Clock,
+  ) {
+    this.injector.map(GameEngine).toValue(this);
+
+    this.onPrepare = this.injector.getSignal(EngineSignals.OnPrepare);
+    this.onStart = this.injector.getSignal(EngineSignals.OnStart);
+    this.onEnd = this.injector.getSignal(EngineSignals.OnEnd);
+    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.onPrePhysicsUpdate = this.injector.getSignal(EngineSignals.OnPrePhysicsUpdate);
+    this.onPhysicsUpdate = this.injector.getSignal(EngineSignals.OnPhysicsUpdate);
+    this.onPostPhysicsUpdate = this.injector.getSignal(EngineSignals.OnPostPhysicsUpdate);
+    this.onLateFixedUpdate = this.injector.getSignal(EngineSignals.onLateFixedUpdate);
+
+    this.onAddEntity = this.injector.getSignal(EngineSignals.OnAddEntity);
+    this.onRemoveEntity = this.injector.getSignal(EngineSignals.OnRemoveEntity);
+
+    this.setupClock();
+    this.prepareFrame();
+  }
+
+  static createDefault(options?: GameEngineOptions) {
+    const opts = {...defaultOptions, ...options};
+    const clock = new GameClock({
+      fixedDeltaTime: opts.fixedDeltaTime,
+      autoStart: false,
+    });
+    const injector = new EcsInjector<Class<System>>();
+    const engine = new GameEngine(injector, clock);
+    engine.installPlugins(opts.plugins);
+    return engine;
+  }
+
+  static createDefaultWithInjector(injector: EcsInjector<Class<System>>, options?: GameEngineOptions) {
+    const opts = {...defaultOptions, ...options};
+    const clock = new GameClock({
+      fixedDeltaTime: opts.fixedDeltaTime,
+      autoStart: false,
+    });
+    const engine = new GameEngine(injector, clock);
+    engine.installPlugins(opts.plugins);
+    return engine;
+  }
+
+  // TODO: test
+  addServiceClass<T extends Class<Service>>(serviceClass: T, mapping?: (injector: EcsInjector) => void): InstanceType<T> {
+    let childInjector: EcsInjector | undefined;
+    if (mapping) {
+      childInjector = this.injector.createChild();
+      mapping(childInjector);
     }
-
-    static createDefault(options?: GameEngineOptions) {
-        const opts = {...defaultOptions, ...options};
-        const clock = new GameClock({
-            fixedDeltaTime: opts.fixedDeltaTime,
-            autoStart: false,
-        });
-        const injector = new EcsInjector<Class<System>>();
-        const engine = new GameEngine(injector, clock);
-        engine.installPlugins(opts.plugins);
-        return engine;
+    this.mapStaticAnnotatedSignals(serviceClass);
+    const service = childInjector?.createInstance(serviceClass) || this.injector.createInstance(serviceClass);
+    this.addService(service);
+    if (childInjector) {
+      this.systemChildInjectors.set(service, childInjector);
     }
-
-    static createDefaultWithInjector(injector: EcsInjector<Class<System>>, options?: GameEngineOptions) {
-        const opts = {...defaultOptions, ...options};
-        const clock = new GameClock({
-            fixedDeltaTime: opts.fixedDeltaTime,
-            autoStart: false,
-        });
-        const engine = new GameEngine(injector, clock);
-        engine.installPlugins(opts.plugins);
-        return engine;
+    return service;
+  }
+
+  private addService(service: Service): void {
+    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);
+  }
+
+  removeService(service: Service): void {
+    const index = this.services.indexOf(service);
+    if (index === -1) return;
+    this.services.splice(index, 1);
+    this.unmapAnnotatedSignals(service);
+    service.onPreFixedUpdate && this.onPreFixedUpdateSet.delete(service);
+    service.onFixedUpdate && this.onFixedUpdateSet.delete(service);
+    service.onUpdate && this.onUpdateSet.delete(service);
+    service.onLateUpdate && this.onLateUpdateSet.delete(service);
+    service.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.delete(service);
+    service.onPhysicsUpdate && this.onPhysicsUpdateSet.delete(service);
+    service.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.delete(service);
+    service.onLateFixedUpdate && this.onLateFixedUpdateSet.delete(service);
+    service.onRender && this.onRenderUpdateSet.delete(service);
+    service.onAddEntity && this.onAddEntitySet.delete(service);
+    service.onRemoveEntity && this.onRemoveEntitySet.delete(service);
+    service.onEnd && service.onEnd();
+    const childInjector = this.systemChildInjectors.get(service);
+    if (childInjector) {
+      childInjector.dispose();
+      this.systemChildInjectors.delete(service);
     }
-
-    addService(service: Service): void {
-        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.onLateFixedUpdate && this.onLateFixedUpdateSet.add(service);
-        service.onRender && this.onRenderUpdateSet.add(service);
-        this.services.push(service);
+  }
+
+  installPlugins(plugins: GameEnginePlugin[]) {
+    plugins.forEach(plugin => {
+      plugin.onPrepare && plugin.onPrepare(this);
+    });
+    plugins.forEach(plugin => {
+      plugin.onStart && plugin.onStart(this);
+    });
+  }
+
+  registerSystem(systemClass: Class<System>): void {
+    this.mapStaticAnnotatedSignals(systemClass);
+    if (this._started) throw new Error('Register Systems before engine is started');
+    this.injector.registerSystem(systemClass);
+  }
+
+  registerService(serviceClass: Class<Service>): void {
+    this.mapStaticAnnotatedSignals(serviceClass);
+    if (this._started) throw new Error('Register Services before engine is started');
+    this.injector.map(serviceClass).toSingleton();
+    this.registeredServices.add(serviceClass);
+  }
+
+  getService<T extends Class<Service>>(serviceClass: T): InstanceType<T> {
+    return this.injector.get(serviceClass);
+  }
+
+  start() {
+    this._started = true;
+    //TODO: throw when registering services or systems when engine is running
+    for (const serviceClass of this.registeredServices) {
+      const service = this.injector.get(serviceClass);
+      this.addService(service);
     }
-
-    private installPlugins(plugins: GameEnginePlugin[]) {
-        plugins.forEach(plugin => {
-            plugin.onPrepare && plugin.onPrepare(this);
-        });
-        plugins.forEach(plugin => {
-            plugin.onStart && plugin.onStart(this);
-        });
+    this.clock.start();
+    this.onStart.dispatch();
+  }
+
+  private 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);
+      }
+      this.onFixedUpdate.dispatch(params);
+      for (const system of this.onFixedUpdateSet) {
+        system.onFixedUpdate!(time, deltaTime);
+      }
+      this.onPhysicsUpdate.dispatch(params);
+      for (const system of this.onPhysicsUpdateSet) {
+        system.onPhysicsUpdate!(time, deltaTime);
+      }
+      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++;
+    });
+
+    // TODO: update from outside
+    this.clock.onUpdate.add(onUpdateParams => {
+      const {time, deltaTime, alpha} = onUpdateParams;
+      this.onUpdate.dispatch(onUpdateParams);
+      for (const system of this.onUpdateSet) {
+        system.onUpdate!(time, deltaTime, alpha);
+      }
+      //TODO: merge with framerate to single signal?
+      this.onLateUpdate.dispatch(onUpdateParams);
+      for (const system of this.onLateUpdateSet) {
+        system.onLateUpdate!(time, deltaTime, alpha);
+      }
+      this.onRender.dispatch(onUpdateParams);
+      for (const system of this.onRenderUpdateSet) {
+        system.onRender!(time, deltaTime, alpha);
+      }
+      this._frameCount++;
+    });
+  }
+
+  add(entity: Entity) {
+    return new Promise<void>(resolve => this.addQueue.push([entity, resolve]));
+  }
+
+  addAll(entity: Entity[]) {
+    return Promise.all(entity.map(entity => new Promise<void>(resolve => this.addQueue.push([entity, resolve]))));
+  }
+
+  waitFrame() {
+    return this.framePromise;
+  }
+
+  async remove(entity: Entity) {
+    if ((<any>entity).markRemoval) return;
+    (<any>entity).markRemoval = true;
+    return new Promise<void>(resolve => this.removeQueue.push([entity, resolve]));
+  }
+
+  async removeAll(entities: Entity[]) {
+    return Promise.all(entities.map(entity => this.remove(entity)));
+  }
+
+  stop() {
+    // this.injector.dispose();
+    this.clock.stop();
+  }
+
+  runAction<T extends Action>(action: T): ReturnType<T> {
+    return action(this);
+  }
+
+  getSignal<T>(signalId: ID): Signal<T> {
+    return this.injector.getSignal<T>(signalId);
+  }
+
+  private signalMappings = new Map<Class, [string, Signal][]>();
+  private staticSignalMappings = new Map<Class, [string, Signal][]>();
+  private signalMapBindings = new Map<Object, SignalBinding[]>();
+
+  // TODO: staticSignalMapBindings needed if we want to unregister Services or Systems
+
+  private mapStaticAnnotatedSignals(target: Class) {
+    let staticSignalMap = this.getStaticSignalMap(target);
+    if (staticSignalMap.length === 0) return;
+
+    const bindings = [];
+    for (const [key, signal] of staticSignalMap) {
+      bindings.push(signal.add((<any>target)[key], target));
     }
+    // TODO: ignore bindings for now (store them if we implement unregister Service or Systems
+  }
 
-    registerSystem(systemClass: Class<System>): void {
-        this.mapStaticAnnotatedSignals(systemClass);
-        if (this._started) throw new Error('Register Systems before engine is started');
-        this.injector.registerSystem(systemClass);
-    }
+  private mapAnnotatedSignals(target: Object) {
+    const signalMap = this.getSignalMap(target.constructor);
+    if (signalMap.length === 0) return;
 
-    registerService(serviceClass: Class<Service>): void {
-        this.mapStaticAnnotatedSignals(serviceClass);
-        if (this._started) throw new Error('Register Services before engine is started');
-        this.injector.map(serviceClass).toSingleton();
-        this.serviceClasses.add(serviceClass);
+    const bindings = [];
+    for (const [key, signal] of signalMap) {
+      bindings.push(signal.add((<any>target)[key], target));
     }
-
-    getService<T extends Class<Service>>(serviceClass: T): InstanceType<T> {
-        return this.injector.get(serviceClass);
+    this.signalMapBindings.set(target, bindings);
+  }
+
+  private unmapAnnotatedSignals(target: Object) {
+    const signalBindings = this.signalMapBindings.get(target);
+    if (!signalBindings) return;
+    for (const binding of signalBindings) {
+      binding.detach();
     }
-
-    start() {
-        this._started = true;
-        //TODO: throw when registering services or systems when engine is running
-        for (const serviceClass of this.serviceClasses) {
-            const service = this.injector.get(serviceClass);
-            this.addService(service);
-        }
-        this.clock.start();
-        this.onStart.dispatch();
+  }
+
+  private getSignalMap(target: Function) {
+    // TODO: we could speed thinks up by introducing "invisible" flags on the systems/services to avoid a map check
+    return putIfAbsent(this.signalMappings, target, (): [string, Signal][] => {
+      const handlers = signalHandlers.get(target);
+      if (!handlers) return [];
+      const result: [string, Signal][] = [];
+      for (const [key, signalId] of handlers) {
+        result.push([key, this.getSignal(signalId)]);
+      }
+      return result;
+    });
+  }
+
+  private getStaticSignalMap(target: Class) {
+    // TODO: we could speed thinks up by introducing "invisible" flags on the systems/services to avoid a map check
+    return putIfAbsent(this.staticSignalMappings, target, (): [string, Signal][] => {
+      const handlers = staticSignalHandlers.get(target);
+      if (!handlers) return [];
+      const result: [string, Signal][] = [];
+      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 context of systems) {
+        context.system.onEnd && context.system.onEnd();
+        this.unmapAnnotatedSignals(context.system);
+      }
     }
-
-    private 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.onLateFixedUpdate.dispatch(params);
-            for (const system of this.onLateFixedUpdateSet) {
-                system.onLateFixedUpdate!(time, deltaTime);
-            }
-            this._fixedFrameCount++;
-        });
-
-        // TODO: update from outside
-        this.clock.onUpdate.add(onUpdateParams => {
-            const {time, deltaTime, alpha} = onUpdateParams;
-            for (const system of this.onUpdateSet) {
-                system.onUpdate!(time, deltaTime, alpha);
-            }
-            //TODO: merge with framerate to single signal?
-
-            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: Entity) {
-        return new Promise<void>(resolve => this.addQueue.push([entity, resolve]));
-    }
-
-    waitFrame() {
-        return this.framePromise;
-    }
-
-    async remove(entity: Entity) {
-        if ((<any>entity).markRemoval) return;
-        (<any>entity).markRemoval = true;
-        return new Promise<void>(resolve => this.removeQueue.push([entity, resolve]));
-    }
-
-    stop() {
-        // this.injector.dispose();
-        this.clock.stop();
-    }
-
-    runAction<T extends Action>(action: T): ReturnType<T> {
-        return action(this);
+    for (const service of this.services) {
+      service.onEnd && service.onEnd();
+      this.unmapAnnotatedSignals(service);
     }
-
-    getSignal<T>(signalId: ID): Signal<T> {
-        return this.injector.getSignal<T>(signalId);
-    }
-
-    private signalMappings = new Map<Class, [string, Signal][]>();
-    private staticSignalMappings = new Map<Class, [string, Signal][]>();
-    private signalMapBindings = new Map<Object, SignalBinding[]>();
-
-    // TODO: staticSignalMapBindings needed if we want to unregister Services or Systems
-
-    private mapStaticAnnotatedSignals(target: Class) {
-        let staticSignalMap = this.getStaticSignalMap(target);
-        if (staticSignalMap.length === 0) return;
-
-        const bindings = [];
-        for (const [key, signal] of staticSignalMap) {
-            bindings.push(signal.add((<any>target)[key], target));
+    this.onEnd.dispatch();
+
+    this.onAddEntity.detachAll();
+    this.onRemoveEntity.detachAll();
+    this.onPrepare.detachAll();
+    this.onStart.detachAll();
+    this.onEnd.detachAll();
+    this.onRender.detachAll();
+    this.onUpdate.detachAll();
+    this.onFixedUpdate.detachAll();
+    this.onPrePhysicsUpdate.detachAll();
+    this.onPhysicsUpdate.detachAll();
+    this.onPostPhysicsUpdate.detachAll();
+    this.onLateFixedUpdate.detachAll();
+    this.onPhysicsUpdateSet.clear();
+    this.onPrePhysicsUpdateSet.clear();
+    this.onPostPhysicsUpdateSet.clear();
+    this.onLateFixedUpdateSet.clear();
+    this.onLateUpdate.detachAll();
+    this.onUpdate.detachAll();
+    this.onFixedUpdate.detachAll();
+    this.onRender.detachAll();
+    this.onAddEntity.detachAll();
+    this.onRemoveEntity.detachAll();
+
+  }
+
+  private prepareFrame() {
+    for (const [entity, resolve] of this.removeQueue) {
+      const entities = entity.getAllEntities();
+      for (const entity of entities) {
+        (<any>entity).markRemoval = false;
+        if (!(<any>entity).gameEngine) {
+          console.log('Entity not active', entity);
+          // throw new Error('Entity not active');
         }
-        // TODO: ignore bindings for now (store them if we implement unregister Service or Systems
-    }
-
-    private mapAnnotatedSignals(target: Object) {
-        const signalMap = this.getSignalMap(target.constructor);
-        if (signalMap.length === 0) return;
-
-        const bindings = [];
-        for (const [key, signal] of signalMap) {
-            bindings.push(signal.add((<any>target)[key], target));
+        (<any>entity).gameEngine = undefined;
+
+        const systemContexts = this.entitySystemMap.get(entity);
+        this.entitySystemMap.delete(entity);
+        if (systemContexts) {
+          for (const context of systemContexts) {
+            this.disposeContext(context);
+          }
         }
-        this.signalMapBindings.set(target, bindings);
-    }
+        entity.onRemove.dispatch();
+        entity.onRemove.detachAll();
+        entity._signalMap.forEach(signal => signal.detachAll());
 
-    private unmapAnnotatedSignals(target: Object) {
-        const signalBindings = this.signalMapBindings.get(target);
-        if (!signalBindings) return;
-        for (const binding of signalBindings) {
-            binding.detach();
+        for (const system of this.onRemoveEntitySet) {
+          system.onRemoveEntity!(entity);
         }
-    }
-
-    private getSignalMap(target: Function) {
-        // TODO: we could speed thinks up by introducing "invisible" flags on the systems/services to avoid a map check
-        return putIfAbsent(this.signalMappings, target, (): [string, Signal][] => {
-            const handlers = signalHandlers.get(target);
-            if (!handlers) return [];
-            const result: [string, Signal][] = [];
-            for (const [key, signalId] of handlers) {
-                result.push([key, this.getSignal(signalId)]);
-            }
-            return result;
-        });
-    }
+      }
 
-    private getStaticSignalMap(target: Class) {
-        // TODO: we could speed thinks up by introducing "invisible" flags on the systems/services to avoid a map check
-        return putIfAbsent(this.staticSignalMappings, target, (): [string, Signal][] => {
-            const handlers = staticSignalHandlers.get(target);
-            if (!handlers) return [];
-            const result: [string, Signal][] = [];
-            for (const [key, signalId] of handlers) {
-                result.push([key, this.getSignal(signalId)]);
-            }
-            return result;
-        });
+      resolve();
     }
-
-    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();
+    this.removeQueue = [];
+
+    for (const [entity, resolve] of this.addQueue) {
+      const preparePromises = [];
+      const nextSystemContexts: SystemContext[] = [];
+      const entities = entity.getAllEntities();
+      for (const entity of entities) {
+        if ((<any>entity).gameEngine) throw new Error('Entity already added to a gameEngine');
+        (<any>entity).gameEngine = this;
+        const systemContexts = this.injector.createSystemsForEntity(entity);
+        for (const context of systemContexts) {
+          // TODO: implement synced mode where async onPrepares aren't allowed
+          context.system.onPrepare && preparePromises.push(context.system.onPrepare());
+          nextSystemContexts.push(context);
         }
-    }
+        this.entitySystemMap.set(entity, systemContexts);
+      }
 
-    private prepareFrame() {
-
-        for (const [entity, resolve] of this.removeQueue) {
-            const entities = entity.getAllEntities();
-            for (const entity of entities) {
-                (<any>entity).markRemoval = false;
-                if (!(<any>entity).gameEngine) {
-                    console.log(entity);
-                    // throw new Error('Entity not active');
-                }
-                (<any>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.onLateFixedUpdate && this.onLateFixedUpdateSet.delete(system);
-                        system.onRender && this.onRenderUpdateSet.delete(system);
-                    }
-                }
-                entity.onRemove.dispatch();
-                entity.onRemove.detachAll();
-            }
-
-            resolve();
-        }
-        this.removeQueue = [];
-
-        for (const [entity, resolve] of this.addQueue) {
-            const preparePromises = [];
-            const nexSystemContexts: SystemContext[] = [];
-            const entities = entity.getAllEntities();
-            for (const entity of entities) {
-                if ((<any>entity).gameEngine) throw new Error('Entity already added to a gameEngine');
-                (<any>entity).gameEngine = this;
-                const systemContexts = this.injector.createSystems(entity);
-                for (const context of systemContexts) {
-                    // TODO: implement synced mode where async onPrepares aren't allowed
-                    context.system.onPrepare && preparePromises.push(context.system.onPrepare());
-                    nexSystemContexts.push(context);
-                }
-                this.entitySystemMap.set(entity, systemContexts);
-            }
-
-            const startSystems = () => {
-                // TODO: check if a "global" method is faster than this inner method
-                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.onLateFixedUpdate && this.onLateFixedUpdateSet.add(system);
-                    system.onRender && this.onRenderUpdateSet.add(system);
-                }
-                resolve();
-            };
-
-            // Promise.all doesnt resolve immediately when there are no promises bu
-            if (preparePromises.length === 0) {
-                startSystems();
-            } else {
-                Promise.all(preparePromises).then(startSystems);
-            }
+      const entityWasAdded = () => {
+        for (const system of this.onAddEntitySet) {
+          system.onAddEntity!(entity);
         }
-        this.addQueue = [];
-        // create promise for next frame
-        this.resolveFrame();
-        this.framePromise = new Promise<void>(resolve => {
-            this.resolveFrame = resolve;
-        });
-        this.onPrepare.dispatch();
+        resolve();
+      };
+
+      // Promise.all doesnt resolve immediately when there are no promises bu
+      if (preparePromises.length === 0) {
+        this.startSystems(nextSystemContexts, entityWasAdded);
+      } else {
+        Promise.all(preparePromises).then(() => this.startSystems(nextSystemContexts, entityWasAdded));
+      }
+    }
+    this.addQueue = [];
+    // create promise for next frame
+    this.resolveFrame();
+    this.framePromise = new Promise<void>(resolve => {
+      this.resolveFrame = resolve;
+    });
+    this.onPrepare.dispatch();
+  }
+
+  private startSystems(contexts: Iterable<SystemContext>, then?: () => void) {
+    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?.();
+  };
+
+  getAllEntities(): Entity[] {
+    return Array.from(this.entitySystemMap.keys());
+  }
+
+  removeAllEntities() {
+    return this.removeAll(this.getAllEntities());
+  }
+
+  private disposeContext(context: SystemContext<System>) {
+    const system = context.system;
+
+    // if onEnd returns a promise, we need to wait for it to finish before we can dispose the 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);
+  }
 }
 //
 // type RunSpread<T> = T extends undefined