mani-game-engine 1.0.0-pre.3 → 1.0.0-pre.30

package/src/gameEngine.ts

@@ -1,16 +1,16 @@
-import {Action, Class, GameEnginePlugin, GameService, GameSystem, OnUpdateParams} from './types';
+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} from './ecsInjector';
-import {Clock} from './clock';
+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];
+type AddEntry = [Entity, () => void];
+type RemoveEntry = [Entity, () => void];
 
 const defaultOptions = {
     fixedDeltaTime: 1 / 60,
-    autoStart: true,
     plugins: [] as GameEnginePlugin[],
 };
 
@@ -25,55 +25,151 @@ type GameEngineActionParams<K extends keyof GameEngineActions> = GameEngineActio
 type GameAction<K extends keyof GameEngineActions> = (engine: GameEngine, params: GameEngineActionParams<K>) => Promise<any> | any;
 
 export class GameEngine {
-    readonly onRender = new Signal();
-    readonly onUpdate = new Signal<OnUpdateParams>();
 
-    private readonly onEarlyUpdateSet = new Set<GameSystem>();
-    private readonly onUpdateSet = new Set<GameSystem>();
-    private readonly onFixedUpdateSet = new Set<GameSystem>();
-    private readonly onPreFixedUpdateSet = new Set<GameSystem>();
-    private readonly onPhysicsUpdateSet = new Set<GameSystem>();
-    private readonly onPostPhysicsUpdateSet = new Set<GameSystem>();
-    private readonly onLateUpdateSet = new Set<GameSystem>();
-    private readonly onRenderUpdateSet = new Set<GameSystem>();
-
-    private readonly entitySystemMap = new Map<Object, GameSystem[]>();
+    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>;
+
+    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 entitySystemMap = new Map<Entity, SystemContext[]>();
+
+    private readonly serviceClasses = new Set<Class<Service>>();
+    private readonly services: Service[] = [];
 
     private framePromise!: Promise<any>;
     private resolveFrame: () => void = () => undefined;
 
+    private addQueue: AddEntry[] = [];
+    private removeQueue: RemoveEntry[] = [];
+
+    private _started = false;
+
+    get started(): boolean { return this._started; }
+
     private _frameCount = 0;
+    get frameCount(): number { return this._frameCount; }
 
-    get frameCount(): number {
-        return this._frameCount;
-    }
+    private _fixedFrameCount = 0;
+    get fixedFrameCount(): number { return this._fixedFrameCount; }
 
-    get numEntities(): number {
-        return 0;
-    }
+    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.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.setupClock();
+        this.prepareFrame();
+    }
+
     static createDefault(options?: GameEngineOptions) {
         const opts = {...defaultOptions, ...options};
-        const clock = new Clock({
+        const clock = new GameClock({
             fixedDeltaTime: opts.fixedDeltaTime,
-            autoStart: opts.autoStart
+            autoStart: false,
         });
-        const injector = new EcsInjector<Class<GameSystem>>();
+        const injector = new EcsInjector<Class<System>>();
         const engine = new GameEngine(injector, clock);
         engine.installPlugins(opts.plugins);
         return engine;
     }
 
-    constructor(
-        readonly injector: EcsInjector<Class<GameSystem>>,
-        readonly clock: Clock,
-    ) {
-        this.injector.map(GameEngine).toValue(this);
-        this.setupClock();
-        this.prepareFrame();
+    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;
+    }
+
+    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);
+        this.services.push(service);
+    }
+
+    private 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.serviceClasses.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.serviceClasses) {
+            const service = this.injector.get(serviceClass);
+            this.addService(service);
+        }
+        this.clock.start();
+        this.onStart.dispatch();
     }
 
     private setupClock() {
@@ -85,143 +181,223 @@ export class GameEngine {
             }
         });
 
-        this.clock.onFixedUpdate.add(({time, deltaTime}) => {
+        this.clock.onFixedUpdate.add((params) => {
+            const {time, deltaTime} = params;
             for (const system of this.onPreFixedUpdateSet) {
-                system.onPreFixedUpdate!();
+                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(({time, deltaTime, alpha}) => {
+        // 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);
             }
-            //TODO: merge with framerate to single signal?
-            this.onUpdate.dispatch({time, deltaTime, alpha});
-            //
-            // const drawTime = 1 / 30;
-            // while (performance.now() < ts + drawTime * 1000) {
-            //
-            // }
+            this.onLateUpdate.dispatch(onUpdateParams);
+
             for (const system of this.onRenderUpdateSet) {
-                system.onRender!();
+                system.onRender!(time, deltaTime, alpha);
             }
-            this.onRender.dispatch();
+            this.onRender.dispatch(onUpdateParams);
             this._frameCount++;
         });
     }
 
-    private installPlugins(plugins: GameEnginePlugin[]) {
-        plugins.forEach(plugin => {
-            plugin.onPrepare && plugin.onPrepare(this);
-        });
-        plugins.forEach(plugin => {
-            plugin.onStart && plugin.onStart(this);
-        });
+    add(entity: Entity) {
+        return new Promise<void>(resolve => this.addQueue.push([entity, resolve]));
     }
 
-    registerSystem(systemClass: Class<GameSystem>): void {
-        this.injector.registerSystem(systemClass);
+    waitFrame() {
+        return this.framePromise;
     }
 
-    addService(service: GameService): 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.onRender && this.onRenderUpdateSet.add(service);
+    async remove(entity: Entity) {
+        if ((<any>entity).markRemoval) return;
+        (<any>entity).markRemoval = true;
+        return new Promise<void>(resolve => this.removeQueue.push([entity, resolve]));
     }
 
-    private addQueue: AddEntry[] = [];
-    private removeQueue: RemoveEntry[] = [];
+    stop() {
+        // this.injector.dispose();
+        this.clock.stop();
+    }
 
-    addEntity(entity: Entity) {
-        return new Promise(resolve => this.addQueue.push([entity.getAllChildren(), resolve]));
+    runAction<T extends Action>(action: T): ReturnType<T> {
+        return action(this);
     }
 
-    waitFrame() {
-        return this.framePromise;
+    getSignal<T>(signalId: ID): Signal<T> {
+        return this.injector.getSignal<T>(signalId);
     }
 
-    async removeEntity(entity: Entity) {
-        if ((<any>entity).markRemoval) return;
-        (<any>entity).markRemoval = true;
-        return new Promise(resolve => this.removeQueue.push([entity.getAllChildren(), resolve]));
+    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
     }
 
-    private prepareFrame() {
+    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));
+        }
+        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();
+        }
+    }
+
+    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;
+        });
+    }
 
-        for (const [entities, resolve] of this.removeQueue) {
+    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();
+    }
+
+    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) throw new Error('Entity not active');
+                if (!(<any>entity).gameEngine) {
+                    console.log(entity);
+                    // throw new Error('Entity not active');
+                }
                 (<any>entity).gameEngine = undefined;
 
-                const systems = this.entitySystemMap.get(entity);
+                const systemContexts = this.entitySystemMap.get(entity);
                 this.entitySystemMap.delete(entity);
-                if (systems) {
-                    for (const system of systems) {
+                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.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.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 [entities, resolve] of this.addQueue) {
+        for (const [entity, resolve] of this.addQueue) {
             const preparePromises = [];
-            const newSystems: GameSystem[] = [];
+            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 systems = this.injector.createSystems(entity);
-                for (const system of systems) {
-                    system.onPrepare && preparePromises.push(system.onPrepare());
-                    newSystems.push(system);
+                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, systems);
+                this.entitySystemMap.set(entity, systemContexts);
             }
 
             const startSystems = () => {
                 // TODO: check if a "global" method is faster than this inner method
-                for (const system of newSystems) {
+                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.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.add(system);
                     system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(system);
+                    system.onLateFixedUpdate && this.onLateFixedUpdateSet.add(system);
                     system.onRender && this.onRenderUpdateSet.add(system);
                 }
                 resolve();
@@ -237,52 +413,10 @@ export class GameEngine {
         this.addQueue = [];
         // create promise for next frame
         this.resolveFrame();
-        this.framePromise = new Promise<any>(resolve => {
+        this.framePromise = new Promise<void>(resolve => {
             this.resolveFrame = resolve;
         });
-    }
-
-    runAction<T extends Action>(action: T): ReturnType<T> {
-        return action(this);
-    }
-
-    getSignal<T>(signalId: ID): Signal<T> {
-        return this.injector.getSignal<T>(signalId);
-    }
-
-    signalMappings = new Map<Class, [string, Signal][]>();
-    signalMapBindings = new Map<Object, SignalBinding[]>();
-
-    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));
-        }
-        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();
-        }
-    }
-
-    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;
-        });
+        this.onPrepare.dispatch();
     }
 }
 //

package/src/index.ts

@@ -1,9 +1,18 @@
 export * from './gameEngine';
 export * from './entity';
 export * from './types';
-export {EcsInjector, EntityComponent, GetComponent, GetEntity} from './ecsInjector';
+export * from './scope/scopeContext';
+export * from './systemContext';
+export {EcsInjector, EntityComponent, GetComponent, GetEntity, GetContext, GetSignal, OnSignal} from './ecsInjector';
 
 // intellij doesnt auto resolve imports if we just export * from an external dependency
-import {Inject, InjectId, Injector, InjectType} from 'mani-injector';
 
-export {Injector, InjectType, InjectId, Inject};
+import {ID, Inject, InjectId, Injector, InjectType, putIfAbsent} from './injector';
+import {Signal, SignalBinding, SignalCallback} from 'mani-signal';
+import {Clock} from './clock';
+
+export {Injector, InjectType, InjectId, Inject, putIfAbsent, ID};
+
+export {Clock};
+
+export {Signal, SignalBinding, SignalCallback};