mani-game-engine 1.0.0-pre.1 → 1.0.0-pre.100

package/src/scope/scopeContext.ts

@@ -0,0 +1,392 @@
+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();
+    }
+}
+// TODO: rename to ScopeStack to something like InternalScopeTreeSingleton with an interface
+class ScopeStack {
+    readonly stack: ScopeContext[] = [];
+    queuedScopeChanges: (() => Promise<void>)[] = [];
+    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>,
+
+}) => 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<T extends Class = Class<Scope>> {
+    readonly scope!: InstanceType<T>;
+    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>();
+    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);
+
+        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,
+        });
+
+        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(): boolean {
+        return this === this.stack.rootScope;
+    }
+
+    // TODO: test this
+    get target() {
+        return this.stack.target;
+    }
+
+    get isActive(): boolean {
+        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
+     */
+    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);
+
+            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) {
+                await nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+        };
+        // TODO: this queued changes are somewhat experimental
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            await 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
+     */
+    async exitScope(target?: Scope) {
+        const doChange = async () => {
+            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) {
+                await nextChange();
+            } else {
+                this.stack.ongoingChange = false;
+            }
+
+        };
+        if (!this.stack.ongoingChange) {
+            this.stack.ongoingChange = true;
+            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) {
+                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, {context: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], {context: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.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

@@ -0,0 +1,58 @@
+import {System} from './types';
+import {Entity, GameEngine, ID, putIfAbsent, Signal, SignalBinding, SignalCallback} from './index';
+import {AddSignalOptions} from 'mani-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;
+  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));
+  }
+
+  // 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);
+    };
+  }
+
+  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);
+    };
+
+  }
+
+  dispose() {
+    this.abortController.abort();
+    for (const binding of this.signalBindings) binding.detach();
+    this.onDispose.dispatch();
+    this.onDispose.detachAll();
+  }
+}

package/src/types.ts

@@ -0,0 +1,95 @@
+import {GameEngine} from './gameEngine';
+import {Entity} from './entity';
+
+export interface System {
+    [propName: string]: any;
+    onPrepare?(): Promise<void>;
+    onStart?(): void;
+    onEnd?(): void | Promise<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'),
+    OnLateFixedUpdate: Symbol('OnLateFixedUpdate'),
+    OnPreFixedUpdate: Symbol('OnPreFixedUpdate'),
+    OnPrePhysicsUpdate: Symbol('OnPrePhysicsUpdate'),
+    OnPhysicsUpdate: Symbol('OnPhysicsUpdate'),
+    OnPostPhysicsUpdate: Symbol('OnPostPhysicsUpdate'),
+    OnRender: Symbol('OnRender'),
+    OnPrepare: Symbol('OnPrepare'),
+    OnAddEntity: Symbol('OnAddEntity'),
+    OnRemoveEntity: Symbol('OnRemoveEntity'),
+};

package/src/utils/map2k.ts

@@ -0,0 +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)
+            }
+        }
+    }
+
+}

package/clockService.d.ts

@@ -1,12 +0,0 @@
-import { Space } from 'mani-ecs-test/space';
-export interface Updatable {
-    update(time: number, deltaTime: number): void;
-}
-export declare class ClockService {
-    private frameLoop;
-    private updateTime;
-    constructor(space: Space);
-    timeScale: number;
-    start(): void;
-    stop(): void;
-}

package/clockService.js

@@ -1,30 +0,0 @@
-import { FrameLoop } from 'mani-frameloop/frameLoop';
-export class ClockService {
-    constructor(space) {
-        this.updateTime = 0;
-        this.frameLoop = new FrameLoop(1 / 60, () => {
-            space.prepareFrame();
-        }, (time, deltaTime) => {
-            space.preFixedUpdate();
-            space.fixedUpdate(time, deltaTime);
-            space.prePhysicUpdate(time, deltaTime);
-            space.postPhysicUpdate(time, deltaTime);
-        }, (time, deltaTime, alpha) => {
-            space.update(time, deltaTime, alpha);
-            space.lateUpdate(time, deltaTime, alpha);
-        });
-        this.start();
-    }
-    get timeScale() {
-        return this.frameLoop.timeScale;
-    }
-    set timeScale(value) {
-        this.frameLoop.timeScale = value;
-    }
-    start() {
-        this.frameLoop.start();
-    }
-    stop() {
-        this.frameLoop.stop();
-    }
-}