mani-game-engine 1.0.0-pre.4 → 1.0.0-pre.40

package/src/scope/scopeContext.ts

@@ -0,0 +1,359 @@
+import {Class, EcsInjector, Signal, SignalBinding, SignalCallback} from '../index';
+import {signalHandlers} from '../ecsInjector';
+import {ID, putIfAbsent} from '../injector';
+
+export type ScopeSignalOptions = { keepAlive?: boolean | Scope[], group?: string }
+
+export const scopeSignalHandlers = new Map<Object, [string, ID, ScopeSignalOptions?][]>();
+
+export const OnScopeSignal = (id: ID, options?: ScopeSignalOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    if (target instanceof Function) {
+        throw new Error('only allowed on non static methods');
+    } else {
+        const mappingList = putIfAbsent(scopeSignalHandlers, target.constructor, (): [string, ID, ScopeSignalOptions?][] => []);
+        mappingList.push([propertyKey, id, options]);
+    }
+};
+
+export const SCOPE_CONTEXT = {
+    log: true,
+};
+
+export interface Scope {
+    [propName: string]: any; // disable weak type detection
+    onEnter?(): void;
+    onExit?(): void;
+    onSubReturn?(): void;
+    onSubExit?(): void;
+    onActivate?(): void;
+    onDeactivate?(): void;
+}
+
+class ScopeSignalBinding {
+    readonly keepAlive?: boolean | Scope[];
+    private group?: string;
+
+    constructor(private signalBinding: SignalBinding, options?: ScopeSignalOptions) {
+        this.keepAlive = options?.keepAlive;
+        this.group = options?.group;
+    }
+
+    activate() {
+        this.signalBinding.setActive(true);
+    }
+
+    deactivate() {
+        this.signalBinding.setActive(false);
+    }
+
+    detach() {
+        this.signalBinding.detach();
+    }
+}
+
+class ScopeStack {
+    readonly stack: ScopeContext[] = [];
+    queuedScopeChanges: Function[] = [];
+    ongoingChange = false;
+    target?: Scope;
+
+    constructor(readonly rootScope: ScopeContext) {
+        this.stack.push(rootScope);
+    }
+
+    get rootContext() {
+        return this.stack[0];
+    }
+
+    get activeContext() {
+        return this.stack[this.stack.length - 1];
+    }
+
+}
+
+export type ScopeMapping = (params: {
+    injector: EcsInjector,
+    registerScopeService: (serviceClass: Class) => void,
+    onEnter: Signal<ScopeContext>,
+    onExit: Signal<ScopeContext>,
+    onSubReturn: Signal<ScopeContext>,
+    onSubExit: Signal<ScopeContext>,
+    onActivate: Signal<ScopeContext>,
+    onDeactivate: Signal<ScopeContext>,
+
+}) => void
+
+interface AddScopeSignalOptions extends ScopeSignalOptions {
+    context?: unknown;
+}
+
+// TODO: maybe move Signal resolver to Injector and dont use EcsInjector here?
+export class ScopeContext {
+    readonly scope: Scope;
+    readonly injector: EcsInjector;
+    private readonly stack: ScopeStack; // TODO: naming
+    private readonly signalBindings: ScopeSignalBinding[] = [];
+
+    // Scope services will be active (signals bounds) in this scope and all sub scopes
+    // when this scope exits, the signals will be unbound
+    private serviceBindings: SignalBinding[] = [];
+    private closed = false;
+    private muteKeepAliveSignals = false;
+
+    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>();
+
+    constructor(injector: EcsInjector, scopeClass: Class, mapping?: ScopeMapping, private parent?: ScopeContext) {
+        if (!parent) {
+            this.stack = new ScopeStack(this);
+
+        } else {
+            this.stack = parent.stack;
+            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?.({
+            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.onEnter.dispatch(this);
+        this.scope.onActivate?.();
+        this.onActivate.dispatch(this);
+    }
+
+    get isRoot() {
+        return this === this.stack.rootScope;
+    }
+
+    // TODO: test this
+    get target() {
+        return this.stack.target;
+    }
+
+    get isActive() {
+        return this === this.stack.activeContext;
+    }
+
+    get activeContext() { return this.stack.activeContext;}
+
+    /**
+     * returns the new scope only if there is currently no ongoing scope change happening
+     * @param scopeClass
+     * @param mapping
+     */
+    enterScope(scopeClass: Class, mapping?: ScopeMapping): ScopeContext | undefined {
+        let newContext;
+        const doChange = () => {
+
+            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);
+
+            this.logStack();
+            const nextChange = this.stack.queuedScopeChanges.shift();
+            if (nextChange) {
+                nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+        };
+        // TODO: this queued changes are somewhat experimental
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            doChange();
+        } else {
+            this.stack.queuedScopeChanges.push(doChange);
+        }
+        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 = () => {
+            if (this.closed) throw new Error(`Scope already closed`);
+            // TODO: check if target is in stack?
+            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 === this.stack.target) {
+                    break;
+                }
+            }
+            this.stack.target = undefined;
+            const nextChange = this.stack.queuedScopeChanges.shift();
+            if (nextChange) {
+                nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+
+        };
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            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) {
+                throw new Error('no scope in stack');
+            }
+            ctx.exitThis();
+        }
+        this.stack.target = undefined;
+    }
+
+    private logStack() {
+        if (SCOPE_CONTEXT.log) {
+            console.debug('%c' + this.stack.stack.map(c => c.scope.constructor.name).join(' -> '), 'color:yellow');
+        }
+    }
+
+    getStackClasses(): Scope[] {
+        return this.stack.stack.map(context => context.scope.constructor);
+    }
+
+    addScopeSignal<T>(signal: Signal<T>, callback: SignalCallback<T>, params?: AddScopeSignalOptions) {
+        const signalBinding = new ScopeSignalBinding(signal.add(callback, params?.context), params);
+        this.signalBindings.push(signalBinding);
+    }
+
+    disableKeepAliveSignals() {
+        this.muteKeepAliveSignals = true;
+        this.updateSignalBindings();
+    }
+
+    enableKeepAliveSignals() {
+        this.muteKeepAliveSignals = false;
+        this.updateSignalBindings();
+    }
+
+    private updateSignalBindings(muteKeepAlive = false) {
+        for (const binding of this.signalBindings) {
+            if (this.isActive) {
+                binding.activate();
+            } else if (muteKeepAlive) {
+                binding.deactivate();
+            } else if (binding.keepAlive === true) {
+                binding.activate();
+            } else if (!!(binding.keepAlive)) {
+                // is array of scopes
+                // OPT: cache active context?
+                if (binding.keepAlive.indexOf(this.activeContext.scope.constructor) != -1) {
+                    binding.activate();
+                } else {
+                    binding.deactivate();
+                }
+            } else {
+                binding.deactivate();
+            }
+        }
+        muteKeepAlive = muteKeepAlive || this.muteKeepAliveSignals;
+        this.parent?.updateSignalBindings(muteKeepAlive);
+    }
+
+    private detachSignalBindings() {
+        for (const signalBinding of this.signalBindings) {
+            signalBinding.detach();
+        }
+    }
+
+    private mapScopeSignals() {
+        const handlers = scopeSignalHandlers.get(this.scope.constructor);
+        if (!handlers) return;
+
+        for (const [field, id, options] of handlers) {
+            const signal = this.injector.getSignal(id);
+            const callback = (<any>this.scope) [field];
+            this.addScopeSignal(signal, callback, {...options, context: this.scope});
+        }
+    }
+
+    private mapServiceSignals(scopeService: Object) {
+        const handlers = signalHandlers.get(scopeService.constructor);
+        if (!handlers) return;
+
+        for (const [field, id] of handlers) {
+            const signal = this.injector.getSignal(id);
+            const signalBinding = signal.add((<any>scopeService) [field], scopeService);
+            this.serviceBindings.push(signalBinding);
+        }
+    }
+
+    private detachServiceBindings() {
+        for (const binding of this.serviceBindings) {
+            binding.detach();
+        }
+        this.serviceBindings = [];
+    }
+
+    private exitThis() {
+
+        // TODO: BUG: when there is a scope change within another scope change there is some confusion about the call order
+        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.parent.updateSignalBindings();
+        this.parent.scope.onSubReturn?.();
+        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

@@ -0,0 +1,38 @@
+import {System} from './types';
+import {Entity, GameEngine, ID, putIfAbsent, Signal, SignalBinding, SignalCallback} from './index';
+
+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[] = [];
+
+    constructor(readonly entity: Entity) {
+    }
+
+    // TODO: is this a bit hacky?
+    addSignalById<S>(signalId: string | symbol, callback: SignalCallback<S>, thisArg?: unknown) {
+        this.signalBindings.push(((this.entity as any).gameEngine as GameEngine).getSignal<S>(signalId).add(callback, thisArg));
+    }
+
+    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>, thisArg?: unknown) {
+        this.signalBindings.push(signal.addOnce(callback, thisArg));
+    }
+
+    dispose() {
+        for (const binding of this.signalBindings) binding.detach();
+
+    }
+}

package/src/types.ts

@@ -1,70 +1,95 @@
-import {GameEngine} from './gameEngine';
-
-export interface System {
-    [propName: string]: any;
-    onPrepare?(): Promise<void>;
-    onStart?(): void;
-    onEnd?(): void;
-    onPreFixedUpdate?(): void;
-    onEarlyUpdate?(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;
-    onPostPhysicsUpdate?(time: number, deltaTime: number): void;
-    onRender?(): void;
-    // new(): GameSystem;
-}
-
-// export interface GameSystemClass {
-//     new(...args: any[]): GameSystem;
-// }
-
-export interface Service {
-    [propName: string]: any; // disable weak type detection
-    onPrepare?(): Promise<void>;
-    onStart?(): void;
-    onEnd?(): void;
-    onPreFixedUpdate?(): void;
-    onPostPhysicsUpdate?(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;
-    onRender?(): void;
-    // new(): GameSystem;
-}
-
-type GameEngineCallback = (gameEngine: GameEngine) => void;
-
-export interface GameEnginePlugin {
-    // systems?: (SystemClass | GameSystemClass)[];
-    // services?: Service[];
-    onPrepare?: GameEngineCallback;
-    onStart?: GameEngineCallback;
-}
-
-export interface CommandClass {
-    name?: string;
-
-    new(...args: any[]): any;
-}
-
-export type OnUpdateParams = {
-    time: number;
-    deltaTime: number;
-    alpha: number;
-};
-
-export type OnFixedUpdateParams = {
-    time: number;
-    deltaTime: number;
-};
-
-
-export type AsyncAction<T = unknown> = (gameEngine: GameEngine) => Promise<T>;
-// export type Action<T = unknown> = (gameEngine: GameEngine) => T;
-export type Action<T=any> = (gameEngine: GameEngine) => T;
-export type Class<T = any> = { new(...args: any[]): T; }
+import {GameEngine} from './gameEngine';
+import {Entity} from './entity';
+
+export interface System {
+    [propName: string]: any;
+    onPrepare?(): Promise<void>;
+    onStart?(): void;
+    onEnd?(): void;
+    onPreFixedUpdate?(time: number, deltaTime: number): void;
+    onFixedUpdate?(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;
+}
+
+// export interface GameSystemClass {
+//     new(...args: any[]): GameSystem;
+// }
+
+export interface Service {
+    [propName: string]: any; // disable weak type detection
+    onPrepare?(): Promise<void>;
+    onStart?(): void;
+    onEnd?(): 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;
+    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?(time: number, deltaTime: number, alpha: number): void;
+    onAddEntity?(entity: Entity): void;
+    onRemoveEntity?(entity: Entity): void;
+    // new(): GameSystem;
+}
+
+type GameEngineCallback = (gameEngine: GameEngine) => void;
+
+export interface GameEnginePlugin {
+    // systems?: (SystemClass | GameSystemClass)[];
+    // services?: Service[];
+    onPrepare?: GameEngineCallback;
+    onStart?: GameEngineCallback;
+}
+
+export interface CommandClass {
+    name?: string;
+
+    new(...args: any[]): any;
+}
+
+export type OnUpdateParams = {
+    time: number;
+    deltaTime: number;
+    alpha: number;
+};
+
+export type OnFixedUpdateParams = {
+    time: number;
+    deltaTime: number;
+};
+
+export type OnEarlyUpdateParams = { time: number, deltaTime: number };
+
+export type AsyncAction<T = unknown> = (gameEngine: GameEngine) => Promise<T>;
+// export type Action<T = unknown> = (gameEngine: GameEngine) => T;
+export type Action<T = any> = (gameEngine: GameEngine) => T;
+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'),
+    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'),
+};

package/src/utils/map2k.ts

@@ -1,52 +1,52 @@
-export class Map2k<K, V> {
-    map = new Map<K, Map<K, V>>();
-
-    set(key1: K, key2: K, value: V) {
-        let first = this.map.get(key1);
-        if(!first) {
-            first = new Map<K, V>();
-            this.map.set(key1, first);
-        }
-        let second = this.map.get(key2);
-        if(!second) {
-            second = new Map<K, V>();
-            this.map.set(key2, second);
-        }
-        first.set(key2, value);
-        second.set(key1, value);
-    }
-
-    // putIfAbsent(key1: K, key2: K, cb: () => V): V {
-    //     let first = this.map.get(key1);
-    //     let value;
-    //     if(!first) {
-    //         first = new Map<K, V>();
-    //         this.map.set(key1, first);
-    //         value = cb();
-    //         first.set(key2, value);
-    //     }
-    // }
-
-    get(key1: K, key2: K): V | undefined {
-        const first = this.map.get(key1);
-        return first && first.get(key2);
-    }
-
-    delete(key1:K, key2:K) {
-        let first = this.map.get(key1);
-        if (first) {
-            first.delete(key2);
-            if (first.size === 0) {
-                this.map.delete(key1)
-            }
-        }
-        let second = this.map.get(key2);
-        if (second) {
-            second.delete(key1);
-            if (second.size === 0) {
-                this.map.delete(key2)
-            }
-        }
-    }
-
-}
+export class Map2k<K, V> {
+    map = new Map<K, Map<K, V>>();
+
+    set(key1: K, key2: K, value: V) {
+        let first = this.map.get(key1);
+        if(!first) {
+            first = new Map<K, V>();
+            this.map.set(key1, first);
+        }
+        let second = this.map.get(key2);
+        if(!second) {
+            second = new Map<K, V>();
+            this.map.set(key2, second);
+        }
+        first.set(key2, value);
+        second.set(key1, value);
+    }
+
+    // putIfAbsent(key1: K, key2: K, cb: () => V): V {
+    //     let first = this.map.get(key1);
+    //     let value;
+    //     if(!first) {
+    //         first = new Map<K, V>();
+    //         this.map.set(key1, first);
+    //         value = cb();
+    //         first.set(key2, value);
+    //     }
+    // }
+
+    get(key1: K, key2: K): V | undefined {
+        const first = this.map.get(key1);
+        return first && first.get(key2);
+    }
+
+    delete(key1:K, key2:K) {
+        let first = this.map.get(key1);
+        if (first) {
+            first.delete(key2);
+            if (first.size === 0) {
+                this.map.delete(key1)
+            }
+        }
+        let second = this.map.get(key2);
+        if (second) {
+            second.delete(key1);
+            if (second.size === 0) {
+                this.map.delete(key2)
+            }
+        }
+    }
+
+}