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

package/src/entity.ts

@@ -1,116 +1,257 @@
 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;
 
+export type RemoveOptions = { dispose: boolean };
 export class Entity {
 
-    readonly id: number;
-    readonly children = new Set<Entity>();
-    private gameEngine?: GameEngine;
+  readonly children = new Set<Entity>();
+  readonly gameEngine?: GameEngine;
+  readonly onAdd = new Signal();
 
-    // TODO: use single rootEntity class instead of undefined?
-    private _parent?: Entity;
-    readonly parentChanged = new Signal();
-    readonly onRemove = new Signal();
-    private markRemoval = false;
+  get isAdded() {
+    return !!this.gameEngine;
+  }
 
-    constructor() {
-        this.id = idCounter++;
+  // TODO: use single rootEntity class instead of undefined?
+  private _parent?: Entity;
+  readonly parentChanged = new Signal();
+  readonly onRemove = new Signal();
+  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;
+  }
 
-    async onBeforeRemove?(): Promise<void>;
+  private _dynamicComponents = new Map<Class, InstanceType<any>>();
 
-    private setParent(parent: Entity | undefined) {
-        if (parent === this._parent) {
-            //TODO: i think this check can be removed
-            throw Error('same parent');
-        }
-        this._parent = parent;
-        this.parentChanged.dispatch();
+  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');
+    }
+    if (!this.gameEngine) {
+      this._dynamicComponents.set(component.constructor as T, component);
+      this.dynamicComponentAdded.dispatch(component);
+      return this;
     }
 
-    get parent(): Entity | undefined {
-        return this._parent;
+    this.gameEngine.maybeDefer(() => {
+      this._dynamicComponents.set(component.constructor as T, component);
+      this.dynamicComponentAdded.dispatch(component);
+      // it could be that we are within the system creation loop (component is added within a constructor of a system)
+      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);
+        // (this.gameEngine as any).addSystemContextSetToMap(this, systemContexts);
+      }
+
+      if (preparePromises.length === 0) {
+        this.gameEngine!['startSystems'](systemContexts, () => {});
+      } else {
+        Promise.all(preparePromises).then(() => this.gameEngine?.['startSystems'](systemContexts));
+      }
+    });
+    return this;
+  }
+
+  hasDynamicComponentClass<T extends Class>(componentClass: T): boolean {
+    return this._dynamicComponents.has(componentClass);
+  }
+
+  // TODO: move the logic to gameEngine?
+  removeDynamicComponentClass<T extends Class>(componentClass: T) {
+    if (!this.gameEngine) {
+      if (!this._dynamicComponents.has(componentClass)) {
+        throw new Error('component not found: ' + JSON.stringify(componentClass));
+      }
+      this._dynamicComponents.delete(componentClass);
+      this.dynamicComponentRemoved.dispatch(this._dynamicComponents.get(componentClass)!);
+      return;
     }
 
-    getComponent<T extends Class>(componentClass: T): InstanceType<T> | undefined {
-        const componentMap = entityComponents.get(this.constructor as Class);
-        if (!componentMap) {
-            throw new Error(`No components in entity of type '${this.constructor.name}'.`);
+    this.gameEngine.maybeDefer(() => {
+        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));
         }
-        const key = componentMap.get(componentClass as T);
-        return key && (<any>this)[key];
+        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;
+  }
 
-    async add(entity: Entity) {
-        if (entity.parent === this) {
-            throw new Error('Entity is already a child');
-        }
-        if (entity === this) {
-            throw new Error('Could not add Entity as a child of itself.');
-        }
+  get detached(): boolean { return this._detached; }
 
-        if (entity.parent) {
-            entity.parent.children.delete(entity);
-        }
-        this.children.add(entity);
-        entity.setParent(this);
-
-        if (entity.gameEngine) {
-            if (this.gameEngine !== entity.gameEngine) {
-                throw new Error('cant add an active to a passive entity');
-            }
-        } else {
-            if (this.gameEngine) {
-
-                await this.gameEngine.add(entity);
-            }
-        }
+  async onBeforeRemove?(): Promise<void>;
 
-        // TODO: systems should be informed so they can do stuff (renderer system should add object 3d etc...)
+  getSignal<T>(id: ID): Signal<T> {
+    return putIfAbsent(this._signalMap, id, () => new Signal<any>());
+  }
 
-        if (this.gameEngine && this.gameEngine !== entity.gameEngine) {
+  private setParent(parent: Entity | undefined) {
+    if (parent === this._parent) {
+      //TODO: i think this check can be removed
+      throw Error('same parent');
+    }
+    this._parent = parent;
+    this.parentChanged.dispatch();
+  }
 
-        }
+  get parent(): Entity | undefined {
+    return this._parent;
+  }
+
+  getComponent<T extends Class>(componentClass: T): InstanceType<T> | undefined {
+    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);
+    return key && (<any>this)[key];
+  }
 
-    async remove(entity: Entity) {
-        if (!this.children.delete(entity)) {
-            throw new Error('Could not remove. Entity is not a child.');
-        }
-        entity.setParent(undefined);
-        if (this.gameEngine) {
-            return await this.gameEngine.remove(entity);
-        }
+  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 detach() {
-        if (this.parent) {
-            await this.parent.remove(this);
-        } else {
-            if (!this.gameEngine) {
-                throw new Error('entity isn\'t attached to a parent or the game engine');
-            }
-            await this.gameEngine.remove(this);
-        }
+  async add(entity: Entity) {
+    if (entity.parent === this) {
+      throw new Error('Entity is already a child');
+    }
+    if (entity === this) {
+      throw new Error('Could not add Entity as a child of itself.');
     }
 
-    has(entity: Entity) {
-        return this.children.has(entity);
+    if (entity.parent) {
+      entity.parent.children.delete(entity);
     }
+    this.children.add(entity);
+    entity.setParent(this);
 
-    /**
-     * this includes the entity itself
-     * @param target
-     */
-    getAllEntities(target: Entity[] = []) {
-        target.push(this);
-        for (const child of this.children) {
-            child.getAllEntities(target);
-        }
-        return target;
+    if (entity.gameEngine) {
+      if (this.gameEngine !== entity.gameEngine) {
+        throw new Error('cant add an active to a passive entity');
+      }
+    } else {
+      if (this.gameEngine) {
+
+        await this.gameEngine.add(entity);
+      }
+    }
+
+    // TODO: systems should be informed so they can do stuff (renderer system should add object 3d etc...)
+
+    if (this.gameEngine && this.gameEngine !== entity.gameEngine) {
+
+    }
+  }
+
+  async remove(entity: Entity, options?: RemoveOptions) {
+    if (!this.children.delete(entity)) {
+      throw new Error('Could not remove. Entity is not a child.');
+    }
+    entity.setParent(undefined);
+    if (this.gameEngine) {
+      return await this.gameEngine.remove(entity, options);
+    }
+    entity._signalMap.forEach(signal => signal.detachAll());
+  }
+
+  dispose() {
+    this._signalMap.forEach(signal => signal.detachAll());
+  }
+
+  async detach(options?: RemoveOptions) {
+    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, options);
+    } else {
+      if (!this.gameEngine) {
+        throw new Error('entity isn\'t attached to a parent or the game engine');
+      }
+      await this.gameEngine.remove(this, options);
+    }
+  }
+
+  has(entity: Entity) {
+    return this.children.has(entity);
+  }
+
+  /**
+   * this includes the entity itself
+   * @param target
+   */
+  getAllEntities(target: Entity[] = []) {
+    target.push(this);
+    for (const child of this.children) {
+      child.getAllEntities(target);
+    }
+    return target;
+  }
+
+  hasDynamicComponents() {
+    return this._dynamicComponents.size > 0;
+  }
 }