mani-game-engine 1.0.0-pre.5 → 1.0.0-pre.51

package/src/clock.ts

@@ -1,103 +1,163 @@
-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 GameClockOptions = Partial<typeof defaultOptions>;
-
-export class Clock {
-    private isRunning = false;
-    private requestId = 0;
-    private currentTime = 0;
-    private accumulator = 0;
-    private gameTime = 0;
-
-    private _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;
-        }
-
-        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);
-        }
-    };
-
-    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();
-    }
-
-    get fixedDeltaTime(): number { return this._fixedDeltaTime; }
-
-    private _timeScale = 1;
-
-    get timeScale(): number {
-        return this._timeScale;
-    }
-
-    set timeScale(value: number) {
-        this._timeScale = Math.max(value, MIN_TIME_SCALE);
-    }
-
-    start(): this {
-        if (this.isRunning) {
-            return this;
-        }
-        this.requestId = requestAnimationFrame(this.update);
-        return this;
-    }
-
-    stop() {
-        if (!this.isRunning) {
-            return;
-        }
-        this.isRunning = false;
-        cancelAnimationFrame(this.requestId);
-    }
-}
+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 {
+
+    onPrepare: Signal<unknown>;
+    onEarlyUpdate: Signal<OnEarlyUpdateParams>;
+    onUpdate: Signal<OnUpdateParams>;
+    onFixedUpdate: Signal<OnFixedUpdateParams>;
+    timeScale: number;
+    start(): this;
+    stop(): this;
+    dispose(): void;
+    setTimeout(callback: Function, delay: number): number;
+    setInterval(callback: Function, delay: number): number;
+    clearTimeout(timeoutId: number): boolean;
+}
+
+export class GameClock implements Clock {
+    private nextTimeoutId = 0;
+    private timeouts = new Map<number, Timeout>();
+    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;
+        }
+
+        this.currentTime = newTime;
+        this.accumulator += frameTime;
+        let isMultipleFixedUpdate = false;
+
+        this.onPrepare.dispatch();
+        this.onEarlyUpdate.dispatch({time: this.gameTime, deltaTime: frameTime});
+
+        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);
+                }
+            }
+        }
+
+        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);
+        }
+    };
+
+    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 {
+        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) {
+        this._timeScale = Math.max(value, MIN_TIME_SCALE);
+    }
+
+    start(): this {
+        if (this.isRunning) {
+            return this;
+        }
+        this.requestId = requestAnimationFrame(this.update);
+        return this;
+    }
+
+    stop(): this {
+        if (!this.isRunning) {
+            return this;
+        }
+        this.isRunning = false;
+        cancelAnimationFrame(this.requestId);
+        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;
+    }
+
+    clearTimeout(timeoutId: number) {
+        return this.timeouts.delete(timeoutId);
+    }
+}