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

package/src/clock.ts

@@ -0,0 +1,205 @@
+import {Signal} from 'mani-signal';
+import {OnEarlyUpdateParams, OnFixedUpdateParams, OnUpdateParams} from './types';
+
+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,
+};
+
+export type Timeout = {
+  recall?: number;
+  callback: Function;
+  callTime: number;
+};
+export type GameClockOptions = Partial<typeof defaultOptions>;
+
+export interface Clock {
+  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 {
+  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;
+    }
+
+    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);
+          }
+        }
+      }
+      this.onFixedUpdate.dispatch({time: this._gameTime, deltaTime: this._fixedDeltaTime});
+      this.accumulator -= this._fixedDeltaTime;
+      this._gameTime += this._fixedDeltaTime;
+    }
+    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;
+    }
+    // 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;
+    }
+    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();
+        }
+      });
+    });
+  }
+
+  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();
+        }
+      });
+    });
+  }
+
+  clearTimeout(timeoutId: number) {
+    return this.timeouts.delete(timeoutId);
+  }
+}

package/src/ecsInjector.ts

@@ -0,0 +1,282 @@
+// 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[]>>;
+    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>();
+
+        // 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) {
+        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 && 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)!;
+
+        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 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], {context: 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();
+        }
+    }
+}