mani-game-engine 1.0.0-pre.34 → 1.0.0-pre.36

package/src/entity.ts

@@ -1,123 +1,131 @@
-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;
-    private _detached = false;
-    get detached(): boolean { return this._detached; }
-
-    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._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;
-    }
-}
+import {GameEngine} from './gameEngine';
+import {Signal} from 'mani-signal';
+import {Class} from './types';
+import {entityComponents} from './ecsInjector';
+import {ID, putIfAbsent} from './injector';
+
+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;
+    private _detached = false;
+    private readonly signalMap: Map<ID, Signal> = new Map<ID, Signal>();
+
+    get detached(): boolean { return this._detached; }
+
+    constructor() {
+        this.id = idCounter++;
+    }
+
+    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 = 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;
+    }
+}