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

package/package.json

@@ -1,45 +1,39 @@
-{
-  "name": "mani-game-engine",
-  "author": "Jan Mankopf",
-  "version": "1.0.0-pre.4",
-  "description": "entity component system game engine for typescript",
-  "private": false,
-  "scripts": {
-    "build": "rimraf lib && tsc",
-    "watch": "rimraf lib && tsc -w",
-    "test": "jest",
-    "test watch": "jest --watch",
-    "do-pre-publish": "npm publish --dry-run",
-    "do-publish": "npm publish",
-    "testme": "mocha --experimental-modules -r ts-node/register tests/**/*.spec.ts "
-  },
-  "main": "lib/index.js",
-  "files": [
-    "lib/*",
-    "src/*"
-  ],
-  "typings": "lib/index.d.ts",
-  "license": "MIT",
-  "devDependencies": {
-    "@fluffy-spoon/substitute": "^1.88.0",
-    "@types/jest": "^24.0.13",
-    "chai": "^4.2.0",
-    "jasmine-core": "^3.4.0",
-    "jest": "^24.8.0",
-    "mani-signal": "^1.0.3",
-    "mocha": "^6.1.4",
-    "nyc": "^14.1.1",
-    "reflect-metadata": "^0.1.13",
-    "rimraf": "^2.6.3",
-    "ts-jest": "^24.0.2",
-    "ts-node": "^8.2.0",
-    "typescript": "^3.5.1"
-  },
-  "peerDependencies": {
-    "mani-signal": "^1.0.3",
-    "reflect-metadata": "^0.1.13"
-  },
-  "dependencies": {
-    "mani-injector": "^0.0.2"
-  }
-}
+{
+  "name": "mani-game-engine",
+  "author": "Jan Mankopf",
+  "version": "1.0.0-pre.41",
+  "description": "entity component system game engine for typescript",
+  "private": false,
+  "scripts": {
+    "build": "rimraf lib && tsc",
+    "watch": "tsc -w",
+    "test": "jest",
+    "test watch": "jest --watch",
+    "do-pre-publish": "npm publish --dry-run",
+    "version-up": "npm version prerelease",
+    "do-publish": "npm publish"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "lib/*",
+    "src/*"
+  ],
+  "typings": "lib/index.d.ts",
+  "license": "MIT",
+  "devDependencies": {
+    "@fluffy-spoon/substitute": "^1.208.0",
+    "@types/jest": "^29.2.3",
+    "jest": "^29.3.1",
+    "reflect-metadata": "^0.1.13",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.4.1",
+    "typescript": "^4.9.3",
+    "mani-signal": "^1.0.6"
+  },
+  "peerDependencies": {
+    "reflect-metadata": "^0.1.13",
+    "mani-signal": "^1.0.6"
+  }
+}

package/src/clock.ts

@@ -1,102 +1,163 @@
-import {Signal} from 'mani-signal';
-
-const MIN_TIME_SCALE = 0.00001;
-
-type OnEarlyUpdateParams = { time: number, deltaTime: number };
-type OnUpdateParams = { time: number, deltaTime: number, alpha: number; };
-type OnFixedUpdateParams = { time: number, deltaTime: 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 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();
-    }
-
-    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 _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);
+    }
+}