dacha 0.18.0-alpha.9 → 0.18.1

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

@@ -1,3 +1,4 @@
+import { Vector2 } from '../../../../../engine/math-lib';
 import { Collider, Transform } from '../../../../components';
 import { geometryBuilders } from './geometry-builders';
 import { aabbBuilders } from './aabb-builders';
@@ -10,7 +11,7 @@ export function buildQueryProxy(type, params) {
         aabb: aabbBuilders[type](geometry),
         geometry,
         layer: params.layer,
-        excludedActors: params.excludeActors
+        excludedActors: params.excludeActors?.length
             ? new Set(params.excludeActors)
             : undefined,
         actorFilter: params.actorFilter,
@@ -62,130 +63,145 @@ export const getActorCastQueryType = (params) => {
             return null;
     }
 };
+export const makeCastHit = () => ({
+    actor: undefined,
+    point: { x: 0, y: 0 },
+    normal: new Vector2(0, 0),
+    distance: 0,
+});
+const cloneCastHit = (hit) => ({
+    actor: hit.actor,
+    point: hit.point,
+    normal: hit.normal,
+    distance: hit.distance,
+});
+export const makeOverlapHit = () => ({
+    actor: undefined,
+    normal: new Vector2(0, 0),
+    penetration: 0,
+    contactPoints: [],
+});
+const cloneOverlapHit = (hit) => ({
+    actor: hit.actor,
+    normal: hit.normal,
+    penetration: hit.penetration,
+    contactPoints: hit.contactPoints,
+});
 export const overlap = (type, queryProxy, proxies) => {
+    const scratch = makeOverlapHit();
     const hits = [];
-    for (const proxy of proxies) {
-        const collider = proxy.actor.getComponent(Collider);
-        const checker = intersectionCheckers[type]?.[collider.shape.type];
-        if (!checker) {
-            continue;
-        }
-        const intersection = checker(queryProxy.geometry, proxy.geometry);
-        if (!intersection) {
-            continue;
-        }
-        const hit = {
-            actor: proxy.actor,
-            normal: intersection.normal.clone().multiplyNumber(-1),
-            penetration: intersection.penetration,
-            contactPoints: intersection.contactPoints,
-        };
-        if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
-            continue;
-        }
-        hits.push(hit);
-    }
+    overlapEach(type, queryProxy, proxies, scratch, (hit) => {
+        hits.push(cloneOverlapHit(hit));
+    });
     return hits;
 };
 export const raycast = (queryProxy, proxies) => {
+    const scratch = makeCastHit();
     let nearestDistance = Infinity;
     let nearestHit = null;
-    for (const proxy of proxies) {
-        const collider = proxy.actor.getComponent(Collider);
-        const hit = raycastCheckers.ray[collider.shape.type](queryProxy.geometry, proxy.geometry);
-        if (!hit) {
-            continue;
-        }
-        const castHit = {
-            actor: proxy.actor,
-            point: hit.point,
-            normal: hit.normal,
-            distance: hit.distance,
-        };
-        if (queryProxy.hitFilter && !queryProxy.hitFilter(castHit)) {
-            continue;
-        }
+    raycastEach(queryProxy, proxies, scratch, (hit) => {
         if (hit.distance < nearestDistance) {
-            nearestHit = castHit;
             nearestDistance = hit.distance;
+            nearestHit = nearestHit ?? makeCastHit();
+            nearestHit.actor = hit.actor;
+            nearestHit.point = hit.point;
+            nearestHit.normal = hit.normal;
+            nearestHit.distance = hit.distance;
         }
-    }
+    });
     return nearestHit;
 };
 export const raycastAll = (queryProxy, proxies) => {
+    const scratch = makeCastHit();
     const hits = [];
+    raycastEach(queryProxy, proxies, scratch, (hit) => {
+        hits.push(cloneCastHit(hit));
+    });
+    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
+    return hits;
+};
+export const shapeCast = (type, queryProxy, proxies) => {
+    const scratch = makeCastHit();
+    let nearestDistance = Infinity;
+    let nearestHit = null;
+    shapeCastEach(type, queryProxy, proxies, scratch, (hit) => {
+        if (hit.distance < nearestDistance) {
+            nearestDistance = hit.distance;
+            nearestHit = nearestHit ?? makeCastHit();
+            nearestHit.actor = hit.actor;
+            nearestHit.point = hit.point;
+            nearestHit.normal = hit.normal;
+            nearestHit.distance = hit.distance;
+        }
+    });
+    return nearestHit;
+};
+export const shapeCastAll = (type, queryProxy, proxies) => {
+    const scratch = makeCastHit();
+    const hits = [];
+    shapeCastEach(type, queryProxy, proxies, scratch, (hit) => {
+        hits.push(cloneCastHit(hit));
+    });
+    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
+    return hits;
+};
+export const raycastEach = (queryProxy, proxies, hit, callback) => {
     for (const proxy of proxies) {
         const collider = proxy.actor.getComponent(Collider);
-        const hit = raycastCheckers.ray[collider.shape.type](queryProxy.geometry, proxy.geometry);
-        if (!hit) {
+        const result = raycastCheckers.ray[collider.shape.type](queryProxy.geometry, proxy.geometry);
+        if (!result) {
             continue;
         }
-        const castHit = {
-            actor: proxy.actor,
-            point: hit.point,
-            normal: hit.normal,
-            distance: hit.distance,
-        };
-        if (queryProxy.hitFilter && !queryProxy.hitFilter(castHit)) {
+        hit.actor = proxy.actor;
+        hit.point = result.point;
+        hit.normal = result.normal;
+        hit.distance = result.distance;
+        if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
             continue;
         }
-        hits.push(castHit);
+        callback(hit);
     }
-    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
-    return hits;
 };
-export const shapeCast = (type, queryProxy, proxies) => {
-    let nearestDistance = Infinity;
-    let nearestHit = null;
+export const shapeCastEach = (type, queryProxy, proxies, hit, callback) => {
     for (const proxy of proxies) {
         const collider = proxy.actor.getComponent(Collider);
         const checker = shapeCastCheckers[type]?.[collider.shape.type];
         if (!checker) {
             continue;
         }
-        const castHit = checker(queryProxy.geometry, proxy.geometry);
-        if (!castHit) {
+        const result = checker(queryProxy.geometry, proxy.geometry);
+        if (!result) {
             continue;
         }
-        const hit = {
-            actor: proxy.actor,
-            point: castHit.point,
-            normal: castHit.normal,
-            distance: castHit.distance,
-        };
+        hit.actor = proxy.actor;
+        hit.point = result.point;
+        hit.normal = result.normal;
+        hit.distance = result.distance;
         if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
             continue;
         }
-        if (castHit.distance < nearestDistance) {
-            nearestHit = hit;
-            nearestDistance = castHit.distance;
-        }
+        callback(hit);
     }
-    return nearestHit;
 };
-export const shapeCastAll = (type, queryProxy, proxies) => {
-    const hits = [];
+export const overlapEach = (type, queryProxy, proxies, hit, callback) => {
     for (const proxy of proxies) {
         const collider = proxy.actor.getComponent(Collider);
-        const checker = shapeCastCheckers[type]?.[collider.shape.type];
+        const checker = intersectionCheckers[type]?.[collider.shape.type];
         if (!checker) {
             continue;
         }
-        const castHit = checker(queryProxy.geometry, proxy.geometry);
-        if (!castHit) {
+        const intersection = checker(queryProxy.geometry, proxy.geometry);
+        if (!intersection) {
             continue;
         }
-        const hit = {
-            actor: proxy.actor,
-            point: castHit.point,
-            normal: castHit.normal,
-            distance: castHit.distance,
-        };
+        intersection.normal.multiplyNumber(-1);
+        hit.actor = proxy.actor;
+        hit.normal = intersection.normal;
+        hit.penetration = intersection.penetration;
+        hit.contactPoints = intersection.contactPoints;
         if (queryProxy.hitFilter && !queryProxy.hitFilter(hit)) {
             continue;
         }
-        hits.push(hit);
+        callback(hit);
     }
-    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
-    return hits;
 };

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

@@ -2,7 +2,6 @@ import type { Vector2, Point } from '../../../../../engine/math-lib';
 import type { Actor } from '../../../../../engine/actor';
 import type { CastHit, OverlapHit } from '../../types';
 import type { DynamicAABBTreeEntryId } from './dynamic-aabb-tree';
-import type { DispersionCalculator } from './dispersion-calculator';
 export type { Point };
 export interface AABB {
     min: Point;
@@ -83,7 +82,6 @@ export interface ActorProxy {
     aabb: AABB;
     geometry: Geometry;
     orientationData: OrientationData;
-    edges: Record<Axis, [SortedItem, SortedItem]>;
     treeEntryId: DynamicAABBTreeEntryId;
     layer: string;
 }
@@ -96,19 +94,6 @@ export interface QueryProxy {
     hitFilter?: (hit: OverlapHit | CastHit) => boolean;
 }
 export type Proxy = ActorProxy | QueryProxy;
-export interface SortedItem {
-    proxy: ActorProxy;
-    value: number;
-}
-export interface AxisEntry {
-    sortedList: SortedItem[];
-    dispersionCalculator: DispersionCalculator;
-}
-export type Axis = 'x' | 'y';
-export interface Axes {
-    x: AxisEntry;
-    y: AxisEntry;
-}
 export type ProxyPair = [ActorProxy, ActorProxy];
 export interface Contact {
     actor1: Actor;

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/contrib/systems/renderer/builders/mesh-builder/index.d.ts

@@ -16,7 +16,6 @@ export declare class MeshBuilder implements Builder<Mesh> {
     destroy(mesh: Mesh): void;
     buildView(mesh: Mesh, actor: Actor): PixiMesh;
     updateView(mesh: Mesh): void;
-    private updateGeometry;
     private updateTexture;
 }
 export {};

package/build/contrib/systems/renderer/builders/mesh-builder/index.js

@@ -75,26 +75,6 @@ export class MeshBuilder {
         }
         this.materialSystem.updateShader(mesh);
     }
-    updateGeometry(mesh) {
-        const view = mesh.renderData.view;
-        const texture = view.texture;
-        const geometry = view.geometry;
-        const uvs = texture?.uvs;
-        if (!uvs) {
-            return;
-        }
-        const uvAttr = geometry.getAttribute('aUV');
-        const uvBuffer = uvAttr.buffer.data;
-        uvBuffer[0] = uvs.x0;
-        uvBuffer[1] = uvs.y0;
-        uvBuffer[2] = uvs.x1;
-        uvBuffer[3] = uvs.y1;
-        uvBuffer[4] = uvs.x2;
-        uvBuffer[5] = uvs.y2;
-        uvBuffer[6] = uvs.x3;
-        uvBuffer[7] = uvs.y3;
-        uvAttr.buffer.update();
-    }
     updateTexture(mesh) {
         const view = mesh.renderData.view;
         const meta = view.__dacha.meta;
@@ -109,6 +89,5 @@ export class MeshBuilder {
         const texture = textureArray?.[mesh.currentFrame];
         view.texture = texture ?? Texture.WHITE;
         meta.currentFrame = mesh.currentFrame;
-        this.updateGeometry(mesh);
     }
 }

package/build/contrib/systems/renderer/builders/pixi-view-builder/index.js

@@ -1,3 +1,4 @@
+import { Graphics } from 'pixi.js';
 import { PixiView } from '../../../../components/pixi-view';
 export class PixiViewBuilder {
     destroy(pixiView) {
@@ -5,7 +6,7 @@ export class PixiViewBuilder {
         pixiView.renderData = undefined;
     }
     buildView(pixiView, actor) {
-        const view = pixiView.createView();
+        const view = pixiView.createView ? pixiView.createView() : new Graphics();
         pixiView.renderData = { view };
         view.__dacha = {
             actor,

package/build/contrib/systems/renderer/builders/sprite-builder/index.js

@@ -78,5 +78,13 @@ export class SpriteBuilder {
             meta.width = sprite.width;
             meta.height = sprite.height;
         }
+        if (sprite.fit === 'repeat') {
+            if (sprite.textureOffset.x !== meta.textureOffsetX ||
+                sprite.textureOffset.y !== meta.textureOffsetY) {
+                view.tilePosition.set(sprite.textureOffset.x, sprite.textureOffset.y);
+                meta.textureOffsetX = sprite.textureOffset.x;
+                meta.textureOffsetY = sprite.textureOffset.y;
+            }
+        }
     }
 }

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

@@ -1,2 +1,2 @@
 export declare const DEFAULT_VERTEX_SHADER = "\n  precision mediump float;\n\n  attribute vec2 aPosition;\n  attribute vec2 aUV;\n\n  uniform mat3 uProjectionMatrix;\n  uniform mat3 uWorldTransformMatrix;\n  uniform mat3 uTransformMatrix;\n\n  varying vec2 vUV;\n\n  void main() {\n    vUV = aUV;\n\n    mat3 mvp = uProjectionMatrix * uWorldTransformMatrix * uTransformMatrix;\n    vec3 pos = mvp * vec3(aPosition, 1.0);\n    gl_Position = vec4(pos.xy, 0.0, 1.0);\n  }\n";
-export declare const DEFAULT_FRAGMENT_SHADER = "\n  precision mediump float;\n\n  varying vec2 vUV;\n\n  uniform sampler2D uSampler;\n  uniform vec3 uTint;\n  uniform float uAlpha;\n\n  void main() {\n    vec4 color = texture2D(uSampler, vUV);\n    color.rgb *= uTint;\n    color *= uAlpha;\n    gl_FragColor = color;\n  }\n";
+export declare const DEFAULT_FRAGMENT_SHADER = "\n  precision mediump float;\n\n  varying vec2 vUV;\n\n  uniform sampler2D uSampler;\n  uniform vec2 uUVOffset;\n  uniform vec2 uUVScale;\n  uniform vec3 uTint;\n  uniform float uAlpha;\n\n  void main() {\n    vec4 color = texture2D(uSampler, uUVOffset + vUV * uUVScale);\n    color.rgb *= uTint;\n    color *= uAlpha;\n    gl_FragColor = color;\n  }\n";

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

@@ -24,11 +24,13 @@ export const DEFAULT_FRAGMENT_SHADER = `
   varying vec2 vUV;
 
   uniform sampler2D uSampler;
+  uniform vec2 uUVOffset;
+  uniform vec2 uUVScale;
   uniform vec3 uTint;
   uniform float uAlpha;
 
   void main() {
-    vec4 color = texture2D(uSampler, vUV);
+    vec4 color = texture2D(uSampler, uUVOffset + vUV * uUVScale);
     color.rgb *= uTint;
     color *= uAlpha;
     gl_FragColor = color;

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

@@ -35,7 +35,9 @@ export class MaterialSystem {
                     uTime: { value: 0.0, type: 'f32' },
                     uTint: { value: [1.0, 1.0, 1.0], type: 'vec3<f32>' },
                     uAlpha: { value: 1.0, type: 'f32' },
-                    uTextureSize: { value: [0.0, 0.0], type: 'vec2<f32>' },
+                    uFrameSize: { value: [0.0, 0.0], type: 'vec2<f32>' },
+                    uUVOffset: { value: [0.0, 0.0], type: 'vec2<f32>' },
+                    uUVScale: { value: [1.0, 1.0], type: 'vec2<f32>' },
                     ...(config && builder?.uniforms?.(config.options)),
                 },
             },
@@ -78,10 +80,14 @@ export class MaterialSystem {
                 .setValue(tint)
                 .toRgbArray([]);
         }
-        view.shader.resources.uniformsGroup.uniforms.uTextureSize[0] =
-            view.texture.source.width;
-        view.shader.resources.uniformsGroup.uniforms.uTextureSize[1] =
-            view.texture.source.height;
+        if (meta.materialTexture !== view.texture) {
+            meta.materialTexture = view.texture;
+            const { uvs, frame } = view.texture;
+            const uniforms = view.shader.resources.uniformsGroup.uniforms;
+            uniforms.uUVOffset = [uvs.x0, uvs.y0];
+            uniforms.uUVScale = [uvs.x1 - uvs.x0, uvs.y2 - uvs.y0];
+            uniforms.uFrameSize = [frame.width, frame.height];
+        }
         if (!material || !builder) {
             return;
         }

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.1",
   "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;
-}