mani-game-engine 1.0.0-pre.10 → 1.0.0-pre.100

package/src/clock.ts

@@ -6,110 +6,200 @@ const MIN_TIME_SCALE = 0.00001;
 // type OnUpdateParams = { time: number, deltaTime: number, alpha: number; };
 
 const defaultOptions = {
-    autoStart: true,
-    fixedDeltaTime: 1 / 60,
-    maxFrameTime: 0.25,
-    timeScale: 1,
+  autoStart: true,
+  fixedDeltaTime: 1 / 60,
+  maxFrameTime: 0.25,
+  timeScale: 1,
 };
 
+export type Timeout = {
+  recall?: number;
+  callback: Function;
+  callTime: number;
+};
 export type GameClockOptions = Partial<typeof defaultOptions>;
 
 export interface Clock {
-
-    onPrepare: Signal<unknown>;
-    onEarlyUpdate: Signal<OnEarlyUpdateParams>;
-    onUpdate: Signal<OnUpdateParams>;
-    onFixedUpdate: Signal<OnFixedUpdateParams>;
-    timeScale: number;
-    start(): this;
-    stop(): this;
+  readonly gameTime: number;
+  onPrepare: Signal<unknown>;
+  onEarlyUpdate: Signal<OnEarlyUpdateParams>;
+  onUpdate: Signal<OnUpdateParams>;
+  onFixedUpdate: Signal<OnFixedUpdateParams>;
+  timeScale: number;
+  start(): this;
+  stop(): this;
+  dispose(): void;
+  processFrame(time: number): void;
+  readonly fixedDeltaTime: number;
+  setTimeout(callback: Function, delay: number): number;
+  setInterval(callback: Function, delay: number): number;
+  clearTimeout(timeoutId: number): boolean;
+  fixedTween(duration: number, from: number, to: number, onUpdate: (t: number) => void): Promise<void>;
+  tween(duration: number, from: number, to: number, onUpdate: (t: number) => void): Promise<void>;
 }
 
 export class GameClock implements Clock {
-    private isRunning = false;
-    private requestId = 0;
-    private currentTime = 0;
-    private accumulator = 0;
-    private gameTime = 0;
-
-    private readonly _fixedDeltaTime: number;
-    private update = (time: number) => {
-        const newTime = time * 0.001;
-        if (!this.isRunning) {
-            this.currentTime = newTime;
-            this.isRunning = true;
-        }
-
-        let frameTime = (newTime - this.currentTime) * this.timeScale;
-
-        if (frameTime > this.maxFrameTime) {
-            frameTime = this.maxFrameTime;
-        }
+  get gameTime(): number {
+    return this._gameTime;
+  }
+  get animationTime(): number {
+    return this._animationTime;
+  }
+  private _animationTime = 0;
+  private nextTimeoutId = 0;
+  private timeouts = new Map<number, Timeout>();
+  private isRunning = false;
+  private currentTime = 0;
+  private accumulator = 0;
+  private _gameTime = 0;
+
+  private readonly _fixedDeltaTime: number;
+
+
+
+  processFrame(time: number): void {
+    if (!this.isRunning) {
+      return;
+    }
 
-        this.currentTime = newTime;
-        this.accumulator += frameTime;
-        let isMultipleFixedUpdate = false;
-
-        this.onPrepare.dispatch();
-        this.onEarlyUpdate.dispatch({time: this.gameTime, deltaTime: frameTime});
-        while (this.accumulator >= this._fixedDeltaTime) {
-            if (isMultipleFixedUpdate) {
-                this.onPrepare.dispatch();
-            }
-            this.onFixedUpdate.dispatch({time: this.gameTime, deltaTime: this._fixedDeltaTime});
-            isMultipleFixedUpdate = true;
-            this.accumulator -= this._fixedDeltaTime;
-            this.gameTime += this._fixedDeltaTime;
-        }
-        const alpha = this.accumulator / this._fixedDeltaTime;
-        this.onUpdate.dispatch({time: this.gameTime + alpha * this._fixedDeltaTime, deltaTime: frameTime, alpha: alpha});
-        if (this.isRunning) {
-            this.requestId = requestAnimationFrame(this.update);
+    const newTime = time * 0.001;
+    // Clamp raw delta before applying timeScale for more predictable behavior
+    const rawDelta = newTime - this.currentTime;
+    let clampedDelta = rawDelta;
+    if (clampedDelta > this.maxFrameTime) {
+      clampedDelta = this.maxFrameTime;
+    }
+    const frameTime = clampedDelta * this.timeScale;
+
+    this.currentTime = newTime;
+    this.accumulator += frameTime;
+
+    while (this.accumulator >= this._fixedDeltaTime) {
+      // Use fixedDeltaTime inside the fixed-step loop for consistency
+      this.onEarlyUpdate.dispatch({time: this._gameTime, deltaTime: this._fixedDeltaTime});
+      this.onPrepare.dispatch();
+      for (const [id, timeOut] of this.timeouts) {
+        if (this._gameTime >= timeOut.callTime) {
+          timeOut.callback();
+          if (timeOut.recall) {
+            timeOut.callTime += timeOut.recall;
+          } else {
+            this.timeouts.delete(id);
+          }
         }
-    };
-
-    private maxFrameTime: number;
-
-    readonly onPrepare = new Signal();
-    readonly onEarlyUpdate = new Signal<OnEarlyUpdateParams>();
-    readonly onUpdate = new Signal<OnUpdateParams>();
-    readonly onFixedUpdate = new Signal<OnFixedUpdateParams>();
-
-    constructor(options?: GameClockOptions) {
-        const opts = {...defaultOptions, ...options} as Required<GameClockOptions>;
-        this._fixedDeltaTime = opts.fixedDeltaTime;
-        this.maxFrameTime = opts.maxFrameTime;
-        this.timeScale = opts.timeScale;
-
-        opts.autoStart && this.start();
+      }
+      this.onFixedUpdate.dispatch({time: this._gameTime, deltaTime: this._fixedDeltaTime});
+      this.accumulator -= this._fixedDeltaTime;
+      this._gameTime += this._fixedDeltaTime;
     }
-
-    get fixedDeltaTime(): number { return this._fixedDeltaTime; }
-
-    private _timeScale = 1;
-
-    get timeScale(): number {
-        return this._timeScale;
+    const alpha = this.accumulator / this._fixedDeltaTime;
+    this._animationTime = this._gameTime + alpha * this._fixedDeltaTime;
+    this.onUpdate.dispatch({time: this._animationTime, deltaTime: frameTime, alpha: alpha});
+  }
+
+  private readonly maxFrameTime: number;
+
+  readonly onPrepare = new Signal();
+  readonly onEarlyUpdate = new Signal<OnEarlyUpdateParams>();
+  readonly onUpdate = new Signal<OnUpdateParams>();
+  readonly onFixedUpdate = new Signal<OnFixedUpdateParams>();
+
+  constructor(options?: GameClockOptions) {
+    const opts = {...defaultOptions, ...options} as Required<GameClockOptions>;
+    this._fixedDeltaTime = opts.fixedDeltaTime;
+    this.maxFrameTime = opts.maxFrameTime;
+    this.timeScale = opts.timeScale;
+
+    opts.autoStart && this.start();
+  }
+
+  dispose(): void {
+    // Stop scheduling frames and clear callbacks to avoid leaks
+    this.stop();
+    this.timeouts.clear();
+    this.onPrepare.detachAll();
+    this.onEarlyUpdate.detachAll();
+    this.onUpdate.detachAll();
+    this.onFixedUpdate.detachAll();
+  }
+
+  get fixedDeltaTime(): number { return this._fixedDeltaTime; }
+
+  private _timeScale = 1;
+
+  get timeScale(): number {
+    return this._timeScale;
+  }
+
+  set timeScale(value: number) {
+    // Allow 0 (pause). For positive values, clamp to MIN_TIME_SCALE.
+    this._timeScale = value === 0 ? 0 : Math.max(value, MIN_TIME_SCALE);
+  }
+
+  start(): this {
+    if (this.isRunning) {
+      return this;
     }
-
-    set timeScale(value: number) {
-        this._timeScale = Math.max(value, MIN_TIME_SCALE);
+    // Initialize timing state on start to ensure stable first frame
+    this.isRunning = true;
+    this.currentTime = performance.now() * 0.001;
+    this.accumulator = 0;
+    return this;
+  }
+
+  stop(): this {
+    if (!this.isRunning) {
+      return this;
     }
-
-    start(): this {
-        if (this.isRunning) {
-            return this;
+    this.isRunning = false;
+    return this;
+  }
+
+  setTimeout(callback: Function, delay: number) {
+    const timeOut: Timeout = {callback, callTime: this._gameTime + delay};
+    this.nextTimeoutId++;
+    this.timeouts.set(this.nextTimeoutId, timeOut);
+    return this.nextTimeoutId;
+  }
+
+  setInterval(callback: Function, delay: number) {
+    const timeOut: Timeout = {callback, callTime: this._gameTime + delay, recall: delay};
+    this.nextTimeoutId++;
+    this.timeouts.set(this.nextTimeoutId, timeOut);
+    return this.nextTimeoutId;
+  }
+
+  async fixedTween(duration: number, from: number, to: number, onUpdate: (t: number) => void) {
+    return new Promise<void>((resolve) => {
+      const startTime = this.gameTime;
+
+      const binding = this.onFixedUpdate.add(({time}) => {
+        const t = Math.min(1, (this.gameTime - startTime) / duration);
+        onUpdate(from + (to - from) * t);
+        if (t >= 1) {
+          binding.detach();
+          resolve();
         }
-        this.requestId = requestAnimationFrame(this.update);
-        return this;
-    }
-
-    stop(): this {
-        if (!this.isRunning) {
-            return this;
+      });
+    });
+  }
+
+  async tween(duration: number, from: number, to: number, onUpdate: (t: number) => void) {
+    return new Promise<void>((resolve) => {
+      const startTime = this._animationTime;
+
+      const binding = this.onUpdate.add(({time}) => {
+        const t = Math.min(1, (this._animationTime - startTime) / duration);
+        onUpdate(from + (to - from) * t);
+        if (t >= 1) {
+          binding.detach();
+          resolve();
         }
-        this.isRunning = false;
-        cancelAnimationFrame(this.requestId);
-        return this;
-    }
+      });
+    });
+  }
+
+  clearTimeout(timeoutId: number) {
+    return this.timeouts.delete(timeoutId);
+  }
 }

package/src/ecsInjector.ts

@@ -1,32 +1,43 @@
 // 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';
+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 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}));
+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(entityComponents, entityClass, () => new Map<ComponentClass, string>());
+    const componentSet = putIfAbsent(EcsInjector.entityComponents, entityClass, () => new Map<ComponentClass, string>());
     componentSet.set(componentClass, propertyKey);
 };
 
@@ -42,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)) {
@@ -74,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.`);
@@ -85,6 +108,13 @@ const entityResolver = ({type, kind}: ResolverContext, _dependency: Dependency):
     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.`);
@@ -95,22 +125,32 @@ 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>[]>;
-    private signalMap: Map<ID, Signal>;
+    protected dynamicComponentSystemMap: Map<Class, SystemClass[]>;
+    protected entitySystemResolverTuples: Map<Class, Map<SystemClass, ResolverFunction[]>>;
+    protected registeredClasses = new Set<SystemClass>();
+    private readonly 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>[]>();
+
+        // 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 => {
@@ -118,17 +158,33 @@ export class EcsInjector<SystemClass extends Class = Class> extends Injector {
                 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 = getComponentDependencies(systemClass).map(dependency => dependency.type);
+        if (this.registeredClasses.has(systemClass)) {
+          throw new Error(`System ${systemClass.name} already registered.`);
+        }
+        this.registeredClasses.add(systemClass);
+        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;
         }
@@ -138,39 +194,81 @@ 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})]);
+        if (!systems) {
+            return undefined;
+        }
+
+        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++) {
                 args[i] = resolver[i](systemContext);
             }
 
-            // friend class :)
-            (systemContext as any).system = new system(...args); // TODO: new class(...args) is very slow in firefox :/
+            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], {context: newSystem});
+                }
+            }
 
-            // let systemInstance = new (system.bind(system, args[0], args[1], args[2], args[3], args[4]));
+            // 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>());
     }