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

package/src/entity.ts

@@ -1,28 +1,126 @@
 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';
+import {entitySignalHandlers} from './systemContext';
 
 let idCounter = 0;
 
 export class Entity {
 
-    readonly id: number;
     readonly children = new Set<Entity>();
-    private gameEngine?: GameEngine;
+    readonly gameEngine?: GameEngine;
+
+    get isAdded() {
+        return !!this.gameEngine;
+    }
 
     // TODO: use single rootEntity class instead of undefined?
     private _parent?: Entity;
     readonly parentChanged = new Signal();
     readonly onRemove = new Signal();
     private markRemoval = false;
+    private _detached = false;
+    readonly _signalMap: Map<ID, Signal> = new Map<ID, Signal>();
+
+    // this is filled by the injector
+    private _components?: Map<Class, InstanceType<any>>;
+    get components(): ReadonlyMap<Class, InstanceType<any>> {
+        if (!this._components) {
+            this._components = new Map<Class, InstanceType<any>>();
+            EcsInjector.entityComponents.get(this.constructor as Class)!.forEach((field, componentClass) =>
+                this._components!.set(componentClass, (this as any)[field]));
+        }
+        return this._components;
+    }
+
+
+    private _dynamicComponents = new Map<Class, InstanceType<any>>();
+
+    readonly dynamicComponentAdded = new Signal<InstanceType<any>>();
+    readonly dynamicComponentRemoved = new Signal<InstanceType<any>>();
+
+    get dynamicComponents(): ReadonlyMap<Class, InstanceType<any>> {
+        return this._dynamicComponents;
+    }
+
+    // TODO: move the logic to gameEngine?
+    addDynamicComponent<T extends Class>(component: InstanceType<T>):this {
+        if (this.hasDynamicComponentClass(component.constructor)) {
+            throw new Error('component of this class already added');
+        }
+        this._dynamicComponents.set(component.constructor as T, component);
+
+        this.dynamicComponentAdded.dispatch(component);
+        if (!this.gameEngine) return this;
+
+        const systemContexts = this.gameEngine.injector.createSystemsForDynamicComponents(component.constructor, this);
+
+        if (!systemContexts) return this;
+        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));
+        }
+        return this;
+    }
 
-    constructor() {
-        this.id = idCounter++;
+    hasDynamicComponentClass<T extends Class>(componentClass: T): boolean {
+        return this._dynamicComponents.has(componentClass);
     }
 
+    // TODO: move the logic to gameEngine?
+    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);
+            }
+        });
+        const component = this._dynamicComponents.get(componentClass);
+        if (!this._dynamicComponents.delete(componentClass)) {
+            throw new Error('component not found: ' + JSON.stringify(componentClass));
+        }
+        this.dynamicComponentRemoved.dispatch(component);
+    }
+
+    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);
+    }
+
+    getDynamicComponentOrThrow<T extends Class>(componentClass: T): InstanceType<T> {
+        const component = this._dynamicComponents.get(componentClass);
+        if (!component) {
+            throw new Error(`DynamicComponent '${componentClass.name}' not found in entity of type '${this.constructor.name}'.`);
+        }
+        return component;
+    }
+
+    get detached(): boolean { return this._detached; }
+
     async onBeforeRemove?(): Promise<void>;
 
+    getSignal<T>(id: ID): Signal<T> {
+        return putIfAbsent(this._signalMap, id, () => new Signal<any>());
+    }
+
     private setParent(parent: Entity | undefined) {
         if (parent === this._parent) {
             //TODO: i think this check can be removed
@@ -37,7 +135,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}'.`);
         }
@@ -45,6 +143,18 @@ export class Entity {
         return key && (<any>this)[key];
     }
 
+  getComponentOrThrow<T extends Class>(componentClass: T): InstanceType<T> {
+      const componentMap = EcsInjector.entityComponents.get(this.constructor as Class);
+      if (!componentMap) {
+        throw new Error(`No components in entity of type '${this.constructor.name}'.`);
+      }
+      const key = componentMap.get(componentClass as T);
+      if (!key) {
+        throw new Error(`Component '${componentClass.name}' not found in entity of type '${this.constructor.name}'.`);
+      }
+      return (<any>this)[key];
+    }
+
     async add(entity: Entity) {
         if (entity.parent === this) {
             throw new Error('Entity is already a child');
@@ -85,9 +195,15 @@ export class Entity {
         if (this.gameEngine) {
             return await this.gameEngine.remove(entity);
         }
+        entity._signalMap.forEach(signal => signal.detachAll());
     }
 
     async detach() {
+        if (this._detached) {
+            throw new Error('entity already detached');
+        }
+        this._detached = true;
+        // TODO: mark for detach and prevent another call, because this.gameEngine is set to undefined until next frame
         if (this.parent) {
             await this.parent.remove(this);
         } else {
@@ -113,4 +229,8 @@ export class Entity {
         }
         return target;
     }
+
+    hasDynamicComponents() {
+        return this._dynamicComponents.size > 0;
+    }
 }