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

package/src/ecsInjector.ts

@@ -9,6 +9,7 @@ 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; };
@@ -16,9 +17,12 @@ type EntitySignalDependency = Dependency & { kind: 'entitySignal'; index: number
 
 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 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}));
@@ -33,7 +37,7 @@ export const EntityComponent = (target: object, propertyKey: string): any => {
     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>());
+    const componentSet = putIfAbsent(EcsInjector.entityComponents, entityClass, () => new Map<ComponentClass, string>());
     componentSet.set(componentClass, propertyKey);
 };
 
@@ -49,17 +53,18 @@ export const OnSignal = (id: ID) => (target: any, propertyKey: string, descripto
     }
 };
 
-const getComponentDependencies = (system: Class) => {
-    const dependencies = Injector.dependencyMap.get(system);
-    return dependencies
-        ? dependencies.filter((dependency): dependency is ComponentDependency => dependency.kind === 'component')
-        : [];
+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 entityComponents) {
+    for (const [entityClass, componentMap] of EcsInjector.entityComponents) {
         let allDependenciesMet = true;
         for (const componentType of componentTypes) {
             if (!componentMap.has(componentType)) {
@@ -81,10 +86,21 @@ const componentResolver = (context: ResolverContext, dependency: Dependency): Re
         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);
+    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.`);
@@ -109,22 +125,31 @@ const contextResolver = ({type, kind}: ResolverContext, _dependency: Dependency)
 // 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[]>();
+    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 entitySystemResolverTuples: Map<Class, SystemResolvers<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.entitySystemResolverTuples = new Map<EntityClass, SystemResolvers<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 => {
@@ -143,12 +168,19 @@ export class EcsInjector<SystemClass extends Class = Class> extends Injector {
 
     registerSystem<T extends SystemClass>(systemClass: T) {
         // TODO: check if system is already mapped
-        const componentDependencies = getComponentDependencies(systemClass).map(dependency => dependency.type);
+        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) {
+        if (entityClasses.length === 0 && EcsInjector.warnNoMatchingEntities) {
             console.warn(`System '${systemClass.name}' has no matching entities.`);
             return;
         }
@@ -158,23 +190,39 @@ export class EcsInjector<SystemClass extends Class = Class> extends Injector {
         }
     }
 
-    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 [];
-            }
+    createSystemsForDynamicComponents(dynamicComponentClass: Class, entity: Entity) {
+        const potentialSystems = this.getSystemResolverTuples(entity);
+        const systems = this.dynamicComponentSystemMap.get(dynamicComponentClass)!;
 
-            const result: SystemResolvers<SystemClass>[] = [];
-            for (const systemClass of systems) {
-                result.push([systemClass, this.createResolverArray({type: systemClass, kind: 'system', entityClass: entity.constructor})]);
+        const finalSystemResolverEntries = new Map<SystemClass, ResolverFunction[]>();
+        for (const system of systems) {
+            const resolverTuples = potentialSystems.get(system);
+            if (resolverTuples) {
+                finalSystemResolverEntries.set(system, resolverTuples);
             }
-            return result;
-        });
-        const systemInstances: SystemContext[] = [];
-        for (const [system, resolver] of systemResolverTuples) {
+        }
+
+        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++) {
@@ -187,18 +235,32 @@ export class EcsInjector<SystemClass extends Class = Class> extends Injector {
             const entitySignals = entitySignalHandlers.get(system);
             if (entitySignals?.length) {
                 for (const [propertyKey, id] of entitySignals) {
-                    (entity as Entity).getSignal(id).add(newSystem[propertyKey], newSystem);
+                    entity.getSignal(id).add(newSystem[propertyKey], newSystem);
                 }
             }
 
             // friend class :)
             (systemContext as any).system = newSystem;
 
-            systemInstances.push(systemContext);
+            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>());
     }

package/src/entity.ts

@@ -1,14 +1,13 @@
 import {GameEngine} from './gameEngine';
 import {Signal} from 'mani-signal';
 import {Class} from './types';
-import {entityComponents} from './ecsInjector';
 import {ID, putIfAbsent} from './injector';
+import {EcsInjector} from './ecsInjector';
 
 let idCounter = 0;
 
 export class Entity {
 
-    readonly id: number;
     readonly children = new Set<Entity>();
     private gameEngine?: GameEngine;
 
@@ -20,12 +19,64 @@ export class Entity {
     private _detached = false;
     private readonly signalMap: Map<ID, Signal> = new Map<ID, Signal>();
 
-    get detached(): boolean { return this._detached; }
+    private dynamicComponents = new Map<Class, InstanceType<any>>();
+
+    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);
+
+        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);
+    }
+    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);
+            }
+        });
+        if (!this.dynamicComponents.delete(componentClass)) {
+            throw new Error('component not found: ' + JSON.stringify(componentClass));
+        }
+    }
 
-    constructor() {
-        this.id = idCounter++;
+    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> {
@@ -46,7 +97,7 @@ export class Entity {
     }
 
     getComponent<T extends Class>(componentClass: T): InstanceType<T> | undefined {
-        const componentMap = entityComponents.get(this.constructor as Class);
+        const componentMap = EcsInjector.entityComponents.get(this.constructor as Class);
         if (!componentMap) {
             throw new Error(`No components in entity of type '${this.constructor.name}'.`);
         }
@@ -128,4 +179,8 @@ export class Entity {
         }
         return target;
     }
+
+    hasDynamicComponents() {
+        return this.dynamicComponents.size > 0;
+    }
 }

package/src/gameEngine.ts

@@ -17,7 +17,7 @@ const defaultOptions = {
 export type GameEngineOptions = Partial<typeof defaultOptions>;
 declare global {
     interface GameEngineActions {
-        'testAction': string
+        'testAction': string;
     }
 }
 
@@ -50,7 +50,8 @@ export class GameEngine {
     private readonly onLateUpdateSet = new Set<System>();
     private readonly onRenderUpdateSet = new Set<System>();
 
-    private readonly entitySystemMap = new Map<Entity, SystemContext[]>();
+    // TODO: for performance, we could store the systems directly in the entity
+    private readonly entitySystemMap = new Map<Entity, Set<SystemContext>>();
 
     private readonly serviceClasses = new Set<Class<Service>>();
     private readonly services: Service[] = [];
@@ -346,19 +347,7 @@ export class GameEngine {
                 this.entitySystemMap.delete(entity);
                 if (systemContexts) {
                     for (const context of systemContexts) {
-                        context.dispose();
-                        const system = context.system;
-                        this.unmapAnnotatedSignals(system);
-                        system.onEnd && system.onEnd();
-                        system.onPreFixedUpdate && this.onPreFixedUpdateSet.delete(system);
-                        system.onFixedUpdate && this.onFixedUpdateSet.delete(system);
-                        system.onUpdate && this.onUpdateSet.delete(system);
-                        system.onLateUpdate && this.onLateUpdateSet.delete(system);
-                        system.onPhysicsUpdate && this.onPhysicsUpdateSet.delete(system);
-                        system.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.delete(system);
-                        system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.delete(system);
-                        system.onLateFixedUpdate && this.onLateFixedUpdateSet.delete(system);
-                        system.onRender && this.onRenderUpdateSet.delete(system);
+                        this.disposeContext(context);
                     }
                 }
                 entity.onRemove.dispatch();
@@ -370,45 +359,27 @@ export class GameEngine {
         this.removeQueue = [];
 
         for (const [entity, resolve] of this.addQueue) {
+
             const preparePromises = [];
-            const nexSystemContexts: SystemContext[] = [];
+            const nextSystemContexts: SystemContext[] = [];
             const entities = entity.getAllEntities();
             for (const entity of entities) {
                 if ((<any>entity).gameEngine) throw new Error('Entity already added to a gameEngine');
                 (<any>entity).gameEngine = this;
-                const systemContexts = this.injector.createSystems(entity);
+                const systemContexts = this.injector.createSystemsForEntity(entity);
                 for (const context of systemContexts) {
                     // TODO: implement synced mode where async onPrepares aren't allowed
                     context.system.onPrepare && preparePromises.push(context.system.onPrepare());
-                    nexSystemContexts.push(context);
+                    nextSystemContexts.push(context);
                 }
                 this.entitySystemMap.set(entity, systemContexts);
             }
 
-            const startSystems = () => {
-                // TODO: check if a "global" method is faster than this inner method
-                for (const context of nexSystemContexts) {
-                    const system = context.system;
-                    this.mapAnnotatedSignals(system);
-                    system.onStart && system.onStart();
-                    system.onPreFixedUpdate && this.onPreFixedUpdateSet.add(system);
-                    system.onFixedUpdate && this.onFixedUpdateSet.add(system);
-                    system.onUpdate && this.onUpdateSet.add(system);
-                    system.onLateUpdate && this.onLateUpdateSet.add(system);
-                    system.onPhysicsUpdate && this.onPhysicsUpdateSet.add(system);
-                    system.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.add(system);
-                    system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(system);
-                    system.onLateFixedUpdate && this.onLateFixedUpdateSet.add(system);
-                    system.onRender && this.onRenderUpdateSet.add(system);
-                }
-                resolve();
-            };
-
             // Promise.all doesnt resolve immediately when there are no promises bu
             if (preparePromises.length === 0) {
-                startSystems();
+                this.startSystems(nextSystemContexts, resolve);
             } else {
-                Promise.all(preparePromises).then(startSystems);
+                Promise.all(preparePromises).then(() => this.startSystems(nextSystemContexts, resolve));
             }
         }
         this.addQueue = [];
@@ -419,6 +390,40 @@ export class GameEngine {
         });
         this.onPrepare.dispatch();
     }
+
+    private startSystems(contexts: Iterable<SystemContext>, then?: () => void) {
+        for (const context of contexts) {
+            const system = context.system;
+            this.mapAnnotatedSignals(system);
+            system.onStart && system.onStart();
+            system.onPreFixedUpdate && this.onPreFixedUpdateSet.add(system);
+            system.onFixedUpdate && this.onFixedUpdateSet.add(system);
+            system.onUpdate && this.onUpdateSet.add(system);
+            system.onLateUpdate && this.onLateUpdateSet.add(system);
+            system.onPhysicsUpdate && this.onPhysicsUpdateSet.add(system);
+            system.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.add(system);
+            system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.add(system);
+            system.onLateFixedUpdate && this.onLateFixedUpdateSet.add(system);
+            system.onRender && this.onRenderUpdateSet.add(system);
+        }
+        then?.();
+    };
+
+    private disposeContext(context: SystemContext<System>) {
+        context.dispose();
+        const system = context.system;
+        this.unmapAnnotatedSignals(system);
+        system.onEnd && system.onEnd();
+        system.onPreFixedUpdate && this.onPreFixedUpdateSet.delete(system);
+        system.onFixedUpdate && this.onFixedUpdateSet.delete(system);
+        system.onUpdate && this.onUpdateSet.delete(system);
+        system.onLateUpdate && this.onLateUpdateSet.delete(system);
+        system.onPhysicsUpdate && this.onPhysicsUpdateSet.delete(system);
+        system.onPrePhysicsUpdate && this.onPrePhysicsUpdateSet.delete(system);
+        system.onPostPhysicsUpdate && this.onPostPhysicsUpdateSet.delete(system);
+        system.onLateFixedUpdate && this.onLateFixedUpdateSet.delete(system);
+        system.onRender && this.onRenderUpdateSet.delete(system);
+    }
 }
 //
 // type RunSpread<T> = T extends undefined

package/src/index.ts

@@ -17,7 +17,7 @@ export {
     Scope, SCOPE_CONTEXT, ScopeContext, OnScopeSignal, scopeSignalHandlers, ScopeSignalOptions, ScopeMapping,
 } from './scope/scopeContext';
 export {SystemContext, OnEntitySignal} from './systemContext';
-export {EcsInjector, EntityComponent, GetComponent, GetEntity, GetContext, GetSignal, OnSignal, GetEntitySignal} from './ecsInjector';
+export {EcsInjector, EntityComponent, GetComponent,GetDynamicComponent, GetEntity, GetContext, GetSignal, OnSignal, GetEntitySignal, } from './ecsInjector';
 
 // intellij doesnt auto resolve imports if we just export * from an external dependency
 

package/src/injector.ts

@@ -73,6 +73,7 @@ export const createDependencyAnnotation = (cb: (type: any, index: number, depend
         throw new Error('Could not inject class in itself.');
     }
     const depList = putIfAbsent(Injector.dependencyMap, dependantType, (): Dependency[] => []);
+
     depList.push(cb(type, index, dependantType));
 };
 

package/src/scope/scopeContext.ts

@@ -74,6 +74,13 @@ class ScopeStack {
 export type ScopeMapping = (params: {
     injector: EcsInjector,
     registerScopeService: (serviceClass: Class) => void,
+    onEnter: Signal<ScopeContext>,
+    onExit: Signal<ScopeContext>,
+    onSubReturn: Signal<ScopeContext>,
+    onSubExit: Signal<ScopeContext>,
+    onActivate: Signal<ScopeContext>,
+    onDeactivate: Signal<ScopeContext>,
+
 }) => void
 
 interface AddScopeSignalOptions extends ScopeSignalOptions {
@@ -93,6 +100,13 @@ export class ScopeContext {
     private closed = false;
     private muteKeepAliveSignals = false;
 
+    readonly onEnter = new Signal<ScopeContext>();
+    readonly onExit = new Signal<ScopeContext>();
+    readonly onSubReturn = new Signal<ScopeContext>();
+    readonly onSubExit = new Signal<ScopeContext>();
+    readonly onActivate = new Signal<ScopeContext>();
+    readonly onDeactivate = new Signal<ScopeContext>();
+
     constructor(injector: EcsInjector, scopeClass: Class, mapping?: ScopeMapping, private parent?: ScopeContext) {
         if (!parent) {
             this.stack = new ScopeStack(this);
@@ -115,6 +129,12 @@ export class ScopeContext {
                 this.injector.map(serviceClass).toSingleton();
                 this.mapServiceSignals(this.injector.get(serviceClass));
             },
+            onEnter: this.onEnter,
+            onExit: this.onExit,
+            onSubReturn: this.onSubReturn,
+            onSubExit: this.onSubExit,
+            onActivate: this.onActivate,
+            onDeactivate: this.onDeactivate,
         });
 
         this.scope = this.injector.get(scopeClass) as Scope;
@@ -122,7 +142,9 @@ export class ScopeContext {
         this.updateSignalBindings();
         // TODO: maybe the scope needs to prepare resources or something before it can react to signals, so we should move onEnter bevore the signal mapping and make it async (not working in constructor though)
         this.scope.onEnter?.();
+        this.onEnter.dispatch(this);
         this.scope.onActivate?.();
+        this.onActivate.dispatch(this);
     }
 
     get isRoot() {
@@ -150,7 +172,9 @@ export class ScopeContext {
         const doChange = () => {
 
             this.activeContext.scope.onSubExit?.();
+            this.activeContext.onSubExit.dispatch(this);
             this.activeContext.scope.onDeactivate?.();
+            this.activeContext.onDeactivate.dispatch(this);
 
             newContext = new ScopeContext(this.activeContext.injector, scopeClass, mapping, this.activeContext);
 
@@ -162,7 +186,7 @@ export class ScopeContext {
                 this.stack.ongoingChange = false;
             }
         };
-        // TODO: this queued changes arent somewhat experimental
+        // TODO: this queued changes are somewhat experimental
         if (!this.stack.ongoingChange) {
             this.stack.ongoingChange = true;
             doChange();
@@ -313,10 +337,23 @@ export class ScopeContext {
         this.detachSignalBindings();
         this.detachServiceBindings();
         this.scope.onDeactivate?.();
+        this.onDeactivate.dispatch(this);
+
         this.scope.onExit?.();
+        this.onExit.dispatch(this);
         this.parent.updateSignalBindings();
         this.parent.scope.onSubReturn?.();
+        this.onSubReturn.dispatch(this);
         this.parent.scope.onActivate?.();
+        this.parent.onActivate.dispatch(this);
         this.closed = true;
+
+        this.onEnter.detachAll();
+        this.onExit.detachAll();
+        this.onSubReturn.detachAll();
+        this.onSubExit.detachAll();
+        this.onActivate.detachAll();
+        this.onDeactivate.detachAll();
+
     }
 }

package/src/systemContext.ts

@@ -1,5 +1,5 @@
 import {System} from './types';
-import {GameEngine, ID, putIfAbsent, Signal, SignalBinding, SignalCallback} from './index';
+import {Entity, GameEngine, ID, putIfAbsent, Signal, SignalBinding, SignalCallback} from './index';
 
 export const entitySignalHandlers = new Map<Object, [string, ID][]>();
 export const OnEntitySignal = (id: ID) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
@@ -15,7 +15,7 @@ export class SystemContext<T extends System = System> {
     readonly system!: T;
     private signalBindings: SignalBinding[] = [];
 
-    constructor(readonly entity: Object) {
+    constructor(readonly entity: Entity) {
     }
 
     // TODO: is this a bit hacky?
@@ -33,5 +33,6 @@ export class SystemContext<T extends System = System> {
 
     dispose() {
         for (const binding of this.signalBindings) binding.detach();
+
     }
 }

package/src/types.ts

@@ -14,6 +14,7 @@ export interface System {
     onPostPhysicsUpdate?(time: number, deltaTime: number): void;
     onLateFixedUpdate?(time: number, deltaTime: number): void;
     onRender?(time: number, deltaTime: number, alpha: number): void;
+    // new(...args: any[]): System;
     // new(): GameSystem;
 }