mani-game-engine 1.0.0-pre.12 → 1.0.0-pre.15

package/src/ecsInjector.ts

@@ -1,184 +1,184 @@
-// 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 {SystemContext} from './systemContext';
-
-type ComponentClass = Class;
-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; };
-
-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;
-    const componentClass = Reflect.getMetadata('design:type', target, propertyKey);
-    if (componentClass === Object) {
-        throw new Error(`Object component type not allowed. Forgot to specify type of ${entityClass.name}.${propertyKey}?`);
-    }
-    const componentSet = putIfAbsent(entityComponents, entityClass, () => new Map<ComponentClass, string>());
-    componentSet.set(componentClass, propertyKey);
-};
-
-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) {
-        let mappingList = putIfAbsent(staticSignalHandlers, target, (): [string, ID][] => []);
-        mappingList.push([propertyKey, id]);
-    } else {
-        let mappingList = putIfAbsent(signalHandlers, target.constructor, (): [string, ID][] => []);
-        mappingList.push([propertyKey, id]);
-    }
-};
-
-const getComponentDependencies = (system: Class) => {
-    const dependencies = Injector.dependencyMap.get(system);
-    return dependencies
-        ? dependencies.filter((dependency): dependency is ComponentDependency => dependency.kind === 'component')
-        : [];
-};
-
-const getEntityClassesForComponentDependencies = (componentTypes: Class[]): Class[] => {
-    // TODO: refactor class, use map, filter etc...
-    const result = [];
-    for (const [entityClass, componentMap] of entityComponents) {
-        let allDependenciesMet = true;
-        for (const componentType of componentTypes) {
-            if (!componentMap.has(componentType)) {
-                allDependenciesMet = false;
-                break;
-            }
-        }
-        if (allDependenciesMet) {
-            result.push(entityClass);
-        }
-    }
-    return result;
-};
-
-const componentResolver = (context: ResolverContext, dependency: Dependency): ResolverFunction => {
-    const kind = context.kind;
-    const type = context.type;
-    if (kind !== 'system') {
-        throw new Error(`Could not resolve Component ${type.name}. @GetComponent only allowed in system scope.`);
-    }
-    const entityClass = (context as EntityResolverContext).entityClass;
-    const key = entityComponents.get(<any>entityClass as Class)!.get((dependency as ComponentDependency).type);
-    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 (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';
-
-export class EcsInjector<SystemClass extends Class = Class> extends Injector {
-    // protected readonly entitySystemMap = new Map<EntityClass, SystemClass[]>();
-    protected entitySystemMap: Map<Class, SystemClass[]>;
-    protected entitySystemResolverTuples: Map<Class, SystemResolvers<SystemClass>[]>;
-    private signalMap: Map<ID, Signal>;
-
-    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.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());
-                return (entity: any) => signal;
-            };
-            this.addExtensionResolver('signal', signalResolver);
-        }
-    }
-
-    registerSystem<T extends SystemClass>(systemClass: T) {
-        // TODO: check if system is already mapped
-        const componentDependencies = getComponentDependencies(systemClass).map(dependency => dependency.type);
-        if (componentDependencies.length === 0) {
-            throw new Error(`${systemClass.name} needs at least one component dependency.`);
-        }
-        const entityClasses = getEntityClassesForComponentDependencies(componentDependencies);
-        if (entityClasses.length === 0) {
-            console.warn(`System '${systemClass.name}' has no matching entities.`);
-            return;
-        }
-        for (let entityClass of entityClasses) {
-            const systemClasses = putIfAbsent(this.entitySystemMap, entityClass, (): SystemClass[] => []);
-            systemClasses.push(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) {
-                return [];
-            }
-
-            const result: SystemResolvers<SystemClass>[] = [];
-            for (const systemClass of systems) {
-                result.push([systemClass, this.createResolverArray({type: systemClass, kind: 'system', entityClass: entity.constructor})]);
-            }
-            return result;
-        });
-        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](systemContext);
-            }
-
-            // friend class :)
-            (systemContext as any).system = 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]));
-
-            systemInstances.push(systemContext);
-        }
-        return systemInstances;
-    }
-
-    getSignal<T>(id: ID): Signal<T> {
-        return putIfAbsent(this.signalMap, id, () => new Signal<any>());
-    }
-
-    dispose() {
-        // TODO: implement dispose in Injector
-        for (const [key, signal] of this.signalMap) {
-            signal.detachAll();
-        }
-    }
-}
+// 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 {SystemContext} from './systemContext';
+
+type ComponentClass = Class;
+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; };
+
+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;
+    const componentClass = Reflect.getMetadata('design:type', target, propertyKey);
+    if (componentClass === Object) {
+        throw new Error(`Object component type not allowed. Forgot to specify type of ${entityClass.name}.${propertyKey}?`);
+    }
+    const componentSet = putIfAbsent(entityComponents, entityClass, () => new Map<ComponentClass, string>());
+    componentSet.set(componentClass, propertyKey);
+};
+
+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) {
+        let mappingList = putIfAbsent(staticSignalHandlers, target, (): [string, ID][] => []);
+        mappingList.push([propertyKey, id]);
+    } else {
+        let mappingList = putIfAbsent(signalHandlers, target.constructor, (): [string, ID][] => []);
+        mappingList.push([propertyKey, id]);
+    }
+};
+
+const getComponentDependencies = (system: Class) => {
+    const dependencies = Injector.dependencyMap.get(system);
+    return dependencies
+        ? dependencies.filter((dependency): dependency is ComponentDependency => dependency.kind === 'component')
+        : [];
+};
+
+const getEntityClassesForComponentDependencies = (componentTypes: Class[]): Class[] => {
+    // TODO: refactor class, use map, filter etc...
+    const result = [];
+    for (const [entityClass, componentMap] of entityComponents) {
+        let allDependenciesMet = true;
+        for (const componentType of componentTypes) {
+            if (!componentMap.has(componentType)) {
+                allDependenciesMet = false;
+                break;
+            }
+        }
+        if (allDependenciesMet) {
+            result.push(entityClass);
+        }
+    }
+    return result;
+};
+
+const componentResolver = (context: ResolverContext, dependency: Dependency): ResolverFunction => {
+    const kind = context.kind;
+    const type = context.type;
+    if (kind !== 'system') {
+        throw new Error(`Could not resolve Component ${type.name}. @GetComponent only allowed in system scope.`);
+    }
+    const entityClass = (context as EntityResolverContext).entityClass;
+    const key = entityComponents.get(<any>entityClass as Class)!.get((dependency as ComponentDependency).type);
+    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 (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';
+
+export class EcsInjector<SystemClass extends Class = Class> extends Injector {
+    // protected readonly entitySystemMap = new Map<EntityClass, SystemClass[]>();
+    protected entitySystemMap: Map<Class, SystemClass[]>;
+    protected entitySystemResolverTuples: Map<Class, SystemResolvers<SystemClass>[]>;
+    private signalMap: Map<ID, Signal>;
+
+    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.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());
+                return (entity: any) => signal;
+            };
+            this.addExtensionResolver('signal', signalResolver);
+        }
+    }
+
+    registerSystem<T extends SystemClass>(systemClass: T) {
+        // TODO: check if system is already mapped
+        const componentDependencies = getComponentDependencies(systemClass).map(dependency => dependency.type);
+        if (componentDependencies.length === 0) {
+            throw new Error(`${systemClass.name} needs at least one component dependency.`);
+        }
+        const entityClasses = getEntityClassesForComponentDependencies(componentDependencies);
+        if (entityClasses.length === 0) {
+            console.warn(`System '${systemClass.name}' has no matching entities.`);
+            return;
+        }
+        for (let entityClass of entityClasses) {
+            const systemClasses = putIfAbsent(this.entitySystemMap, entityClass, (): SystemClass[] => []);
+            systemClasses.push(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) {
+                return [];
+            }
+
+            const result: SystemResolvers<SystemClass>[] = [];
+            for (const systemClass of systems) {
+                result.push([systemClass, this.createResolverArray({type: systemClass, kind: 'system', entityClass: entity.constructor})]);
+            }
+            return result;
+        });
+        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](systemContext);
+            }
+
+            // friend class :)
+            (systemContext as any).system = 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]));
+
+            systemInstances.push(systemContext);
+        }
+        return systemInstances;
+    }
+
+    getSignal<T>(id: ID): Signal<T> {
+        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

@@ -1,116 +1,123 @@
-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) {
-            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';
+
+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;
+    }
+}