mani-game-engine 1.0.0-pre.4 → 1.0.0-pre.41

package/src/ecsInjector.ts

@@ -1,164 +1,274 @@
-// 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';
-
-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 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 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 (entity: any) => entity[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;
-};
-
-// 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>[]>();
-
-        if (!parent) {
-            // only add extension resolvers to the main/parent injector
-            this.addExtensionResolver('entity', entityResolver);
-            this.addExtensionResolver('component', componentResolver);
-
-            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): InstanceType<SystemClass>[] {
-        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!) {
-                result.push([systemClass, this.createResolverArray({type: systemClass, kind: 'system', entityClass: entity.constructor})]);
-            }
-            return result;
-        });
-        const systemInstances: InstanceType<SystemClass>[] = [];
-        for (const [system, resolver] of systemResolverTuples) {
-            const args = new Array(resolver.length);
-            for (let i = 0; i < args.length; i++) {
-                args[i] = resolver[i](entity);
-            }
-
-            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]));
-
-            // systemInstance.onSignal.add()
-
-            systemInstances.push(systemInstance);
-        }
-        return systemInstances;
-    }
-
-    getSignal<T>(id: ID): Signal<T> {
-        return putIfAbsent(this.signalMap, id, () => new Signal());
-    }
-}
+// TODO: what if systems for entity without components are created?
+import {Signal} from 'mani-signal';
+import {Class, createDependencyAnnotation, Dependency, ID, Injector, putIfAbsent, ResolverContext, ResolverFunction} from './injector';
+import {entitySignalHandlers, SystemContext} from './systemContext';
+import {Entity} from './entity';
+
+type ComponentClass = Class;
+type EntityClass = Class;
+
+type SystemResolvers<T extends Class> = [T, ResolverFunction[]]
+type ComponentDependency = Dependency & { kind: 'component'; index: number; type: Class; };
+type DynamicComponentDependency = Dependency & { kind: 'dynamic'; 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 EntitySignalDependency = Dependency & { kind: 'entitySignal'; index: number; id: ID; };
+
+type EntityResolverContext = ResolverContext & { entityClass: Object; };
+
+export const GetComponent = createDependencyAnnotation((type, index): ComponentDependency => ({kind: 'component', type, index}));
+export const GetDynamicComponent = createDependencyAnnotation((type, index): DynamicComponentDependency => ({
+    kind: 'dynamic',
+    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 GetEntitySignal = (id: ID) => createDependencyAnnotation((_type, index): EntitySignalDependency => ({
+    kind: 'entitySignal',
+    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(EcsInjector.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 extractDependenciesWithType = <T extends Dependency>(type: string) => {
+    const result = new Map<Class, T[]>();
+    Injector.dependencyMap.forEach((dependency, system) => {
+        putIfAbsent(result, system, () => [...dependency.filter((dependency) => dependency.kind === type)]);
+    });
+    return result;
+};
+
+const getEntityClassesForComponentDependencies = (componentTypes: Class[]): Class[] => {
+    // TODO: refactor class, use map, filter etc...
+    const result = [];
+    for (const [entityClass, componentMap] of EcsInjector.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 = EcsInjector.entityComponents.get(<any>entityClass as Class)!.get((dependency as ComponentDependency).type);
+    return (context: SystemContext) => (context.entity as any)[key!];
+};
+
+const dynamicComponentResolver = (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.getDynamicComponent((dependency as DynamicComponentDependency).type);
+};
+
+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 entitySignalResolver = ({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) => (<Entity>context.entity).getSignal((<EntitySignalDependency>dependency).id);
+};
+
+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 {
+    static warnNoMatchingEntities = true;
+    static entityComponents = new Map<EntityClass, Map<ComponentClass, string>>();
+    protected componentDependencyMap = extractDependenciesWithType<ComponentDependency>('component');
+    protected dynamicComponentDependencyMap = extractDependenciesWithType<DynamicComponentDependency>('dynamic');
+    protected entitySystemMap: Map<Class, SystemClass[]>;
+    protected dynamicComponentSystemMap: Map<Class, SystemClass[]>;
+    protected entitySystemResolverTuples: Map<Class, Map<SystemClass, ResolverFunction[]>>;
+    private signalMap: Map<ID, Signal>;
+
+    constructor(parent?: EcsInjector<SystemClass>) {
+        super(parent);
+        this.signalMap = parent ? parent.signalMap : new Map<ID, Signal>();
+
+        // TODO: do we need to have this maps in every child injector?
+        this.entitySystemMap = new Map<EntityClass, SystemClass[]>();
+        this.dynamicComponentSystemMap = new Map<EntityClass, SystemClass[]>();
+        this.entitySystemResolverTuples = new Map<Class, Map<SystemClass, ResolverFunction[]>>();
+
+        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('dynamic', dynamicComponentResolver);
+            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);
+            this.addExtensionResolver('entitySignal', entitySignalResolver);
+        }
+    }
+
+    //TODO: this needs some overthinking...
+    newSignalScope() {
+        this.signalMap = new Map<ID, Signal>();
+    }
+
+    registerSystem<T extends SystemClass>(systemClass: T) {
+        // TODO: check if system is already mapped
+        const componentDependencies = this.componentDependencyMap.get(systemClass)?.map(it => it.type) || [];
+        const dynamicComponentDependencies = this.dynamicComponentDependencyMap.get(systemClass) || [];
+
+        for (const dynamicComponentDependency of dynamicComponentDependencies) {
+            const systemClassesForDynamicComponent = putIfAbsent(this.dynamicComponentSystemMap, dynamicComponentDependency.type, () => [] as SystemClass[]);
+            systemClassesForDynamicComponent.push(systemClass);
+        }
+
+        if (componentDependencies.length === 0) {
+            throw new Error(`${systemClass.name} needs at least one component dependency.`);
+        }
+        const entityClasses = getEntityClassesForComponentDependencies(componentDependencies);
+        if (entityClasses.length === 0 && EcsInjector.warnNoMatchingEntities) {
+            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);
+        }
+    }
+
+    createSystemsForDynamicComponents(dynamicComponentClass: Class, entity: Entity) {
+        const potentialSystems = this.getSystemResolverTuples(entity);
+        const systems = this.dynamicComponentSystemMap.get(dynamicComponentClass)!;
+
+        const finalSystemResolverEntries = new Map<SystemClass, ResolverFunction[]>();
+        for (const system of systems) {
+            const resolverTuples = potentialSystems.get(system);
+            if (resolverTuples) {
+                finalSystemResolverEntries.set(system, resolverTuples);
+            }
+        }
+
+        return this.createSystems(finalSystemResolverEntries, entity);
+    }
+
+    createSystemsForEntity(entity: Entity): Set<SystemContext> {
+        const systemResolverTuples = this.getSystemResolverTuples(entity);
+        return this.createSystems(systemResolverTuples, entity);
+    }
+
+    private createSystems(systemResolverMap: Map<SystemClass, ResolverFunction[]>, entity: Entity) {
+        const systemInstances = new Set<SystemContext>();
+        for (const [system, resolver] of systemResolverMap) {
+            const args = new Array(resolver.length);
+
+            const dynamicDependencies = this.dynamicComponentDependencyMap.get(system) || [];
+            const hasUnfulfilledDynamicDependencies = dynamicDependencies.some((dependency, index) => {
+                return !entity.hasDynamicComponentClass(dependency.type);
+            });
+            if (hasUnfulfilledDynamicDependencies) {
+                continue;
+            }
+
+            const systemContext = new SystemContext<InstanceType<SystemClass>>(entity);
+
+            for (let i = 0; i < args.length; i++) {
+                args[i] = resolver[i](systemContext);
+            }
+
+            const newSystem = new system(...args); // TODO: new class(...args) is very slow in firefox :/
+
+            // map entity signals
+            const entitySignals = entitySignalHandlers.get(system);
+            if (entitySignals?.length) {
+                for (const [propertyKey, id] of entitySignals) {
+                    entity.getSignal(id).add(newSystem[propertyKey], newSystem);
+                }
+            }
+
+            // friend class :)
+            (systemContext as any).system = newSystem;
+
+            systemInstances.add(systemContext);
+        }
+        return systemInstances;
+    }
+
+    private getSystemResolverTuples(entity: Entity) {
+        return putIfAbsent(this.entitySystemResolverTuples, entity.constructor, (): Map<SystemClass, ResolverFunction[]> => {
+            const systems = this.entitySystemMap.get(entity.constructor as Class);
+            if (!systems) return [] as any;
+
+            // const result: SystemResolvers<SystemClass>[] = [];
+            const result = new Map<SystemClass, ResolverFunction[]>();
+            for (const systemClass of systems) {
+                result.set(systemClass, this.createResolverArray({type: systemClass, kind: 'system', entityClass: entity.constructor}));
+            }
+            return result;
+        });
+    }
+
+    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();
+        }
+    }
+}