dacha 0.18.0-alpha.9 → 0.18.0

package/build/contrib/systems/physics-system/subsystems/collision-detection/utils.d.ts

@@ -1,5 +1,8 @@
+import type { ActorProxy } from './types';
 export declare const isZero: (value: number) => boolean;
 export declare const isDefinitelyPositive: (value: number) => boolean;
 export declare const isDefinitelyNegative: (value: number) => boolean;
 export declare const isGreaterThan: (left: number, right: number) => boolean;
 export declare const isLessThan: (left: number, right: number) => boolean;
+export declare const isStatic: (proxy: ActorProxy) => boolean;
+export declare const isDisabled: (proxy: ActorProxy) => boolean;

package/build/contrib/systems/physics-system/subsystems/collision-detection/utils.js

@@ -1,6 +1,15 @@
+import { RigidBody, Collider } from '../../../../components';
 import { INTERSECTION_EPSILON } from './constants';
 export const isZero = (value) => Math.abs(value) <= INTERSECTION_EPSILON;
 export const isDefinitelyPositive = (value) => value > INTERSECTION_EPSILON;
 export const isDefinitelyNegative = (value) => value < -INTERSECTION_EPSILON;
 export const isGreaterThan = (left, right) => isDefinitelyPositive(left - right);
 export const isLessThan = (left, right) => isDefinitelyNegative(left - right);
+export const isStatic = (proxy) => {
+    const rigidBody = proxy.actor.getComponent(RigidBody);
+    return rigidBody?.type === 'static';
+};
+export const isDisabled = (proxy) => {
+    const collider = proxy.actor.getComponent(Collider);
+    return collider?.disabled === true;
+};

package/build/contrib/systems/physics-system/subsystems/physics/mass-properties.js

@@ -47,7 +47,7 @@ export const calculateInertia = (mass, collider, transform) => {
             if (length <= 0) {
                 return 0;
             }
-            inertia = (mass * (length * length + 1)) / 12;
+            inertia = (mass * length * length) / 12;
             break;
         }
     }

package/build/contrib/systems/physics-system/types.d.ts

@@ -2,8 +2,8 @@ import type { SceneSystemOptions } from '../../../engine/system';
 import type { Actor } from '../../../engine/actor';
 import type { Vector2, Point } from '../../../engine/math-lib';
 export interface PhysicsSystemOptions extends SceneSystemOptions {
-    gravityX: number;
-    gravityY: number;
+    gravityX?: number;
+    gravityY?: number;
     solverIterations?: number;
     linearSleepThreshold?: number;
     angularSleepThreshold?: number;
@@ -24,6 +24,14 @@ export interface PhysicsQueryFilter<T> {
     layer?: string;
     excludeActors?: Actor[];
     actorFilter?: (actor: Actor) => boolean;
+    /**
+     * Called once per candidate hit to decide whether to keep it.
+     *
+     * The `hit` object passed to this callback may be reused and is only valid
+     * for the duration of the call.
+     * Inspect it and return a boolean; do not retain the reference or store it
+     * in an external collection.
+     */
     hitFilter?: (hit: T) => boolean;
 }
 export interface CommonCastParams extends PhysicsQueryFilter<CastHit> {
@@ -45,6 +53,8 @@ export interface OverlapHit {
     penetration: number;
     contactPoints: Point[];
 }
+export type CastHitCallback = (hit: CastHit) => void;
+export type OverlapHitCallback = (hit: OverlapHit) => void;
 export interface PointQueryShape {
     type: 'point';
     point: Point;

package/build/contrib/systems/renderer/actor-render-tree.js

@@ -1,6 +1,7 @@
 import { Container } from 'pixi.js';
 import { Actor } from '../../../engine/actor';
 import { Transform } from '../../components/transform';
+import { Interpolation } from '../../components/interpolation';
 import { Sprite } from '../../components/sprite';
 import { Shape } from '../../components/shape';
 import { PixiView } from '../../components/pixi-view';
@@ -146,17 +147,25 @@ export class ActorRenderTree {
         this.actorParentMap.set(actor, actor.parent);
     }
     updatePosition(container, actor) {
-        const { local: { position, rotation, scale }, } = actor.getComponent(Transform);
+        const { local } = actor.getComponent(Transform);
+        const interpolation = actor.getComponent(Interpolation);
+        const useRender = interpolation !== undefined &&
+            !interpolation.disabled &&
+            interpolation.initialized;
+        const positionX = useRender ? interpolation.renderX : local.position.x;
+        const positionY = useRender ? interpolation.renderY : local.position.y;
+        const rotation = useRender ? interpolation.renderRotation : local.rotation;
+        const { scale } = local;
         const meta = container.__dacha.meta;
         if (rotation !== meta.rotation) {
             container.rotation = rotation;
             meta.rotation = rotation;
         }
-        if (!floatEquals(position.x, meta.positionX) ||
-            !floatEquals(position.y, meta.positionY)) {
-            container.position.set(position.x, position.y);
-            meta.positionX = position.x;
-            meta.positionY = position.y;
+        if (!floatEquals(positionX, meta.positionX) ||
+            !floatEquals(positionY, meta.positionY)) {
+            container.position.set(positionX, positionY);
+            meta.positionX = positionX;
+            meta.positionY = positionY;
         }
         if (scale.x !== meta.scaleX || scale.y !== meta.scaleY) {
             container.scale.set(scale.x, scale.y);

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/game-loop.js

@@ -27,10 +27,10 @@ export class GameLoop {
         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;
         }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dacha",
-  "version": "0.18.0-alpha.9",
+  "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/engine/data-lib/sort/index.d.ts

@@ -1 +0,0 @@
-export { insertionSort } from './insertion-sort';

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

@@ -1 +0,0 @@
-export { insertionSort } from './insertion-sort';

package/build/engine/data-lib/sort/insertion-sort.d.ts

@@ -1 +0,0 @@
-export declare const insertionSort: <T>(array: T[], compareFn: (arg1: T, arg2: T) => number) => T[];

package/build/engine/data-lib/sort/insertion-sort.js

@@ -1,14 +0,0 @@
-export const insertionSort = (array, compareFn) => {
-    let i = 1;
-    while (i < array.length) {
-        let j = i;
-        const x = array[j];
-        while (j > 0 && compareFn(x, array[j - 1]) < 0) {
-            array[j] = array[j - 1];
-            j -= 1;
-        }
-        array[j] = x;
-        i += 1;
-    }
-    return array;
-};