mani-game-engine 1.0.0-pre.3 → 1.0.0-pre.30

package/src/ecsInjector.ts

@@ -1,6 +1,7 @@
 // TODO: what if systems for entity without components are created?
-import {Class, createDependencyAnnotation, Dependency, ID, Injector, putIfAbsent, ResolverContext, ResolverFunction} from 'mani-injector';
 import {Signal} from 'mani-signal';
+import {Class, createDependencyAnnotation, Dependency, ID, Injector, putIfAbsent, ResolverContext, ResolverFunction} from './injector';
+import {SystemContext} from './systemContext';
 
 type ComponentClass = Class;
 type EntityClass = Class;
@@ -8,6 +9,7 @@ type EntityClass = Class;
 type SystemResolvers<T extends Class> = [T, ResolverFunction[]]
 type ComponentDependency = Dependency & { kind: 'component'; index: number; type: Class; };
 type EntityDependency = Dependency & { kind: 'entity'; index: number; };
+type ContextDependency = Dependency & { kind: 'context'; index: number; };
 type SignalDependency = Dependency & { kind: 'signal'; index: number; id: ID; };
 
 type EntityResolverContext = ResolverContext & { entityClass: Object; };
@@ -16,6 +18,7 @@ export const entityComponents = new Map<EntityClass, Map<ComponentClass, string>
 
 export const GetComponent = createDependencyAnnotation((type, index): ComponentDependency => ({kind: 'component', type, index}));
 export const GetEntity = createDependencyAnnotation((_type, index): EntityDependency => ({kind: 'entity', index}));
+export const GetContext = createDependencyAnnotation((_type, index): ContextDependency => ({kind: 'context', index}));
 export const GetSignal = (id: ID) => createDependencyAnnotation((_type, index): SignalDependency => ({kind: 'signal', index, id}));
 export const EntityComponent = (target: object, propertyKey: string): any => {
     const entityClass = target.constructor;
@@ -28,12 +31,15 @@ export const EntityComponent = (target: object, propertyKey: string): any => {
 };
 
 export const signalHandlers = new Map<Object, [string, ID][]>();
+export const staticSignalHandlers = new Map<Object, [string, ID][]>();
 export const OnSignal = (id: ID) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
     if (target instanceof Function) {
-        throw new Error('@OnSignal annotation only allowed on instance members.');
+        let mappingList = putIfAbsent(staticSignalHandlers, target, (): [string, ID][] => []);
+        mappingList.push([propertyKey, id]);
+    } else {
+        let mappingList = putIfAbsent(signalHandlers, target.constructor, (): [string, ID][] => []);
+        mappingList.push([propertyKey, id]);
     }
-    let mappingList = putIfAbsent(signalHandlers, target.constructor, ():[string, ID][] => []);
-    mappingList.push([propertyKey, id]);
 };
 
 const getComponentDependencies = (system: Class) => {
@@ -69,14 +75,21 @@ const componentResolver = (context: ResolverContext, dependency: Dependency): Re
     }
     const entityClass = (context as EntityResolverContext).entityClass;
     const key = entityComponents.get(<any>entityClass as Class)!.get((dependency as ComponentDependency).type);
-    return (entity: any) => entity[key!];
+    return (context: SystemContext) => (context.entity as any)[key!];
 };
 
 const entityResolver = ({type, kind}: ResolverContext, _dependency: Dependency): ResolverFunction => {
     if (kind !== 'system') {
         throw new Error(`Could not resolve Entity in ${type.name}. @GetEntity only allowed in system scope.`);
     }
-    return (entity: any) => entity;
+    return (context: SystemContext) => context.entity;
+};
+
+const contextResolver = ({type, kind}: ResolverContext, _dependency: Dependency): ResolverFunction => {
+    if (kind !== 'system') {
+        throw new Error(`Could not resolve Context in ${type.name}. @GetContext only allowed in system scope.`);
+    }
+    return (context: SystemContext) => context;
 };
 
 // const isSignalResolver = (dependency: Dependency): dependency is SignalDependency => dependency.kind === 'signal';
@@ -90,13 +103,15 @@ export class EcsInjector<SystemClass extends Class = Class> extends Injector {
     constructor(parent?: EcsInjector<SystemClass>) {
         super(parent);
         this.signalMap = parent ? parent.signalMap : new Map<ID, Signal>();
-        this.entitySystemMap = parent ? parent.entitySystemMap : new Map<EntityClass, SystemClass[]>();
-        this.entitySystemResolverTuples = parent ? parent.entitySystemResolverTuples : new Map<EntityClass, SystemResolvers<SystemClass>[]>();
+        this.entitySystemMap = new Map<EntityClass, SystemClass[]>();
+        this.entitySystemResolverTuples = new Map<EntityClass, SystemResolvers<SystemClass>[]>();
+        this.map(EcsInjector).toValue(this);
 
         if (!parent) {
             // only add extension resolvers to the main/parent injector
             this.addExtensionResolver('entity', entityResolver);
             this.addExtensionResolver('component', componentResolver);
+            this.addExtensionResolver('context', contextResolver);
 
             const signalResolver = ({kind}: ResolverContext, dependency: Dependency): ResolverFunction => {
                 const signal = putIfAbsent(this.signalMap, (<SignalDependency>dependency).id, () => new Signal());
@@ -123,39 +138,47 @@ export class EcsInjector<SystemClass extends Class = Class> extends Injector {
         }
     }
 
-    createSystems(entity: Object): InstanceType<SystemClass>[] {
+    createSystems(entity: Object): SystemContext[] {
         const systemResolverTuples = putIfAbsent(this.entitySystemResolverTuples, entity.constructor, (): SystemResolvers<SystemClass>[] => {
             const systems = this.entitySystemMap.get(entity.constructor as Class);
             if (!systems) {
-                console.warn('no system for entity ' + entity.constructor.name);
                 return [];
             }
 
             const result: SystemResolvers<SystemClass>[] = [];
-            for (const systemClass of systems!) {
+            for (const systemClass of systems) {
                 result.push([systemClass, this.createResolverArray({type: systemClass, kind: 'system', entityClass: entity.constructor})]);
             }
             return result;
         });
-        const systemInstances: InstanceType<SystemClass>[] = [];
+        const systemInstances: SystemContext[] = [];
         for (const [system, resolver] of systemResolverTuples) {
             const args = new Array(resolver.length);
+
+            const systemContext = new SystemContext<InstanceType<SystemClass>>(entity);
+
             for (let i = 0; i < args.length; i++) {
-                args[i] = resolver[i](entity);
+                args[i] = resolver[i](systemContext);
             }
 
-            let systemInstance = new system(...args);
-            // TODO: new class(...args) is very slow in firefox :/
-            // let systemInstance = new (system.bind(system, args[0], args[1], args[2], args[3], args[4]));
+            // friend class :)
+            (systemContext as any).system = new system(...args); // TODO: new class(...args) is very slow in firefox :/
 
-            // systemInstance.onSignal.add()
+            // let systemInstance = new (system.bind(system, args[0], args[1], args[2], args[3], args[4]));
 
-            systemInstances.push(systemInstance);
+            systemInstances.push(systemContext);
         }
         return systemInstances;
     }
 
     getSignal<T>(id: ID): Signal<T> {
-        return putIfAbsent(this.signalMap, id, () => new Signal());
+        return putIfAbsent(this.signalMap, id, () => new Signal<any>());
+    }
+
+    dispose() {
+        // TODO: implement dispose in Injector
+        for (const [key, signal] of this.signalMap) {
+            signal.detachAll();
+        }
     }
 }

package/src/entity.ts

@@ -8,7 +8,7 @@ let idCounter = 0;
 export class Entity {
 
     readonly id: number;
-    children = new Set<Entity>();
+    readonly children = new Set<Entity>();
     private gameEngine?: GameEngine;
 
     // TODO: use single rootEntity class instead of undefined?
@@ -16,7 +16,8 @@ export class 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++;
@@ -67,7 +68,7 @@ export class Entity {
         } else {
             if (this.gameEngine) {
 
-                await this.gameEngine.addEntity(entity);
+                await this.gameEngine.add(entity);
             }
         }
 
@@ -78,35 +79,44 @@ export class Entity {
         }
     }
 
-    remove(entity: Entity) {
+    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.gameEngine) {
-            throw new Error('Could not detach passive entity.');
+        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) {
-            this.parent.remove(this);
+            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);
         }
-        await this.gameEngine.removeEntity(this);
     }
 
     has(entity: Entity) {
         return this.children.has(entity);
     }
 
-    public toString(): string {
-        return 'Deine Vater';
-    }
-
-    getAllChildren(target: Entity[] = []) {
+    /**
+     * this includes the entity itself
+     * @param target
+     */
+    getAllEntities(target: Entity[] = []) {
         target.push(this);
         for (const child of this.children) {
-            child.getAllChildren(target);
+            child.getAllEntities(target);
         }
         return target;
     }