dacha 0.18.0-alpha.8 → 0.18.0

package/build/contrib/systems/renderer/material/index.d.ts

@@ -1,4 +1,5 @@
-import type { ViewComponent, Time } from '../types';
+import type { Time } from '../../../../engine/time';
+import type { ViewComponent } from '../types';
 import type { ShaderConstructor, MaterialConfig } from './shader';
 interface MaterialSystemOptions {
     shaders?: ShaderConstructor[];

package/build/contrib/systems/renderer/material/index.js

@@ -68,7 +68,7 @@ export class MaterialSystem {
             meta.materialSampler = view.texture.source;
             view.shader.resources.uSampler = view.texture.source;
         }
-        view.shader.resources.uniformsGroup.uniforms.uTime = this.time.elapsed;
+        view.shader.resources.uniformsGroup.uniforms.uTime = this.time.elapsedTime;
         view.shader.resources.uniformsGroup.uniforms.uAlpha =
             view.getGlobalAlpha(true);
         const tint = view.getGlobalTint(true);

package/build/contrib/systems/renderer/renderer.d.ts

@@ -1,4 +1,4 @@
-import { WorldSystem, type WorldSystemOptions, type UpdateOptions } from '../../../engine/system';
+import { WorldSystem, type WorldSystemOptions } from '../../../engine/system';
 import { type Scene } from '../../../engine/scene';
 /**
  * Renderer system that manages 2D graphics rendering using PIXI.js under the hood
@@ -30,5 +30,5 @@ export declare class Renderer extends WorldSystem {
     onSceneExit(): void;
     onSceneDestroy(scene: Scene): void;
     private updateCamera;
-    update(options: UpdateOptions): void;
+    update(): void;
 }

package/build/contrib/systems/renderer/renderer.js

@@ -36,7 +36,8 @@ export class Renderer extends WorldSystem {
     rendererApi;
     constructor(options) {
         super();
-        const { globalOptions, windowNodeId, backgroundColor, templateCollection, world, resources, filterEffects, } = options;
+        const { globalOptions, windowNodeId, backgroundColor, templateCollection, world, resources, filterEffects, time, } = options;
+        this.time = time;
         this.backgroundColor = new Color(backgroundColor);
         this.window = getWindowNode(windowNodeId);
         this.resources = resources;
@@ -56,7 +57,6 @@ export class Renderer extends WorldSystem {
         this.application = new Application();
         this.worldContainer = new Container();
         this.assets = new Assets({ templateCollection });
-        this.time = { elapsed: 0 };
         this.materialSystem = new MaterialSystem({
             shaders: this.resources?.shaders,
             time: this.time,
@@ -137,8 +137,7 @@ export class Renderer extends WorldSystem {
         this.worldContainer.position.set(this.application.renderer.width / 2, this.application.renderer.height / 2);
         this.worldContainer.pivot.set(x, y);
     }
-    update(options) {
-        this.time.elapsed += options.deltaTime / 1000;
+    update() {
         this.updateCamera();
         this.actorRenderTree?.update();
         this.filterSystem.update();

package/build/contrib/systems/renderer/types.d.ts

@@ -29,6 +29,3 @@ export interface RendererResources {
     filterEffects?: FilterEffectConstructor[];
     shaders?: ShaderConstructor[];
 }
-export interface Time {
-    elapsed: number;
-}

package/build/engine/data-lib/index.d.ts

@@ -1,3 +1,3 @@
 export { Queue } from './queue';
 export { CacheStore } from './cache-store';
-export { insertionSort } from './sort';
+export { Pool } from './pool';

package/build/engine/data-lib/index.js

@@ -1,3 +1,3 @@
 export { Queue } from './queue';
 export { CacheStore } from './cache-store';
-export { insertionSort } from './sort';
+export { Pool } from './pool';

package/build/engine/data-lib/pool.d.ts

@@ -0,0 +1,9 @@
+export declare class Pool<T> {
+    private factory;
+    private reset?;
+    private items;
+    constructor(factory: () => T, reset?: ((item: T) => void) | undefined);
+    acquire(): T;
+    release(item: T): void;
+    clear(): void;
+}

package/build/engine/data-lib/pool.js

@@ -0,0 +1,19 @@
+export class Pool {
+    factory;
+    reset;
+    items = [];
+    constructor(factory, reset) {
+        this.factory = factory;
+        this.reset = reset;
+    }
+    acquire() {
+        return this.items.pop() ?? this.factory();
+    }
+    release(item) {
+        this.reset?.(item);
+        this.items.push(item);
+    }
+    clear() {
+        this.items.length = 0;
+    }
+}

package/build/engine/engine.js

@@ -1,6 +1,7 @@
 import { SceneManager } from './scene/scene-manager';
 import { TemplateCollection } from './template';
 import { GameLoop } from './game-loop';
+import { Time } from './time';
 /**
  * Main game engine responsible for bootstrapping scenes and systems, managing the
  * game loop, and controlling lifecycle actions (play, pause, stop).
@@ -60,6 +61,7 @@ export class Engine {
             acc[option.name] = option.options;
             return acc;
         }, {});
+        const time = new Time();
         this.sceneManager = new SceneManager({
             sceneConfigs: scenes,
             systemConfigs: systems,
@@ -68,10 +70,11 @@ export class Engine {
             templateCollection,
             globalOptions,
             resources,
+            time,
         });
         await this.sceneManager.loadWorld();
         await this.sceneManager.loadScene(startSceneId, true);
-        this.gameLoop = new GameLoop(this.sceneManager, globalOptions.performance);
+        this.gameLoop = new GameLoop(this.sceneManager, time, globalOptions.performance);
         this.gameLoop.run();
     }
     /**

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

@@ -1,4 +1,5 @@
 import type { SceneManager } from './scene';
+import type { Time } from './time';
 export interface PerformanceSettings {
     maxFPS?: number;
     fixedUpdateRate?: number;
@@ -7,6 +8,7 @@ export interface PerformanceSettings {
 }
 export declare class GameLoop {
     private sceneManager;
+    private time;
     private msPerUpdate;
     private msPerFixedUpdate;
     private maxFrameDelta;
@@ -15,7 +17,7 @@ export declare class GameLoop {
     private previous;
     private lag;
     private bindedTick;
-    constructor(sceneManager: SceneManager, performance?: PerformanceSettings);
+    constructor(sceneManager: SceneManager, time: Time, performance?: PerformanceSettings);
     private tick;
     run(): void;
     stop(): void;

package/build/engine/game-loop.js

@@ -2,6 +2,7 @@ import { eventQueue } from './event-target';
 import { DEFAULT_FIXED_UPDATE_RATE, DEFAULT_MAX_FPS, DEFAULT_MAX_FRAME_DELTA, DEFAULT_MAX_FIXED_UPDATES_PER_FRAME, } from './consts';
 export class GameLoop {
     sceneManager;
+    time;
     msPerUpdate;
     msPerFixedUpdate;
     maxFrameDelta;
@@ -10,8 +11,9 @@ export class GameLoop {
     previous;
     lag;
     bindedTick;
-    constructor(sceneManager, performance) {
+    constructor(sceneManager, time, performance) {
         this.sceneManager = sceneManager;
+        this.time = time;
         this.msPerUpdate = 1000 / (performance?.maxFPS || DEFAULT_MAX_FPS);
         this.msPerFixedUpdate =
             1000 / (performance?.fixedUpdateRate || DEFAULT_FIXED_UPDATE_RATE);
@@ -19,27 +21,27 @@ export class GameLoop {
         this.maxFixedUpdatesPerFrame =
             performance?.maxFixedUpdatesPerFrame ||
                 DEFAULT_MAX_FIXED_UPDATES_PER_FRAME;
+        this.time.fixedDeltaTime = this.msPerFixedUpdate / 1000;
         this.gameLoopId = 0;
         this.previous = 0;
         this.lag = 0;
         this.bindedTick = this.tick.bind(this);
     }
-    tick() {
+    tick(timestamp) {
         this.gameLoopId = requestAnimationFrame(this.bindedTick);
-        const current = performance.now();
-        const elapsed = Math.min(current - this.previous, this.maxFrameDelta);
+        const current = timestamp;
+        const elapsed = Math.min(Math.max(current - this.previous, 0), this.maxFrameDelta);
         if (elapsed < this.msPerUpdate) {
             return;
         }
         this.lag += elapsed;
         eventQueue.update();
         const systems = this.sceneManager.getSystems();
-        const fixedUpdateOptions = { deltaTime: this.msPerFixedUpdate };
         let fixedUpdates = 0;
         while (this.lag >= this.msPerFixedUpdate &&
             fixedUpdates < this.maxFixedUpdatesPerFrame) {
             systems.forEach((system) => {
-                system.fixedUpdate?.(fixedUpdateOptions);
+                system.fixedUpdate?.();
             });
             this.lag -= this.msPerFixedUpdate;
             fixedUpdates += 1;
@@ -47,9 +49,9 @@ export class GameLoop {
         if (fixedUpdates === this.maxFixedUpdatesPerFrame) {
             this.lag = 0;
         }
-        const options = { deltaTime: elapsed };
+        this.time._tick(elapsed / 1000, this.lag / this.msPerFixedUpdate);
         systems.forEach((system) => {
-            system.update?.(options);
+            system.update?.();
         });
         if (this.msPerUpdate > 0) {
             this.previous = current - (elapsed % this.msPerUpdate);
@@ -64,6 +66,7 @@ export class GameLoop {
         }
         this.previous = performance.now();
         this.lag = 0;
+        this.time._reset();
         this.gameLoopId = requestAnimationFrame(this.bindedTick);
     }
     stop() {

package/build/engine/math-lib/math/ops.d.ts

@@ -118,4 +118,20 @@ export declare class MathOps {
      * ```
      */
     static clamp(value: number, min: number, max: number): number;
+    /**
+     * Signed shortest angular difference between two angles in radians
+     *
+     * The result is in (-PI, PI], so `from + delta` is angle-equivalent
+     * to `to` while rotating the short way around.
+     *
+     * @param from - Start angle in radians
+     * @param to - End angle in radians
+     * @returns Signed delta in radians
+     *
+     * @example
+     * ```typescript
+     * const delta = MathOps.getAngleDelta(3, -3); // ~0.283, crosses PI
+     * ```
+     */
+    static getAngleDelta(from: number, to: number): number;
 }

package/build/engine/math-lib/math/ops.js

@@ -134,4 +134,29 @@ export class MathOps {
         }
         return value;
     }
+    /**
+     * Signed shortest angular difference between two angles in radians
+     *
+     * The result is in (-PI, PI], so `from + delta` is angle-equivalent
+     * to `to` while rotating the short way around.
+     *
+     * @param from - Start angle in radians
+     * @param to - End angle in radians
+     * @returns Signed delta in radians
+     *
+     * @example
+     * ```typescript
+     * const delta = MathOps.getAngleDelta(3, -3); // ~0.283, crosses PI
+     * ```
+     */
+    static getAngleDelta(from, to) {
+        let delta = (to - from) % (2 * Math.PI);
+        if (delta > Math.PI) {
+            delta -= 2 * Math.PI;
+        }
+        else if (delta <= -Math.PI) {
+            delta += 2 * Math.PI;
+        }
+        return delta;
+    }
 }

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

@@ -3,6 +3,7 @@ import type { ComponentConstructor } from '../component';
 import type { TemplateCollection } from '../template';
 import type { SystemConstructor } from '../system';
 import type { System } from '../system/system';
+import type { Time } from '../time';
 import { Scene } from './scene';
 interface SceneManagerOptions {
     sceneConfigs: SceneConfig[];
@@ -12,6 +13,7 @@ interface SceneManagerOptions {
     templateCollection: TemplateCollection;
     globalOptions: Record<string, unknown>;
     resources: Record<string, unknown>;
+    time: Time;
 }
 export declare class SceneManager {
     private sceneConfigs;
@@ -20,13 +22,14 @@ export declare class SceneManager {
     private templateCollection;
     private globalOptions;
     private resources;
+    private time;
     private actorCreator;
     private actorSpawner;
     private world;
     private worldSystems;
     private loadedScenes;
     private activeSceneId?;
-    constructor({ sceneConfigs, systemConfigs, availableSystems, components, templateCollection, globalOptions, resources, }: SceneManagerOptions);
+    constructor({ sceneConfigs, systemConfigs, availableSystems, components, templateCollection, globalOptions, resources, time, }: SceneManagerOptions);
     loadWorld(): Promise<void>;
     destroyWorld(): void;
     private handleLoadScene;

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

@@ -13,13 +13,14 @@ export class SceneManager {
     templateCollection;
     globalOptions;
     resources;
+    time;
     actorCreator;
     actorSpawner;
     world;
     worldSystems;
     loadedScenes;
     activeSceneId;
-    constructor({ sceneConfigs, systemConfigs, availableSystems, components, templateCollection, globalOptions, resources, }) {
+    constructor({ sceneConfigs, systemConfigs, availableSystems, components, templateCollection, globalOptions, resources, time, }) {
         this.availableSystems = availableSystems.reduce((acc, AvailableSystem) => {
             acc[AvailableSystem.systemName] = AvailableSystem;
             return acc;
@@ -37,6 +38,7 @@ export class SceneManager {
         this.templateCollection = templateCollection;
         this.globalOptions = globalOptions;
         this.resources = resources;
+        this.time = time;
         this.actorCreator = new ActorCreator(components, templateCollection);
         this.actorSpawner = new ActorSpawner(this.actorCreator);
         this.world = new World({ id: uuid(), name: 'world' });
@@ -52,6 +54,7 @@ export class SceneManager {
                     actorSpawner: this.actorSpawner,
                     resources: this.resources[config.name],
                     globalOptions: this.globalOptions,
+                    time: this.time,
                     world: this.world,
                 };
                 this.worldSystems.set(config.name, new SystemClass(options));
@@ -141,6 +144,7 @@ export class SceneManager {
                     actorSpawner: this.actorSpawner,
                     resources: this.resources[config.name],
                     globalOptions: this.globalOptions,
+                    time: this.time,
                     scene,
                     world: this.world,
                 };

package/build/engine/system/index.d.ts

@@ -1,2 +1,2 @@
 export { SceneSystem, WorldSystem } from './system';
-export type { System, SystemConstructor, SceneSystemOptions, WorldSystemOptions, UpdateOptions, } from './system';
+export type { System, SystemConstructor, SceneSystemOptions, WorldSystemOptions, } from './system';

package/build/engine/system/system.d.ts

@@ -6,6 +6,7 @@ import type { ActorSpawner } from '../actor';
 import type { TemplateCollection } from '../template';
 import type { Scene } from '../scene';
 import type { World } from '../world';
+import type { Time } from '../time';
 import type { Constructor } from '../../types/utils';
 /**
  * Base options for all systems.
@@ -19,6 +20,8 @@ interface SystemOptions extends Record<string, unknown> {
     globalOptions: Record<string, unknown>;
     /** Template collection for actor creation */
     templateCollection: TemplateCollection;
+    /** Shared timing state */
+    time: Time;
 }
 /**
  * Options for scene-level systems.
@@ -36,13 +39,6 @@ export interface WorldSystemOptions extends SystemOptions {
     /** World this system operates on */
     world: World;
 }
-/**
- * Options passed to update methods with timing information.
- */
-export interface UpdateOptions {
-    /** Time elapsed since last update in milliseconds */
-    deltaTime: number;
-}
 /**
  * Abstract base class for all game systems.
  *
@@ -52,17 +48,20 @@ export interface UpdateOptions {
  * ```typescript
  * class MovementSystem extends SceneSystem {
  *   private actorQuery: ActorQuery;
+ *   private time: Time;
  *
  *   constructor(options: SceneSystemOptions) {
- *     super(options);
+ *     super();
  *
+ *     this.time = options.time;
  *     this.actorQuery = new ActorQuery({
  *       scene: options.scene,
  *       filter: [Transform, Velocity]
  *     });
  *   }
  *
- *   update({ deltaTime }: UpdateOptions): void {
+ *   update(): void {
+ *     const { deltaTime } = this.time;
  *     const actors = this.actorQuery.getActors();
  *
  *     for (const actor of actors) {
@@ -90,9 +89,9 @@ export declare abstract class System {
     /** Called when a scene is destroyed */
     onSceneDestroy?(scene: Scene): void;
     /** Called every frame with variable timestep */
-    update?(options: UpdateOptions): void;
+    update?(): void;
     /** Called with fixed timestep for physics calculations */
-    fixedUpdate?(options: UpdateOptions): void;
+    fixedUpdate?(): void;
 }
 /**
  * Abstract base class for world-level systems.

package/build/engine/system/system.js

@@ -7,17 +7,20 @@
  * ```typescript
  * class MovementSystem extends SceneSystem {
  *   private actorQuery: ActorQuery;
+ *   private time: Time;
  *
  *   constructor(options: SceneSystemOptions) {
- *     super(options);
+ *     super();
  *
+ *     this.time = options.time;
  *     this.actorQuery = new ActorQuery({
  *       scene: options.scene,
  *       filter: [Transform, Velocity]
  *     });
  *   }
  *
- *   update({ deltaTime }: UpdateOptions): void {
+ *   update(): void {
+ *     const { deltaTime } = this.time;
  *     const actors = this.actorQuery.getActors();
  *
  *     for (const actor of actors) {

package/build/engine/time.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module Time
+ * @category Core
+ */
+/**
+ * Shared timing state for the game.
+ *
+ * All durations are expressed in seconds.
+ *
+ * @category Core
+ */
+export declare class Time {
+    private _deltaTime;
+    private _fixedDeltaTime;
+    private _elapsedTime;
+    private _alpha;
+    constructor();
+    /**
+     * Time elapsed since the last variable update in seconds.
+     *
+     * Use this for logic in `update`. In `fixedUpdate`, use
+     * {@link Time.fixedDeltaTime} instead.
+     */
+    get deltaTime(): number;
+    /**
+     * The constant fixed-update timestep in seconds.
+     *
+     * Set once from the configured fixed update rate. Use this for logic in
+     * `fixedUpdate`.
+     */
+    get fixedDeltaTime(): number;
+    set fixedDeltaTime(value: number);
+    /**
+     * Total time in seconds since the game started.
+     */
+    get elapsedTime(): number;
+    /**
+     * Interpolation factor in `[0, 1)` between the last two fixed steps, for
+     * smoothing rendered state. Only meaningful during `update`.
+     */
+    get alpha(): number;
+    /**
+     * Advances the per-frame timing state.
+     *
+     * @internal Called only by the game loop.
+     */
+    _tick(deltaTime: number, alpha: number): void;
+    /**
+     * Resets accumulated timing state.
+     *
+     * @internal Called only by the game loop.
+     */
+    _reset(): void;
+}

package/build/engine/time.js

@@ -0,0 +1,77 @@
+/**
+ * @module Time
+ * @category Core
+ */
+/**
+ * Shared timing state for the game.
+ *
+ * All durations are expressed in seconds.
+ *
+ * @category Core
+ */
+export class Time {
+    _deltaTime;
+    _fixedDeltaTime;
+    _elapsedTime;
+    _alpha;
+    constructor() {
+        this._deltaTime = 0;
+        this._fixedDeltaTime = 0;
+        this._elapsedTime = 0;
+        this._alpha = 0;
+    }
+    /**
+     * Time elapsed since the last variable update in seconds.
+     *
+     * Use this for logic in `update`. In `fixedUpdate`, use
+     * {@link Time.fixedDeltaTime} instead.
+     */
+    get deltaTime() {
+        return this._deltaTime;
+    }
+    /**
+     * The constant fixed-update timestep in seconds.
+     *
+     * Set once from the configured fixed update rate. Use this for logic in
+     * `fixedUpdate`.
+     */
+    get fixedDeltaTime() {
+        return this._fixedDeltaTime;
+    }
+    set fixedDeltaTime(value) {
+        this._fixedDeltaTime = value;
+    }
+    /**
+     * Total time in seconds since the game started.
+     */
+    get elapsedTime() {
+        return this._elapsedTime;
+    }
+    /**
+     * Interpolation factor in `[0, 1)` between the last two fixed steps, for
+     * smoothing rendered state. Only meaningful during `update`.
+     */
+    get alpha() {
+        return this._alpha;
+    }
+    /**
+     * Advances the per-frame timing state.
+     *
+     * @internal Called only by the game loop.
+     */
+    _tick(deltaTime, alpha) {
+        this._deltaTime = deltaTime;
+        this._elapsedTime += deltaTime;
+        this._alpha = alpha;
+    }
+    /**
+     * Resets accumulated timing state.
+     *
+     * @internal Called only by the game loop.
+     */
+    _reset() {
+        this._deltaTime = 0;
+        this._elapsedTime = 0;
+        this._alpha = 0;
+    }
+}

package/build/index.d.ts

@@ -4,7 +4,8 @@ export { VectorOps, MathOps, Vector2 } from './engine/math-lib';
 export * from './engine/consts';
 export * from './engine/types';
 export { WorldSystem, SceneSystem } from './engine/system';
-export type { System, WorldSystemOptions, SceneSystemOptions, UpdateOptions, } from './engine/system';
+export type { System, WorldSystemOptions, SceneSystemOptions, } from './engine/system';
+export type { Time } from './engine/time';
 export type { ActorCollectionFilter, ActorSpawner, ActorQueryFilter, } from './engine/actor';
 export type { EventTarget, Event, EventType, EventPayload, ListenerFn, } from './engine/event-target';
 export type { Scene } from './engine/scene';

package/package.json

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

package/build/contrib/systems/physics-system/subsystems/collision-detection/dispersion-calculator/index.d.ts

@@ -1,11 +0,0 @@
-import type { Axis, AABB } from '../types';
-export declare class DispersionCalculator {
-    private axis;
-    private sampleSize;
-    private sum;
-    private squaredSum;
-    constructor(axis: Axis);
-    addToSample(aabb: AABB): void;
-    removeFromSample(aabb: AABB): void;
-    getDispersion(): number;
-}

package/build/contrib/systems/physics-system/subsystems/collision-detection/dispersion-calculator/index.js

@@ -1,41 +0,0 @@
-export class DispersionCalculator {
-    axis;
-    sampleSize;
-    sum;
-    squaredSum;
-    constructor(axis) {
-        this.axis = axis;
-        this.sampleSize = 0;
-        this.sum = 0;
-        this.squaredSum = 0;
-    }
-    addToSample(aabb) {
-        const average = (aabb.min[this.axis] + aabb.max[this.axis]) * 0.5;
-        this.sum += average;
-        this.squaredSum += average ** 2;
-        this.sampleSize += 1;
-    }
-    removeFromSample(aabb) {
-        if (this.sampleSize === 0) {
-            return;
-        }
-        this.sampleSize -= 1;
-        if (this.sampleSize === 0) {
-            this.sum = 0;
-            this.squaredSum = 0;
-        }
-        else {
-            const average = (aabb.min[this.axis] + aabb.max[this.axis]) * 0.5;
-            this.sum -= average;
-            this.squaredSum -= average ** 2;
-        }
-    }
-    getDispersion() {
-        if (this.sampleSize <= 1) {
-            return 0;
-        }
-        const average = this.sum / this.sampleSize;
-        const dispersion = this.squaredSum / this.sampleSize - average ** 2;
-        return Math.max(0, dispersion);
-    }
-}

package/build/contrib/utils/one-way-validator.d.ts

@@ -1,12 +0,0 @@
-import type { Actor } from '../../engine/actor';
-import { type Point } from '../../engine/math-lib';
-export declare class OneWayValidator {
-    private ignoredOneWayContacts;
-    private oneWayContactUpdateIndex;
-    constructor();
-    private clearOneWayContacts;
-    private trackOneWayContact;
-    validate(oneWayActor: Actor, otherActor: Actor, normal: Point): boolean;
-    update(): void;
-    lateUpdate(): void;
-}