mani-game-engine 1.0.0-pre.12 → 1.0.0-pre.15

package/lib/systemContext.d.ts

@@ -1,12 +1,12 @@
-import { System } from './types';
-import { Signal, SignalCallback } from './index';
-export declare class SystemContext<T extends System = System> {
-    readonly entity: Object;
-    readonly system: T;
-    private signalBindings;
-    constructor(entity: Object);
-    addSignalById<S>(signalId: string | symbol, callback: SignalCallback<S>, thisArg?: unknown): void;
-    addSignal<S>(signal: Signal<S>, callback: SignalCallback<S>, thisArg?: unknown): void;
-    addSignalOnce<S>(signal: Signal<S>, callback: SignalCallback<S>, thisArg?: unknown): void;
-    dispose(): void;
-}
+import { System } from './types';
+import { Signal, SignalCallback } from './index';
+export declare class SystemContext<T extends System = System> {
+    readonly entity: Object;
+    readonly system: T;
+    private signalBindings;
+    constructor(entity: Object);
+    addSignalById<S>(signalId: string | symbol, callback: SignalCallback<S>, thisArg?: unknown): void;
+    addSignal<S>(signal: Signal<S>, callback: SignalCallback<S>, thisArg?: unknown): void;
+    addSignalOnce<S>(signal: Signal<S>, callback: SignalCallback<S>, thisArg?: unknown): void;
+    dispose(): void;
+}

package/lib/systemContext.js

@@ -1,20 +1,20 @@
-export class SystemContext {
-    constructor(entity) {
-        this.entity = entity;
-        this.signalBindings = [];
-    }
-    addSignalById(signalId, callback, thisArg) {
-        this.signalBindings.push(this.entity.gameEngine.getSignal(signalId).add(callback, thisArg));
-    }
-    addSignal(signal, callback, thisArg) {
-        this.signalBindings.push(signal.add(callback, thisArg));
-    }
-    addSignalOnce(signal, callback, thisArg) {
-        this.signalBindings.push(signal.addOnce(callback, thisArg));
-    }
-    dispose() {
-        for (const binding of this.signalBindings)
-            binding.detach();
-    }
-}
+export class SystemContext {
+    constructor(entity) {
+        this.entity = entity;
+        this.signalBindings = [];
+    }
+    addSignalById(signalId, callback, thisArg) {
+        this.signalBindings.push(this.entity.gameEngine.getSignal(signalId).add(callback, thisArg));
+    }
+    addSignal(signal, callback, thisArg) {
+        this.signalBindings.push(signal.add(callback, thisArg));
+    }
+    addSignalOnce(signal, callback, thisArg) {
+        this.signalBindings.push(signal.addOnce(callback, thisArg));
+    }
+    dispose() {
+        for (const binding of this.signalBindings)
+            binding.detach();
+    }
+}
 //# sourceMappingURL=systemContext.js.map

package/lib/types.d.ts

@@ -1,69 +1,69 @@
-import { GameEngine } from './gameEngine';
-export interface System {
-    [propName: string]: any;
-    onPrepare?(): Promise<void>;
-    onStart?(): void;
-    onEnd?(): void;
-    onPreFixedUpdate?(time: number, deltaTime: number): void;
-    onEarlyUpdate?(time: number, deltaTime: number): void;
-    onFixedUpdate?(time: number, deltaTime: number): void;
-    onPhysicsUpdate?(time: number, deltaTime: number): void;
-    onUpdate?(time: number, deltaTime: number, alpha: number): void;
-    onLateUpdate?(time: number, deltaTime: number, alpha: number): void;
-    onPostPhysicsUpdate?(time: number, deltaTime: number): void;
-    onLateFixedUpdate?(time: number, deltaTime: number): void;
-    onRender?(time: number, deltaTime: number, alpha: number): void;
-}
-export interface Service {
-    [propName: string]: any;
-    onPrepare?(): Promise<void>;
-    onStart?(): void;
-    onEnd?(): void;
-    onPreFixedUpdate?(time: number, deltaTime: number): void;
-    onPostPhysicsUpdate?(time: number, deltaTime: number): void;
-    onLateFixedUpdate?(time: number, deltaTime: number): void;
-    onFixedUpdate?(time: number, deltaTime: number): void;
-    onPhysicsUpdate?(time: number, deltaTime: number): void;
-    onUpdate?(time: number, deltaTime: number, alpha: number): void;
-    onLateUpdate?(time: number, deltaTime: number, alpha: number): void;
-    onRender?(): void;
-}
-declare type GameEngineCallback = (gameEngine: GameEngine) => void;
-export interface GameEnginePlugin {
-    onPrepare?: GameEngineCallback;
-    onStart?: GameEngineCallback;
-}
-export interface CommandClass {
-    name?: string;
-    new (...args: any[]): any;
-}
-export declare type OnUpdateParams = {
-    time: number;
-    deltaTime: number;
-    alpha: number;
-};
-export declare type OnFixedUpdateParams = {
-    time: number;
-    deltaTime: number;
-};
-export declare type OnEarlyUpdateParams = {
-    time: number;
-    deltaTime: number;
-};
-export declare type AsyncAction<T = unknown> = (gameEngine: GameEngine) => Promise<T>;
-export declare type Action<T = any> = (gameEngine: GameEngine) => T;
-export declare type Class<T = any> = {
-    new (...args: any[]): T;
-};
-export declare const EngineSignals: {
-    OnStart: symbol;
-    OnUpdate: symbol;
-    OnLateUpdate: symbol;
-    OnFixedUpdate: symbol;
-    OnPrePhysics: symbol;
-    OnPostPhysics: symbol;
-    onLateFixedUpdate: symbol;
-    OnRender: symbol;
-    OnPrepare: symbol;
-};
-export {};
+import { GameEngine } from './gameEngine';
+export interface System {
+    [propName: string]: any;
+    onPrepare?(): Promise<void>;
+    onStart?(): void;
+    onEnd?(): void;
+    onPreFixedUpdate?(time: number, deltaTime: number): void;
+    onEarlyUpdate?(time: number, deltaTime: number): void;
+    onFixedUpdate?(time: number, deltaTime: number): void;
+    onPhysicsUpdate?(time: number, deltaTime: number): void;
+    onUpdate?(time: number, deltaTime: number, alpha: number): void;
+    onLateUpdate?(time: number, deltaTime: number, alpha: number): void;
+    onPostPhysicsUpdate?(time: number, deltaTime: number): void;
+    onLateFixedUpdate?(time: number, deltaTime: number): void;
+    onRender?(time: number, deltaTime: number, alpha: number): void;
+}
+export interface Service {
+    [propName: string]: any;
+    onPrepare?(): Promise<void>;
+    onStart?(): void;
+    onEnd?(): void;
+    onPreFixedUpdate?(time: number, deltaTime: number): void;
+    onPostPhysicsUpdate?(time: number, deltaTime: number): void;
+    onLateFixedUpdate?(time: number, deltaTime: number): void;
+    onFixedUpdate?(time: number, deltaTime: number): void;
+    onPhysicsUpdate?(time: number, deltaTime: number): void;
+    onUpdate?(time: number, deltaTime: number, alpha: number): void;
+    onLateUpdate?(time: number, deltaTime: number, alpha: number): void;
+    onRender?(time: number, deltaTime: number, alpha: number): void;
+}
+declare type GameEngineCallback = (gameEngine: GameEngine) => void;
+export interface GameEnginePlugin {
+    onPrepare?: GameEngineCallback;
+    onStart?: GameEngineCallback;
+}
+export interface CommandClass {
+    name?: string;
+    new (...args: any[]): any;
+}
+export declare type OnUpdateParams = {
+    time: number;
+    deltaTime: number;
+    alpha: number;
+};
+export declare type OnFixedUpdateParams = {
+    time: number;
+    deltaTime: number;
+};
+export declare type OnEarlyUpdateParams = {
+    time: number;
+    deltaTime: number;
+};
+export declare type AsyncAction<T = unknown> = (gameEngine: GameEngine) => Promise<T>;
+export declare type Action<T = any> = (gameEngine: GameEngine) => T;
+export declare type Class<T = any> = {
+    new (...args: any[]): T;
+};
+export declare const EngineSignals: {
+    OnStart: symbol;
+    OnUpdate: symbol;
+    OnLateUpdate: symbol;
+    OnFixedUpdate: symbol;
+    OnPrePhysics: symbol;
+    OnPostPhysics: symbol;
+    onLateFixedUpdate: symbol;
+    OnRender: symbol;
+    OnPrepare: symbol;
+};
+export {};

package/lib/types.js

@@ -1,12 +1,12 @@
-export const EngineSignals = {
-    OnStart: Symbol('OnStart'),
-    OnUpdate: Symbol('OnUpdate'),
-    OnLateUpdate: Symbol('OnLateUpdate'),
-    OnFixedUpdate: Symbol('OnFixedUpdate'),
-    OnPrePhysics: Symbol('OnPostPhysics'),
-    OnPostPhysics: Symbol('OnPostPhysics'),
-    onLateFixedUpdate: Symbol('OnPrepare'),
-    OnRender: Symbol('OnRender'),
-    OnPrepare: Symbol('OnPrepare'),
-};
+export const EngineSignals = {
+    OnStart: Symbol('OnStart'),
+    OnUpdate: Symbol('OnUpdate'),
+    OnLateUpdate: Symbol('OnLateUpdate'),
+    OnFixedUpdate: Symbol('OnFixedUpdate'),
+    OnPrePhysics: Symbol('OnPostPhysics'),
+    OnPostPhysics: Symbol('OnPostPhysics'),
+    onLateFixedUpdate: Symbol('OnPrepare'),
+    OnRender: Symbol('OnRender'),
+    OnPrepare: Symbol('OnPrepare'),
+};
 //# sourceMappingURL=types.js.map

package/lib/utils/map2k.d.ts

@@ -1,6 +1,6 @@
-export declare class Map2k<K, V> {
-    map: Map<K, Map<K, V>>;
-    set(key1: K, key2: K, value: V): void;
-    get(key1: K, key2: K): V | undefined;
-    delete(key1: K, key2: K): void;
-}
+export declare class Map2k<K, V> {
+    map: Map<K, Map<K, V>>;
+    set(key1: K, key2: K, value: V): void;
+    get(key1: K, key2: K): V | undefined;
+    delete(key1: K, key2: K): void;
+}

package/lib/utils/map2k.js

@@ -1,40 +1,40 @@
-export class Map2k {
-    constructor() {
-        this.map = new Map();
-    }
-    set(key1, key2, value) {
-        let first = this.map.get(key1);
-        if (!first) {
-            first = new Map();
-            this.map.set(key1, first);
-        }
-        let second = this.map.get(key2);
-        if (!second) {
-            second = new Map();
-            this.map.set(key2, second);
-        }
-        first.set(key2, value);
-        second.set(key1, value);
-    }
-    get(key1, key2) {
-        const first = this.map.get(key1);
-        return first && first.get(key2);
-    }
-    delete(key1, key2) {
-        let first = this.map.get(key1);
-        if (first) {
-            first.delete(key2);
-            if (first.size === 0) {
-                this.map.delete(key1);
-            }
-        }
-        let second = this.map.get(key2);
-        if (second) {
-            second.delete(key1);
-            if (second.size === 0) {
-                this.map.delete(key2);
-            }
-        }
-    }
-}
+export class Map2k {
+    constructor() {
+        this.map = new Map();
+    }
+    set(key1, key2, value) {
+        let first = this.map.get(key1);
+        if (!first) {
+            first = new Map();
+            this.map.set(key1, first);
+        }
+        let second = this.map.get(key2);
+        if (!second) {
+            second = new Map();
+            this.map.set(key2, second);
+        }
+        first.set(key2, value);
+        second.set(key1, value);
+    }
+    get(key1, key2) {
+        const first = this.map.get(key1);
+        return first && first.get(key2);
+    }
+    delete(key1, key2) {
+        let first = this.map.get(key1);
+        if (first) {
+            first.delete(key2);
+            if (first.size === 0) {
+                this.map.delete(key1);
+            }
+        }
+        let second = this.map.get(key2);
+        if (second) {
+            second.delete(key1);
+            if (second.size === 0) {
+                this.map.delete(key2);
+            }
+        }
+    }
+}
 //# sourceMappingURL=map2k.js.map

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "mani-game-engine",
-  "author": "Jan Mankopf",
-  "version": "1.0.0-pre.12",
-  "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.201.0",
-    "@types/jest": "^26.0.22",
-    "jest": "^26.6.3",
-    "reflect-metadata": "^0.1.13",
-    "rimraf": "^3.0.2",
-    "ts-jest": "^26.5.4",
-    "ts-node": "^9.1.1",
-    "tslib": "^2.2.0",
-    "typescript": "^4.2.4"
-  },
-  "peerDependencies": {
-    "reflect-metadata": "^0.1.13"
-  },
-  "dependencies": {
-    "mani-injector": "0.0.3",
-    "mani-signal": "^1.0.6"
-  }
-}
+{
+  "name": "mani-game-engine",
+  "author": "Jan Mankopf",
+  "version": "1.0.0-pre.15",
+  "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.201.0",
+    "@types/jest": "^26.0.22",
+    "jest": "^26.6.3",
+    "reflect-metadata": "^0.1.13",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^26.5.4",
+    "ts-node": "^9.1.1",
+    "tslib": "^2.2.0",
+    "typescript": "^4.2.4"
+  },
+  "peerDependencies": {
+    "reflect-metadata": "^0.1.13"
+  },
+  "dependencies": {
+    "mani-injector": "0.0.3",
+    "mani-signal": "^1.0.6"
+  }
+}

package/src/clock.ts

@@ -1,115 +1,115 @@
-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 interface Clock {
-
-    onPrepare: Signal<unknown>;
-    onEarlyUpdate: Signal<OnEarlyUpdateParams>;
-    onUpdate: Signal<OnUpdateParams>;
-    onFixedUpdate: Signal<OnFixedUpdateParams>;
-    timeScale: number;
-    start(): this;
-    stop(): this;
-}
-
-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;
-        }
-
-        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(): this {
-        if (!this.isRunning) {
-            return this;
-        }
-        this.isRunning = false;
-        cancelAnimationFrame(this.requestId);
-        return this;
-    }
-}
+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 interface Clock {
+
+    onPrepare: Signal<unknown>;
+    onEarlyUpdate: Signal<OnEarlyUpdateParams>;
+    onUpdate: Signal<OnUpdateParams>;
+    onFixedUpdate: Signal<OnFixedUpdateParams>;
+    timeScale: number;
+    start(): this;
+    stop(): this;
+}
+
+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;
+        }
+
+        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 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();
+    }
+
+    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;
+    }
+}