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

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2020 Jan Mankopf
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2020 Jan Mankopf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,69 +1,69 @@
-
-#### Use entity component system
-```typescript
-import {EntityComponent, GetComponent, GetEntity, Inject, Injector} from 'mani-injector';
-
-class Service {}
-
-class FooComponent {}
-class BarComponent {}
-
-class FirstEntity {
-    @EntityComponent
-    foo: FooComponent = new FooComponent();
-}
-
-class SecondEntity {
-    @EntityComponent
-    foo: FooComponent = new FooComponent();
-    @EntityComponent
-    bar: BarComponent = new BarComponent();
-}
-
-// this system is created for every entity that has a FooComponent
-class FooSystem {
-    constructor(
-        // get a reference to the component when the system is created for a specific entity
-        @GetComponent readonly foo: FooComponent,
-        // you can get the entity object
-        @GetEntity readonly entity:Object 
-    ) {}
-}
-
-// this system is created for every entity that has a BarComponent
-class BarSystem {
-    constructor(
-        @GetComponent readonly bar: BarComponent,
-    ) {}
-}
-
-// this system is created for every entity that has a FooComponent and a BarComponent
-class FooBarSystem {
-    constructor(
-        @GetComponent readonly foo: FooComponent,
-        @GetComponent readonly bar: BarComponent,
-        // you can inject everything that is mapped in the injector
-        @Inject readonly service: Service 
-    ) {}
-}
-
-
-const injector = new Injector();
-
-injector.registerSystem(FooSystem);
-injector.registerSystem(BarSystem);
-injector.registerSystem(FooBarSystem);
-injector.map(Service).toSingleton();
-
-const entity1 = new FirstEntity();
-const entity2 = new SecondEntity();
-
-// array with one instance of FooSystem with a reference to the component
-console.log(injector.createSystems(entity1));
-
-// array with 3 systems
-// one instance of FooSystem
-// one instance of BarSystem
-// one instance of FooBarSystem
-console.log(injector.createSystems(entity2));
-```
+
+#### Use entity component system
+```typescript
+import {EntityComponent, GetComponent, GetEntity, Inject, Injector} from 'mani-injector';
+
+class Service {}
+
+class FooComponent {}
+class BarComponent {}
+
+class FirstEntity {
+    @EntityComponent
+    foo: FooComponent = new FooComponent();
+}
+
+class SecondEntity {
+    @EntityComponent
+    foo: FooComponent = new FooComponent();
+    @EntityComponent
+    bar: BarComponent = new BarComponent();
+}
+
+// this system is created for every entity that has a FooComponent
+class FooSystem {
+    constructor(
+        // get a reference to the component when the system is created for a specific entity
+        @GetComponent readonly foo: FooComponent,
+        // you can get the entity object
+        @GetEntity readonly entity:Object 
+    ) {}
+}
+
+// this system is created for every entity that has a BarComponent
+class BarSystem {
+    constructor(
+        @GetComponent readonly bar: BarComponent,
+    ) {}
+}
+
+// this system is created for every entity that has a FooComponent and a BarComponent
+class FooBarSystem {
+    constructor(
+        @GetComponent readonly foo: FooComponent,
+        @GetComponent readonly bar: BarComponent,
+        // you can inject everything that is mapped in the injector
+        @Inject readonly service: Service 
+    ) {}
+}
+
+
+const injector = new Injector();
+
+injector.registerSystem(FooSystem);
+injector.registerSystem(BarSystem);
+injector.registerSystem(FooBarSystem);
+injector.map(Service).toSingleton();
+
+const entity1 = new FirstEntity();
+const entity2 = new SecondEntity();
+
+// array with one instance of FooSystem with a reference to the component
+console.log(injector.createSystems(entity1));
+
+// array with 3 systems
+// one instance of FooSystem
+// one instance of BarSystem
+// one instance of FooBarSystem
+console.log(injector.createSystems(entity2));
+```

package/lib/clock.d.ts

@@ -1,40 +1,40 @@
-import { Signal } from 'mani-signal';
-import { OnEarlyUpdateParams, OnFixedUpdateParams, OnUpdateParams } from './types';
-declare const defaultOptions: {
-    autoStart: boolean;
-    fixedDeltaTime: number;
-    maxFrameTime: number;
-    timeScale: number;
-};
-export declare 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 declare class GameClock implements Clock {
-    private isRunning;
-    private requestId;
-    private currentTime;
-    private accumulator;
-    private gameTime;
-    private readonly _fixedDeltaTime;
-    private update;
-    private maxFrameTime;
-    readonly onPrepare: Signal<unknown>;
-    readonly onEarlyUpdate: Signal<OnEarlyUpdateParams>;
-    readonly onUpdate: Signal<OnUpdateParams>;
-    readonly onFixedUpdate: Signal<OnFixedUpdateParams>;
-    constructor(options?: GameClockOptions);
-    get fixedDeltaTime(): number;
-    private _timeScale;
-    get timeScale(): number;
-    set timeScale(value: number);
-    start(): this;
-    stop(): this;
-}
-export {};
+import { Signal } from 'mani-signal';
+import { OnEarlyUpdateParams, OnFixedUpdateParams, OnUpdateParams } from './types';
+declare const defaultOptions: {
+    autoStart: boolean;
+    fixedDeltaTime: number;
+    maxFrameTime: number;
+    timeScale: number;
+};
+export declare 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 declare class GameClock implements Clock {
+    private isRunning;
+    private requestId;
+    private currentTime;
+    private accumulator;
+    private gameTime;
+    private readonly _fixedDeltaTime;
+    private update;
+    private readonly maxFrameTime;
+    readonly onPrepare: Signal<unknown>;
+    readonly onEarlyUpdate: Signal<OnEarlyUpdateParams>;
+    readonly onUpdate: Signal<OnUpdateParams>;
+    readonly onFixedUpdate: Signal<OnFixedUpdateParams>;
+    constructor(options?: GameClockOptions);
+    get fixedDeltaTime(): number;
+    private _timeScale;
+    get timeScale(): number;
+    set timeScale(value: number);
+    start(): this;
+    stop(): this;
+}
+export {};

package/lib/clock.js

@@ -1,80 +1,80 @@
-import { Signal } from 'mani-signal';
-const MIN_TIME_SCALE = 0.00001;
-const defaultOptions = {
-    autoStart: true,
-    fixedDeltaTime: 1 / 60,
-    maxFrameTime: 0.25,
-    timeScale: 1,
-};
-export class GameClock {
-    constructor(options) {
-        this.isRunning = false;
-        this.requestId = 0;
-        this.currentTime = 0;
-        this.accumulator = 0;
-        this.gameTime = 0;
-        this.update = (time) => {
-            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);
-            }
-        };
-        this.onPrepare = new Signal();
-        this.onEarlyUpdate = new Signal();
-        this.onUpdate = new Signal();
-        this.onFixedUpdate = new Signal();
-        this._timeScale = 1;
-        const opts = Object.assign(Object.assign({}, defaultOptions), options);
-        this._fixedDeltaTime = opts.fixedDeltaTime;
-        this.maxFrameTime = opts.maxFrameTime;
-        this.timeScale = opts.timeScale;
-        opts.autoStart && this.start();
-    }
-    get fixedDeltaTime() { return this._fixedDeltaTime; }
-    get timeScale() {
-        return this._timeScale;
-    }
-    set timeScale(value) {
-        this._timeScale = Math.max(value, MIN_TIME_SCALE);
-    }
-    start() {
-        if (this.isRunning) {
-            return this;
-        }
-        this.requestId = requestAnimationFrame(this.update);
-        return this;
-    }
-    stop() {
-        if (!this.isRunning) {
-            return this;
-        }
-        this.isRunning = false;
-        cancelAnimationFrame(this.requestId);
-        return this;
-    }
-}
+import { Signal } from 'mani-signal';
+const MIN_TIME_SCALE = 0.00001;
+const defaultOptions = {
+    autoStart: true,
+    fixedDeltaTime: 1 / 60,
+    maxFrameTime: 0.25,
+    timeScale: 1,
+};
+export class GameClock {
+    constructor(options) {
+        this.isRunning = false;
+        this.requestId = 0;
+        this.currentTime = 0;
+        this.accumulator = 0;
+        this.gameTime = 0;
+        this.update = (time) => {
+            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);
+            }
+        };
+        this.onPrepare = new Signal();
+        this.onEarlyUpdate = new Signal();
+        this.onUpdate = new Signal();
+        this.onFixedUpdate = new Signal();
+        this._timeScale = 1;
+        const opts = Object.assign(Object.assign({}, defaultOptions), options);
+        this._fixedDeltaTime = opts.fixedDeltaTime;
+        this.maxFrameTime = opts.maxFrameTime;
+        this.timeScale = opts.timeScale;
+        opts.autoStart && this.start();
+    }
+    get fixedDeltaTime() { return this._fixedDeltaTime; }
+    get timeScale() {
+        return this._timeScale;
+    }
+    set timeScale(value) {
+        this._timeScale = Math.max(value, MIN_TIME_SCALE);
+    }
+    start() {
+        if (this.isRunning) {
+            return this;
+        }
+        this.requestId = requestAnimationFrame(this.update);
+        return this;
+    }
+    stop() {
+        if (!this.isRunning) {
+            return this;
+        }
+        this.isRunning = false;
+        cancelAnimationFrame(this.requestId);
+        return this;
+    }
+}
 //# sourceMappingURL=clock.js.map

package/lib/ecsInjector.d.ts

@@ -1,26 +1,26 @@
-import { Class, ID, Injector, ResolverFunction } from 'mani-injector';
-import { Signal } from 'mani-signal';
-import { SystemContext } from './systemContext';
-declare type ComponentClass = Class;
-declare type EntityClass = Class;
-declare type SystemResolvers<T extends Class> = [T, ResolverFunction[]];
-export declare const entityComponents: Map<EntityClass, Map<ComponentClass, string>>;
-export declare const GetComponent: (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
-export declare const GetEntity: (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
-export declare const GetContext: (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
-export declare const GetSignal: (id: ID) => (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
-export declare const EntityComponent: (target: object, propertyKey: string) => any;
-export declare const signalHandlers: Map<Object, [string, ID][]>;
-export declare const staticSignalHandlers: Map<Object, [string, ID][]>;
-export declare const OnSignal: (id: ID) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare class EcsInjector<SystemClass extends Class = Class> extends Injector {
-    protected entitySystemMap: Map<Class, SystemClass[]>;
-    protected entitySystemResolverTuples: Map<Class, SystemResolvers<SystemClass>[]>;
-    private signalMap;
-    constructor(parent?: EcsInjector<SystemClass>);
-    registerSystem<T extends SystemClass>(systemClass: T): void;
-    createSystems(entity: Object): SystemContext[];
-    getSignal<T>(id: ID): Signal<T>;
-    dispose(): void;
-}
-export {};
+import { Class, ID, Injector, ResolverFunction } from 'mani-injector';
+import { Signal } from 'mani-signal';
+import { SystemContext } from './systemContext';
+declare type ComponentClass = Class;
+declare type EntityClass = Class;
+declare type SystemResolvers<T extends Class> = [T, ResolverFunction[]];
+export declare const entityComponents: Map<EntityClass, Map<ComponentClass, string>>;
+export declare const GetComponent: (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
+export declare const GetEntity: (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
+export declare const GetContext: (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
+export declare const GetSignal: (id: ID) => (dependantType: Class<any>, _propertyKey: string | symbol, index: number) => any;
+export declare const EntityComponent: (target: object, propertyKey: string) => any;
+export declare const signalHandlers: Map<Object, [string, ID][]>;
+export declare const staticSignalHandlers: Map<Object, [string, ID][]>;
+export declare const OnSignal: (id: ID) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare class EcsInjector<SystemClass extends Class = Class> extends Injector {
+    protected entitySystemMap: Map<Class, SystemClass[]>;
+    protected entitySystemResolverTuples: Map<Class, SystemResolvers<SystemClass>[]>;
+    private signalMap;
+    constructor(parent?: EcsInjector<SystemClass>);
+    registerSystem<T extends SystemClass>(systemClass: T): void;
+    createSystems(entity: Object): SystemContext[];
+    getSignal<T>(id: ID): Signal<T>;
+    dispose(): void;
+}
+export {};