mani-game-engine 1.0.0-pre.35 → 1.0.0-pre.37

package/src/entity.ts

@@ -1,8 +1,8 @@
 import {GameEngine} from './gameEngine';
 import {Signal} from 'mani-signal';
 import {Class} from './types';
-import {entityComponents} from './ecsInjector';
 import {ID, putIfAbsent} from './injector';
+import {EcsInjector} from './ecsInjector';
 
 let idCounter = 0;
 
@@ -20,6 +20,62 @@ export class Entity {
     private _detached = false;
     private readonly signalMap: Map<ID, Signal> = new Map<ID, Signal>();
 
+    private dynamicComponents = new Map<Class, InstanceType<any>>();
+
+    addDynamicComponent<T extends Class>(component: InstanceType<T>) {
+        if (this.hasDynamicComponentClass(component.constructor)) {
+            throw new Error('component of this class already added');
+        }
+        this.dynamicComponents.set(component.constructor as T, component);
+
+        if (!this.gameEngine) return;
+
+        const systemContexts = this.gameEngine.injector.createSystemsForDynamicComponents(component.constructor, this);
+
+        if (!systemContexts) return;
+        const preparePromises = [];
+        for (const context of systemContexts) {
+            context.system.onPrepare && preparePromises.push(context.system.onPrepare());
+        }
+        for (const context of systemContexts) {
+            this.gameEngine['entitySystemMap'].get(this)?.add(context);
+        }
+
+        if (preparePromises.length === 0) {
+            this.gameEngine['startSystems'](systemContexts, () => {});
+        } else {
+            Promise.all(preparePromises).then(() => this.gameEngine?.['startSystems'](systemContexts));
+        }
+
+    }
+
+    hasDynamicComponentClass<T extends Class>(componentClass: T): boolean {
+        return this.dynamicComponents.has(componentClass);
+    }
+    removeDynamicComponentClass<T extends Class>(componentClass: T) {
+        const systemContexts = this.gameEngine?.['entitySystemMap'].get(this);
+        systemContexts?.forEach(systemContext => {
+            const systemToDependencies = this.gameEngine?.injector['dynamicComponentDependencyMap'];
+            const dependencies = systemToDependencies?.get((systemContext.system as any).constructor);
+            if (!dependencies) return;
+            if (dependencies.some(dependency => dependency.type === componentClass)) {
+                this.gameEngine?.['disposeContext']?.(systemContext);
+                systemContexts?.delete(systemContext);
+            }
+        });
+        if (!this.dynamicComponents.delete(componentClass)) {
+            throw new Error('component not found: ' + JSON.stringify(componentClass));
+        }
+    }
+
+    removeDynamicComponent<T extends Class>(component: InstanceType<T>) {
+        this.removeDynamicComponentClass(component.constructor as T);
+    }
+
+    getDynamicComponent<T extends Class>(componentClass: T): InstanceType<T> | undefined {
+        return this.dynamicComponents.get(componentClass);
+    }
+
     get detached(): boolean { return this._detached; }
 
     constructor() {
@@ -46,7 +102,7 @@ export class Entity {
     }
 
     getComponent<T extends Class>(componentClass: T): InstanceType<T> | undefined {
-        const componentMap = entityComponents.get(this.constructor as Class);
+        const componentMap = EcsInjector.entityComponents.get(this.constructor as Class);
         if (!componentMap) {
             throw new Error(`No components in entity of type '${this.constructor.name}'.`);
         }
@@ -128,4 +184,8 @@ export class Entity {
         }
         return target;
     }
+
+    hasDynamicComponents() {
+        return this.dynamicComponents.size > 0;
+    }
 }

package/src/gameEngine.ts

@@ -17,7 +17,7 @@ const defaultOptions = {
 export type GameEngineOptions = Partial<typeof defaultOptions>;
 declare global {
     interface GameEngineActions {
-        'testAction': string
+        'testAction': string;
     }
 }
 
@@ -50,7 +50,8 @@ export class GameEngine {
     private readonly onLateUpdateSet = new Set<System>();
     private readonly onRenderUpdateSet = new Set<System>();
 
-    private readonly entitySystemMap = new Map<Entity, SystemContext[]>();
+    // TODO: for performance, we could store the systems directly in the entity
+    private readonly entitySystemMap = new Map<Entity, Set<SystemContext>>();
 
     private readonly serviceClasses = new Set<Class<Service>>();
     private readonly services: Service[] = [];
@@ -346,19 +347,7 @@ export class GameEngine {
                 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.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);
+                        this.disposeContext(context);
                     }
                 }
                 entity.onRemove.dispatch();
@@ -370,45 +359,27 @@ export class GameEngine {
         this.removeQueue = [];
 
         for (const [entity, resolve] of this.addQueue) {
+
             const preparePromises = [];
-            const nexSystemContexts: SystemContext[] = [];
+            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.createSystems(entity);
+                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());
-                    nexSystemContexts.push(context);
+                    nextSystemContexts.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.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();
-            };
-
             // Promise.all doesnt resolve immediately when there are no promises bu
             if (preparePromises.length === 0) {
-                startSystems();
+                this.startSystems(nextSystemContexts, resolve);
             } else {
-                Promise.all(preparePromises).then(startSystems);
+                Promise.all(preparePromises).then(() => this.startSystems(nextSystemContexts, resolve));
             }
         }
         this.addQueue = [];
@@ -419,6 +390,40 @@ export class GameEngine {
         });
         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);
+        }
+        then?.();
+    };
+
+    private disposeContext(context: SystemContext<System>) {
+        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.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

package/src/index.ts

@@ -17,7 +17,7 @@ export {
     Scope, SCOPE_CONTEXT, ScopeContext, OnScopeSignal, scopeSignalHandlers, ScopeSignalOptions, ScopeMapping,
 } from './scope/scopeContext';
 export {SystemContext, OnEntitySignal} from './systemContext';
-export {EcsInjector, EntityComponent, GetComponent, GetEntity, GetContext, GetSignal, OnSignal, GetEntitySignal} from './ecsInjector';
+export {EcsInjector, EntityComponent, GetComponent,GetDynamicComponent, GetEntity, GetContext, GetSignal, OnSignal, GetEntitySignal, } from './ecsInjector';
 
 // intellij doesnt auto resolve imports if we just export * from an external dependency
 

package/src/injector.ts

@@ -73,6 +73,7 @@ export const createDependencyAnnotation = (cb: (type: any, index: number, depend
         throw new Error('Could not inject class in itself.');
     }
     const depList = putIfAbsent(Injector.dependencyMap, dependantType, (): Dependency[] => []);
+
     depList.push(cb(type, index, dependantType));
 };
 

package/src/systemContext.ts

@@ -1,5 +1,5 @@
 import {System} from './types';
-import {GameEngine, ID, putIfAbsent, Signal, SignalBinding, SignalCallback} from './index';
+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) => {
@@ -15,7 +15,7 @@ export class SystemContext<T extends System = System> {
     readonly system!: T;
     private signalBindings: SignalBinding[] = [];
 
-    constructor(readonly entity: Object) {
+    constructor(readonly entity: Entity) {
     }
 
     // TODO: is this a bit hacky?
@@ -33,5 +33,6 @@ export class SystemContext<T extends System = System> {
 
     dispose() {
         for (const binding of this.signalBindings) binding.detach();
+
     }
 }

package/src/types.ts

@@ -14,6 +14,7 @@ export interface System {
     onPostPhysicsUpdate?(time: number, deltaTime: number): void;
     onLateFixedUpdate?(time: number, deltaTime: number): void;
     onRender?(time: number, deltaTime: number, alpha: number): void;
+    // new(...args: any[]): System;
     // new(): GameSystem;
 }