dacha 0.14.2 → 0.14.3

package/build/engine/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_FIXED_UPDATE_RATE = 50;
+export declare const DEFAULT_MAX_FPS: number;

package/build/engine/consts.js

@@ -0,0 +1,2 @@
+export const DEFAULT_FIXED_UPDATE_RATE = 50;
+export const DEFAULT_MAX_FPS = Infinity;

package/build/engine/engine.js

@@ -30,7 +30,7 @@ export class Engine {
             this.addWindowListeners();
             return;
         }
-        const { config: { templates, scenes, levels, loaders, startSceneId, startLoaderId, globalOptions, }, systems, components, resources = {}, } = this.options;
+        const { config: { templates, scenes, levels, loaders, startSceneId, startLoaderId, globalOptions: rawGlobalOptions, }, systems, components, resources = {}, } = this.options;
         if (!startSceneId) {
             throw new Error('Can\'t start the engine without starting scene. Please specify start scene id.');
         }
@@ -49,6 +49,10 @@ export class Engine {
             templateCollection.register(templates[i]);
         }
         const actorCreator = new ActorCreator(components, templateCollection);
+        const globalOptions = rawGlobalOptions.reduce((acc, option) => {
+            acc[option.name] = option.options;
+            return acc;
+        }, {});
         this.sceneProvider = new SceneProvider({
             scenes,
             levels,
@@ -71,7 +75,7 @@ export class Engine {
         }
         this.gameLoop = new GameLoop(this.sceneProvider, [
             new SceneController({ sceneProvider: this.sceneProvider }),
-        ]);
+        ], globalOptions.performance);
         this.gameLoop.run();
         this.addWindowListeners();
     }

package/build/engine/game-loop.d.ts

@@ -1,13 +1,19 @@
 import type { SceneProvider } from './scene';
 import type { Controller } from './controllers';
+export interface PerformanceSettings {
+    maxFPS: number;
+    fixedUpdateRate: number;
+}
 export declare class GameLoop {
     private sceneProvider;
     private controllers;
+    private msPerUpdate;
+    private msPerFixedUpdate;
     private gameLoopId;
     private previous;
     private lag;
     private bindedTick;
-    constructor(sceneProvider: SceneProvider, controllers: Array<Controller>);
+    constructor(sceneProvider: SceneProvider, controllers: Controller[], performance?: PerformanceSettings);
     private tick;
     run(): void;
     stop(): void;

package/build/engine/game-loop.js

@@ -1,32 +1,41 @@
 import { eventQueue } from './event-target';
-const MS_PER_UPDATE = 1000 / 50;
+const DEFAULT_FIXED_UPDATE_RATE = 50;
+const DEFAULT_MAX_FPS = Infinity;
 export class GameLoop {
     sceneProvider;
     controllers;
+    msPerUpdate;
+    msPerFixedUpdate;
     gameLoopId;
     previous;
     lag;
     bindedTick;
-    constructor(sceneProvider, controllers) {
+    constructor(sceneProvider, controllers, performance) {
         this.sceneProvider = sceneProvider;
         this.controllers = controllers;
+        this.msPerUpdate = 1000 / (performance?.maxFPS || DEFAULT_MAX_FPS);
+        this.msPerFixedUpdate = 1000 / (performance?.fixedUpdateRate || DEFAULT_FIXED_UPDATE_RATE);
         this.gameLoopId = 0;
         this.previous = 0;
         this.lag = 0;
         this.bindedTick = this.tick.bind(this);
     }
     tick() {
-        eventQueue.update();
+        this.gameLoopId = requestAnimationFrame(this.bindedTick);
         const current = performance.now();
         const elapsed = current - this.previous;
+        if (elapsed < this.msPerUpdate) {
+            return;
+        }
         this.lag += elapsed;
+        eventQueue.update();
         const currentScene = this.sceneProvider.getCurrentScene();
-        const fixedUpdateOptions = { deltaTime: MS_PER_UPDATE };
-        while (this.lag >= MS_PER_UPDATE) {
+        const fixedUpdateOptions = { deltaTime: this.msPerFixedUpdate };
+        while (this.lag >= this.msPerFixedUpdate) {
             currentScene?.systems.forEach((system) => {
                 system.fixedUpdate?.(fixedUpdateOptions);
             });
-            this.lag -= MS_PER_UPDATE;
+            this.lag -= this.msPerFixedUpdate;
         }
         const options = { deltaTime: elapsed };
         currentScene?.systems.forEach((system) => {
@@ -36,7 +45,6 @@ export class GameLoop {
             controller.update();
         });
         this.previous = current;
-        this.gameLoopId = requestAnimationFrame(this.bindedTick);
     }
     run() {
         this.previous = performance.now();

package/build/engine/scene/scene-provider.d.ts

@@ -1,4 +1,4 @@
-import type { SceneConfig, LevelConfig, GlobalOption } from '../types';
+import type { SceneConfig, LevelConfig } from '../types';
 import type { ActorCreator } from '../actor';
 import type { SystemConstructor } from '../system';
 import type { TemplateCollection } from '../template';
@@ -9,7 +9,7 @@ interface SceneProviderOptions {
     levels: Array<LevelConfig>;
     systems: Array<SystemConstructor>;
     resources: Record<string, unknown>;
-    globalOptions: Array<GlobalOption>;
+    globalOptions: Record<string, unknown>;
     actorCreator: ActorCreator;
     templateCollection: TemplateCollection;
 }

package/build/engine/scene/scene-provider.js

@@ -28,10 +28,7 @@ export class SceneProvider {
         }, {});
         this.systems = systems;
         this.resources = resources;
-        this.globalOptions = globalOptions.reduce((acc, option) => {
-            acc[option.name] = option.options;
-            return acc;
-        }, {});
+        this.globalOptions = globalOptions;
         this.loadedScene = void 0;
         this.actorCreator = actorCreator;
         this.templateCollection = templateCollection;

package/build/index.d.ts

@@ -1,6 +1,7 @@
 export { Engine } from './engine';
 export { Component } from './engine/component';
 export { VectorOps, MathOps, Vector2 } from './engine/math-lib';
+export * from './engine/consts';
 export * from './engine/types';
 export { System } from './engine/system';
 export type { SystemOptions, UpdateOptions, } from './engine/system';

package/build/index.js

@@ -1,6 +1,7 @@
 export { Engine } from './engine';
 export { Component } from './engine/component';
 export { VectorOps, MathOps, Vector2 } from './engine/math-lib';
+export * from './engine/consts';
 export * from './engine/types';
 export { System } from './engine/system';
 export * as Animation from './contrib/components/animatable/types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dacha",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "exports": {