mani-game-engine 1.0.0-pre.8 → 1.0.0-pre.81

package/src/scope/scopeContext.ts

@@ -1,6 +1,6 @@
 import {Class, EcsInjector, Signal, SignalBinding, SignalCallback} from '../index';
-import {ID, putIfAbsent} from 'mani-injector';
 import {signalHandlers} from '../ecsInjector';
+import {ID, putIfAbsent} from '../injector';
 
 export type ScopeSignalOptions = { keepAlive?: boolean | Scope[], group?: string }
 
@@ -15,6 +15,10 @@ export const OnScopeSignal = (id: ID, options?: ScopeSignalOptions) => (target:
     }
 };
 
+export const SCOPE_CONTEXT = {
+    log: true,
+};
+
 export interface Scope {
     [propName: string]: any; // disable weak type detection
     onEnter?(): void;
@@ -46,11 +50,12 @@ class ScopeSignalBinding {
         this.signalBinding.detach();
     }
 }
-
+// TODO: rename to ScopeStack to something like InternalScopeTreeSingleton with an interface
 class ScopeStack {
     readonly stack: ScopeContext[] = [];
-    queuedScopeChanges: Function[] = [];
+    queuedScopeChanges: (() => Promise<void>)[] = [];
     ongoingChange = false;
+    target?: Scope;
 
     constructor(readonly rootScope: ScopeContext) {
         this.stack.push(rootScope);
@@ -63,21 +68,32 @@ class ScopeStack {
     get activeContext() {
         return this.stack[this.stack.length - 1];
     }
-
 }
 
 export type ScopeMapping = (params: {
     injector: EcsInjector,
     registerScopeService: (serviceClass: Class) => void,
-}) => void
+    onEnter: Signal<ScopeContext>,
+    onExit: Signal<ScopeContext>,
+    onSubReturn: Signal<ScopeContext>,
+    onSubExit: Signal<ScopeContext>,
+    onActivate: Signal<ScopeContext>,
+    onDeactivate: Signal<ScopeContext>,
+
+}) => any | Promise<void>;
 
 interface AddScopeSignalOptions extends ScopeSignalOptions {
     context?: unknown;
 }
 
+export type ScopeChangeParams = {
+    from: ScopeContext;
+    to: ScopeContext;
+}
+
 // TODO: maybe move Signal resolver to Injector and dont use EcsInjector here?
-export class ScopeContext {
-    readonly scope: Scope;
+export class ScopeContext<T extends Class = Class<Scope>> {
+    readonly scope!: InstanceType<T>;
     readonly injector: EcsInjector;
     private readonly stack: ScopeStack; // TODO: naming
     private readonly signalBindings: ScopeSignalBinding[] = [];
@@ -88,41 +104,81 @@ export class ScopeContext {
     private closed = false;
     private muteKeepAliveSignals = false;
 
-    constructor(injector: EcsInjector, scopeClass: Class, mapping?: ScopeMapping, private parent?: ScopeContext) {
+    readonly onEnter = new Signal<ScopeContext>();
+    readonly onExit = new Signal<ScopeContext>();
+    readonly onSubReturn = new Signal<ScopeContext>();
+    readonly onSubExit = new Signal<ScopeContext>();
+    readonly onActivate = new Signal<ScopeContext>();
+    readonly onDeactivate = new Signal<ScopeContext>();
+    private readonly creationTime: DOMHighResTimeStamp;
+    readonly onScopeChange: Signal<ScopeChangeParams>;
+
+    get runtime() {
+        return (performance.now() - this.creationTime) / 1000;
+    }
+
+    constructor(injector: EcsInjector, scopeClass: T, mapping?: ScopeMapping, private parent?: ScopeContext, resolve?: () => void) {
+        this.creationTime = performance.now();
         if (!parent) {
             this.stack = new ScopeStack(this);
+            this.onScopeChange = new Signal<ScopeChangeParams>();
 
         } else {
             this.stack = parent.stack;
+            this.onScopeChange = parent.onScopeChange;
             this.stack.stack.push(this);
         }
 
+        // TODO: disable this for the rootscope?
         this.injector = injector.createChild();
+
         //TODO: i think it would really be better if we implement an injector.injectIntoUnmapped() instead of mapping here
         this.injector.map(scopeClass).toSingleton();
         this.injector.map(ScopeContext).toValue(this);
 
-        mapping?.({
+        const result = mapping?.({
             injector: this.injector,
             registerScopeService: serviceClass => {
                 this.injector.map(serviceClass).toSingleton();
                 this.mapServiceSignals(this.injector.get(serviceClass));
             },
+            onEnter: this.onEnter,
+            onExit: this.onExit,
+            onSubReturn: this.onSubReturn,
+            onSubExit: this.onSubExit,
+            onActivate: this.onActivate,
+            onDeactivate: this.onDeactivate,
         });
 
-        this.scope = this.injector.get(scopeClass) as Scope;
-        this.mapScopeSignals();
-        this.updateSignalBindings();
-        // TODO: maybe the scope needs to prepare resources or something before it can react to signals, so we should move onEnter bevore the signal mapping and make it async (not working in constructor though)
-        this.scope.onEnter?.();
-        this.scope.onActivate?.();
+        const completeScopeChange = () => {
+            (this.scope as Scope) = this.injector.get(scopeClass);
+            this.mapScopeSignals();
+            this.updateSignalBindings();
+            // TODO: maybe the scope needs to prepare resources or something before it can react to signals, so we should move onEnter bevore the signal mapping and make it async (not working in constructor though)
+            this.scope.onEnter?.();
+            this.onEnter.dispatch(this);
+            this.scope.onActivate?.();
+            this.onActivate.dispatch(this);
+            resolve?.();
+        };
+
+        if (result instanceof Promise) {
+            result.then(completeScopeChange);
+        } else {
+            completeScopeChange();
+        }
     }
 
-    get isRoot() {
+    get isRoot(): boolean {
         return this === this.stack.rootScope;
     }
 
-    get isActive() {
+    // TODO: test this
+    get target() {
+        return this.stack.target;
+    }
+
+    get isActive(): boolean {
         return this === this.stack.activeContext;
     }
 
@@ -133,54 +189,63 @@ export class ScopeContext {
      * @param scopeClass
      * @param mapping
      */
-    enterScope(scopeClass: Class, mapping?: ScopeMapping): ScopeContext | undefined {
-        let newContext;
-        const doChange = () => {
-
+    async enterScope(scopeClass: Class, mapping?: ScopeMapping) {
+        let newContext: ScopeContext | undefined;
+        const doChange = async () => {
+            const oldContext = this.activeContext;
             this.activeContext.scope.onSubExit?.();
+            this.activeContext.onSubExit.dispatch(this);
             this.activeContext.scope.onDeactivate?.();
+            this.activeContext.onDeactivate.dispatch(this);
 
-            newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext);
+            await new Promise<void>(resolve => {
+                newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext, resolve);
+            });
 
             this.logStack();
+            this.onScopeChange.dispatch({
+                from: oldContext,
+                to: newContext!,
+            })
             const nextChange = this.stack.queuedScopeChanges.shift();
             if (nextChange) {
-                nextChange();
+                await nextChange();
             } else {
                 this.stack.ongoingChange = false;
             }
         };
-        // TODO: this queued changes arent somewhat experimental
+        // TODO: this queued changes are somewhat experimental
         if (!this.stack.ongoingChange) {
             this.stack.ongoingChange = true;
-            doChange();
+            await doChange();
         } else {
             this.stack.queuedScopeChanges.push(doChange);
         }
-        return newContext;
+        return newContext!;
     }
 
     /**
      * Exits this scope (and all open subscopes=), if a scope class is given. all scopes from the stack are closed until after the scope with the given class
      */
-    exitScope(target?: Scope) {
-        const doChange = () => {
+    async exitScope(target?: Scope) {
+        const doChange = async () => {
             if (this.closed) throw new Error(`Scope already closed`);
             // TODO: check if target is in stack?
-            if (!target) target = this.scope.constructor;
+            this.stack.target = target || this.scope.constructor;
             while (true) {
                 const ctx = this.stack.stack.pop();
                 if (!ctx) {
                     throw new Error('no scope in stack');
                 }
                 ctx!.exitThis();
-                if (ctx!.scope.constructor === target) {
+                if (ctx!.scope.constructor === this.stack.target) {
                     break;
                 }
             }
+            this.stack.target = undefined;
             const nextChange = this.stack.queuedScopeChanges.shift();
             if (nextChange) {
-                nextChange();
+                await nextChange();
             } else {
                 this.stack.ongoingChange = false;
             }
@@ -188,13 +253,14 @@ export class ScopeContext {
         };
         if (!this.stack.ongoingChange) {
             this.stack.ongoingChange = true;
-            doChange();
+            await doChange();
         } else {
             this.stack.queuedScopeChanges.push(doChange);
         }
     }
 
     closeSubScopes() {
+        this.stack.target = this.scope.constructor;
         while (!this.isActive) {
             const ctx = this.stack.stack.pop();
             if (!ctx) {
@@ -202,10 +268,13 @@ export class ScopeContext {
             }
             ctx.exitThis();
         }
+        this.stack.target = undefined;
     }
 
     private logStack() {
-        console.debug('%c' + this.stack.stack.map(c => c.scope.constructor.name).join(' -> '), 'color:yellow');
+        if (SCOPE_CONTEXT.log) {
+            console.debug('%c' + this.stack.stack.map(c => c.scope.constructor.name).join(' -> '), 'color:yellow');
+        }
     }
 
     getStackClasses(): Scope[] {
@@ -213,7 +282,7 @@ export class ScopeContext {
     }
 
     addScopeSignal<T>(signal: Signal<T>, callback: SignalCallback<T>, params?: AddScopeSignalOptions) {
-        const signalBinding = new ScopeSignalBinding(signal.add(callback, params?.context), params);
+        const signalBinding = new ScopeSignalBinding(signal.add(callback, {context:params?.context}), params);
         this.signalBindings.push(signalBinding);
     }
 
@@ -274,7 +343,7 @@ export class ScopeContext {
 
         for (const [field, id] of handlers) {
             const signal = this.injector.getSignal(id);
-            const signalBinding = signal.add((<any>scopeService) [field], scopeService);
+            const signalBinding = signal.add((<any>scopeService) [field], {context:scopeService});
             this.serviceBindings.push(signalBinding);
         }
     }
@@ -292,14 +361,32 @@ export class ScopeContext {
         if (!this.parent) {
             throw new Error('can\'t exit root scope?!');
         }
+
         this.logStack();
         this.detachSignalBindings();
         this.detachServiceBindings();
         this.scope.onDeactivate?.();
+        this.onDeactivate.dispatch(this);
+
         this.scope.onExit?.();
+        this.onExit.dispatch(this);
+        this.onScopeChange.dispatch({from: this, to: this.parent});
+        // this.injector._dispose();
+
         this.parent.updateSignalBindings();
         this.parent.scope.onSubReturn?.();
+        this.parent.onSubReturn.dispatch(this);
+        this.onSubReturn.dispatch(this);
         this.parent.scope.onActivate?.();
+        this.parent.onActivate.dispatch(this);
         this.closed = true;
+
+        this.onEnter.detachAll();
+        this.onExit.detachAll();
+        this.onSubReturn.detachAll();
+        this.onSubExit.detachAll();
+        this.onActivate.detachAll();
+        this.onDeactivate.detachAll();
+
     }
 }

package/src/systemContext.ts

@@ -1,22 +1,58 @@
 import {System} from './types';
-import {Signal, SignalBinding, SignalCallback} from './index';
+import {Entity, GameEngine, ID, putIfAbsent, Signal, SignalBinding, SignalCallback} from './index';
+import {AddSignalOptions} from 'mani-signal/src/signal';
+
+export const entitySignalHandlers = new Map<Object, [string, ID][]>();
+export const OnEntitySignal = (id: ID) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+  if (target instanceof Function) {
+    throw new Error('only allowed on non static methods');
+  } else {
+    const mappingList = putIfAbsent(entitySignalHandlers, target.constructor, (): [string, ID][] => []);
+    mappingList.push([propertyKey, id]);
+  }
+};
 
 export class SystemContext<T extends System = System> {
-    readonly system!: T;
-    private signalBindings: SignalBinding[] = [];
+  readonly system!: T;
+  readonly onDispose = new Signal();
+  private readonly abortController = new AbortController();
+  get abortSignal() {
+    return this.abortController.signal;
+  }
+  private signalBindings = new Set<SignalBinding>();
+
+  constructor(readonly entity: Entity) {
+  }
+
+  // TODO: is this a bit hacky?
+  addSignalById<S>(signalId: string | symbol, callback: SignalCallback<S>, options: AddSignalOptions = {}) {
+    this.signalBindings.add(((this.entity as any).gameEngine as GameEngine).getSignal<S>(signalId).add(callback, options));
+  }
 
-    constructor(readonly entity: Object) {
-    }
+  // returns a function that can be called to remove the signal
+  addSignal<S>(signal: Signal<S>, callback: SignalCallback<S>, options: AddSignalOptions = {}) {
+    const binding = signal.add(callback, options);
+    this.signalBindings.add(binding);
+    return () => {
+      binding.detach();
+      this.signalBindings.delete(binding);
+    };
+  }
 
-    addSignal<S>(signal: Signal<S>, callback: SignalCallback<S>, thisArg?: unknown) {
-        this.signalBindings.push(signal.add(callback, thisArg));
-    }
+  addSignalOnce<S>(signal: Signal<S>, callback: SignalCallback<S>, options: AddSignalOptions = {}) {
+    const binding = signal.addOnce(callback, options);
+    this.signalBindings.add(binding);
+    return () => {
+      binding.detach();
+      this.signalBindings.delete(binding);
+    };
 
-    addSignalOnce<S>(signal: Signal<S>, callback: SignalCallback<S>, thisArg?: unknown) {
-        this.signalBindings.push(signal.addOnce(callback, thisArg));
-    }
+  }
 
-    dispose() {
-        for (const binding of this.signalBindings) binding.detach();
-    }
+  dispose() {
+    this.abortController.abort();
+    for (const binding of this.signalBindings) binding.detach();
+    this.onDispose.dispatch();
+    this.onDispose.detachAll();
+  }
 }

package/src/types.ts

@@ -1,20 +1,23 @@
 import {GameEngine} from './gameEngine';
+import {Entity} from './entity';
 
 export interface System {
     [propName: string]: any;
     onPrepare?(): Promise<void>;
     onStart?(): void;
-    onEnd?(): void;
-    onPreFixedUpdate?(): void;
-    onEarlyUpdate?(time: number, deltaTime: number): void;
+    onEnd?(): void | Promise<void>;
+    onPreFixedUpdate?(time: number, deltaTime: number): void;
     onFixedUpdate?(time: number, deltaTime: number): void;
-    onPrePhysicUpdate?(time: number, deltaTime: number): void;
     onPhysicsUpdate?(time: number, deltaTime: number): void;
     onUpdate?(time: number, deltaTime: number, alpha: number): void;
     onLateUpdate?(time: number, deltaTime: number, alpha: number): void;
+    onPrePhysicsUpdate?(time: number, deltaTime: number): void;
     onPostPhysicsUpdate?(time: number, deltaTime: number): void;
     onLateFixedUpdate?(time: number, deltaTime: number): void;
     onRender?(time: number, deltaTime: number, alpha: number): void;
+    onAddEntity?(entity: Entity): void;
+    onRemoveEntity?(entity: Entity): void;
+    // new(...args: any[]): System;
     // new(): GameSystem;
 }
 
@@ -27,15 +30,17 @@ export interface Service {
     onPrepare?(): Promise<void>;
     onStart?(): void;
     onEnd?(): void;
-    onPreFixedUpdate?(): void;
+    onPreFixedUpdate?(time: number, deltaTime: number): void;
     onPostPhysicsUpdate?(time: number, deltaTime: number): void;
     onLateFixedUpdate?(time: number, deltaTime: number): void;
     onFixedUpdate?(time: number, deltaTime: number): void;
-    onPrePhysicUpdate?(time: number, deltaTime: number): void;
     onPhysicsUpdate?(time: number, deltaTime: number): void;
+    onPrePhysicsUpdate?(time: number, deltaTime: number): void;
     onUpdate?(time: number, deltaTime: number, alpha: number): void;
     onLateUpdate?(time: number, deltaTime: number, alpha: number): void;
-    onRender?(): void;
+    onRender?(time: number, deltaTime: number, alpha: number): void;
+    onAddEntity?(entity: Entity): void;
+    onRemoveEntity?(entity: Entity): void;
     // new(): GameSystem;
 }
 
@@ -74,12 +79,17 @@ export type Class<T = any> = { new(...args: any[]): T; }
 
 export const EngineSignals = {
     OnStart: Symbol('OnStart'),
+    OnEnd: Symbol('OnEnd'),
     OnUpdate: Symbol('OnUpdate'),
     OnLateUpdate: Symbol('OnLateUpdate'),
     OnFixedUpdate: Symbol('OnFixedUpdate'),
-    OnPostPhysics: Symbol('OnPostPhysics'),
-    onLateFixedUpdate: Symbol('OnPrepare'),
+    OnPreFixedUpdate: Symbol('OnPreFixedUpdate'),
+    OnPrePhysicsUpdate: Symbol('OnPrePhysicsUpdate'),
+    OnPhysicsUpdate: Symbol('OnPhysicsUpdate'),
+    OnPostPhysicsUpdate: Symbol('OnPostPhysicsUpdate'),
+    onLateFixedUpdate: Symbol('onLateFixedUpdate'),
     OnRender: Symbol('OnRender'),
     OnPrepare: Symbol('OnPrepare'),
-
+    OnAddEntity: Symbol('OnAddEntity'),
+    OnRemoveEntity: Symbol('OnRemoveEntity'),
 };