mani-game-engine 1.0.0-pre.5 → 1.0.0-pre.50

package/src/entity.ts

@@ -1,116 +1,202 @@
-import {GameEngine} from './gameEngine';
-import {Signal} from 'mani-signal';
-import {Class} from './types';
-import {entityComponents} from './ecsInjector';
-
-let idCounter = 0;
-
-export class Entity {
-
-    readonly id: number;
-    readonly children = new Set<Entity>();
-    private gameEngine?: GameEngine;
-
-    // TODO: use single rootEntity class instead of undefined?
-    private _parent?: Entity;
-    readonly parentChanged = new Signal();
-    readonly onRemove = new Signal();
-    private markRemoval = false;
-
-    constructor() {
-        this.id = idCounter++;
-    }
-
-    async onBeforeRemove?(): Promise<void>;
-
-    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 = 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 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.');
-        }
-
-        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);
-            }
-        }
-
-        // 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) {
-        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);
-        }
-    }
-
-    async detach() {
-        if (this.parent) {
-            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);
-        }
-    }
-
-    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;
-    }
-}
+import {GameEngine} from './gameEngine';
+import {Signal} from 'mani-signal';
+import {Class} from './types';
+import {ID, putIfAbsent} from './injector';
+import {EcsInjector} from './ecsInjector';
+
+let idCounter = 0;
+
+export class Entity {
+
+    readonly children = new Set<Entity>();
+    private 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;
+    private readonly signalMap: Map<ID, Signal> = new Map<ID, Signal>();
+
+    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>) {
+        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;
+
+        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);
+    }
+
+    // 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);
+    }
+
+    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
+            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 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.');
+        }
+
+        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);
+            }
+        }
+
+        // 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) {
+        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);
+        }
+        this.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 {
+            if (!this.gameEngine) {
+                throw new Error('entity isn\'t attached to a parent or the game engine');
+            }
+            await this.gameEngine.remove(this);
+        }
+    }
+
+    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;
+    }
+}