dacha 0.17.2 → 0.18.0-alpha.1

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-box/check-ray-and-box-intersection.js

@@ -0,0 +1,69 @@
+import { VectorOps } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks a ray against a convex box using half-space clipping.
+ *
+ * The intersection interval is clipped against each box face.
+ * - `tEnter` tracks the first point where the ray enters the box
+ * - `tExit` tracks the first point where the ray leaves the box
+ *
+ * When the ray starts inside the box, the first hit is the exit point.
+ */
+export const checkRayAndBoxIntersection = (arg1, arg2) => {
+    const isBoxFirst = 'edges' in arg1.geometry;
+    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
+    const ray = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    let tEnter = -Infinity;
+    let tExit = ray.maxDistance;
+    let enterEdge = null;
+    let exitEdge = null;
+    for (const edge of box.edges) {
+        const signedDistance = VectorOps.dotProduct({
+            x: ray.origin.x - edge.point1.x,
+            y: ray.origin.y - edge.point1.y,
+        }, edge.normal);
+        const denominator = VectorOps.dotProduct(ray.direction, edge.normal);
+        if (Math.abs(denominator) <= INTERSECTION_EPSILON) {
+            if (signedDistance > INTERSECTION_EPSILON) {
+                return false;
+            }
+            continue;
+        }
+        const t = -signedDistance / denominator;
+        if (denominator < 0) {
+            if (t > tEnter) {
+                tEnter = t;
+                enterEdge = edge;
+            }
+        }
+        else {
+            if (t < tExit) {
+                tExit = t;
+                exitEdge = edge;
+            }
+        }
+        if (tEnter - tExit > INTERSECTION_EPSILON) {
+            return false;
+        }
+    }
+    if (tExit < -INTERSECTION_EPSILON ||
+        tEnter > ray.maxDistance + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const hitDistance = tEnter >= 0 ? tEnter : tExit;
+    const hitEdge = tEnter >= 0 ? enterEdge : exitEdge;
+    if (hitEdge === null) {
+        return false;
+    }
+    const hitPoint = {
+        x: ray.origin.x + ray.direction.x * hitDistance,
+        y: ray.origin.y + ray.direction.y * hitDistance,
+    };
+    const normal = hitEdge.normal.clone();
+    return {
+        normal,
+        distance: hitDistance,
+        penetration: 0,
+        contactPoints: [hitPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-circle/check-ray-and-circle-intersection.d.ts

@@ -0,0 +1,10 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks a ray against a circle.
+ *
+ * The ray/circle equation is solved in parametric form. The first valid
+ * distance on the finite ray is used as the contact point. When the ray
+ * starts at the circle center, the normal falls back to the opposite ray
+ * direction.
+ */
+export declare const checkRayAndCircleIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-circle/check-ray-and-circle-intersection.js

@@ -0,0 +1,45 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks a ray against a circle.
+ *
+ * The ray/circle equation is solved in parametric form. The first valid
+ * distance on the finite ray is used as the contact point. When the ray
+ * starts at the circle center, the normal falls back to the opposite ray
+ * direction.
+ */
+export const checkRayAndCircleIntersection = (arg1, arg2) => {
+    const isCircleFirst = 'radius' in arg1.geometry;
+    const circle = (isCircleFirst ? arg1.geometry : arg2.geometry);
+    const ray = (isCircleFirst ? arg2.geometry : arg1.geometry);
+    const offsetX = ray.origin.x - circle.center.x;
+    const offsetY = ray.origin.y - circle.center.y;
+    const b = offsetX * ray.direction.x + offsetY * ray.direction.y;
+    const c = offsetX ** 2 + offsetY ** 2 - circle.radius ** 2;
+    if (c > INTERSECTION_EPSILON && b > 0) {
+        return false;
+    }
+    const discriminant = b ** 2 - c;
+    if (discriminant < -INTERSECTION_EPSILON) {
+        return false;
+    }
+    const hitDistance = Math.max(0, -b - Math.sqrt(Math.max(0, discriminant)));
+    if (hitDistance > ray.maxDistance + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const hitPoint = {
+        x: ray.origin.x + ray.direction.x * hitDistance,
+        y: ray.origin.y + ray.direction.y * hitDistance,
+    };
+    const normal = new Vector2(hitPoint.x - circle.center.x, hitPoint.y - circle.center.y).normalize();
+    if (normal.magnitude === 0) {
+        normal.x = -ray.direction.x;
+        normal.y = -ray.direction.y;
+    }
+    return {
+        normal,
+        distance: hitDistance,
+        penetration: 0,
+        contactPoints: [hitPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-segment/check-ray-and-segment-intersection.d.ts

@@ -0,0 +1,16 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks a ray against a finite segment.
+ *
+ * Both primitives are treated parametrically:
+ * - the ray is `origin + direction * t`
+ * - the segment is `point1 + (point2 - point1) * u`
+ *
+ * Solving the 2D line intersection gives `t` on the ray and `u` on the
+ * segment. A hit is valid only when `t` lies within the ray length and
+ * `u` lies within the finite segment interval `[0, 1]`.
+ *
+ * The contact normal comes from the segment normal and is flipped when needed
+ * so it opposes the incoming ray direction.
+ */
+export declare const checkRayAndSegmentIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-segment/check-ray-and-segment-intersection.js

@@ -0,0 +1,51 @@
+import { VectorOps } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../utils';
+import { subtractPoints } from './utils';
+/**
+ * Checks a ray against a finite segment.
+ *
+ * Both primitives are treated parametrically:
+ * - the ray is `origin + direction * t`
+ * - the segment is `point1 + (point2 - point1) * u`
+ *
+ * Solving the 2D line intersection gives `t` on the ray and `u` on the
+ * segment. A hit is valid only when `t` lies within the ray length and
+ * `u` lies within the finite segment interval `[0, 1]`.
+ *
+ * The contact normal comes from the segment normal and is flipped when needed
+ * so it opposes the incoming ray direction.
+ */
+export const checkRayAndSegmentIntersection = (arg1, arg2) => {
+    const isSegmentFirst = 'point1' in arg1.geometry;
+    const segment = (isSegmentFirst ? arg1.geometry : arg2.geometry);
+    const ray = (isSegmentFirst ? arg2.geometry : arg1.geometry);
+    const segmentDirection = subtractPoints(segment.point2, segment.point1);
+    const delta = subtractPoints(segment.point1, ray.origin);
+    const denominator = VectorOps.crossProduct(ray.direction, segmentDirection);
+    if (Math.abs(denominator) <= INTERSECTION_EPSILON) {
+        return false;
+    }
+    const rayDistance = VectorOps.crossProduct(delta, segmentDirection) / denominator;
+    const segmentDistance = VectorOps.crossProduct(delta, ray.direction) / denominator;
+    if (rayDistance < -INTERSECTION_EPSILON ||
+        rayDistance > ray.maxDistance + INTERSECTION_EPSILON ||
+        segmentDistance < -INTERSECTION_EPSILON ||
+        segmentDistance > 1 + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const point = {
+        x: ray.origin.x + ray.direction.x * rayDistance,
+        y: ray.origin.y + ray.direction.y * rayDistance,
+    };
+    const normal = segment.normal.clone();
+    if (normal.x * ray.direction.x + normal.y * ray.direction.y >
+        INTERSECTION_EPSILON) {
+        normal.multiplyNumber(-1);
+    }
+    return {
+        normal,
+        distance: rayDistance,
+        penetration: 0,
+        contactPoints: [point],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-segment/utils.d.ts

@@ -0,0 +1,2 @@
+import type { Point } from '../../types';
+export declare const subtractPoints: (point1: Point, point2: Point) => Point;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-segment/utils.js

@@ -0,0 +1,4 @@
+export const subtractPoints = (point1, point2) => ({
+    x: point1.x - point2.x,
+    y: point1.y - point2.y,
+});

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/tests/helpers.d.ts

@@ -0,0 +1,20 @@
+import type { BoxGeometry, CircleGeometry, Intersection, PointGeometry, Proxy, RayGeometry, SegmentGeometry } from '../../types';
+export declare const createBoxGeometry: (centerX: number, centerY: number, sizeX: number, sizeY: number) => BoxGeometry;
+export declare const createRotatedBoxGeometry: (centerX: number, centerY: number, sizeX: number, sizeY: number, rotation: number) => BoxGeometry;
+export declare const createCircleGeometry: (centerX: number, centerY: number, radius: number) => CircleGeometry;
+export declare const createSegmentGeometry: (point1X: number, point1Y: number, point2X: number, point2Y: number) => SegmentGeometry;
+export declare const createPointGeometry: (centerX: number, centerY: number) => PointGeometry;
+export declare const createRayGeometry: (originX: number, originY: number, directionX: number, directionY: number, maxDistance: number) => RayGeometry;
+export declare const createProxy: (geometry: BoxGeometry | CircleGeometry | SegmentGeometry | PointGeometry | RayGeometry) => Proxy;
+export declare const expectToBeClose: (point: {
+    x: number;
+    y: number;
+}, x: number, y: number, digits?: number) => void;
+export declare const expectIntersection: (intersection: Intersection | false) => Intersection;
+export declare const sortPoints: (points: {
+    x: number;
+    y: number;
+}[]) => {
+    x: number;
+    y: number;
+}[];

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/tests/helpers.js

@@ -0,0 +1,69 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import { Collider, Transform } from '../../../../../../components';
+import { buildBoxGeometry } from '../../geometry-builders/build-box-geometry';
+import { buildCircleGeometry } from '../../geometry-builders/build-circle-geometry';
+import { buildPointGeometry } from '../../geometry-builders/build-point-geometry';
+import { buildRayGeometry } from '../../geometry-builders/build-ray-geometry';
+import { buildSegmentGeometry } from '../../geometry-builders/build-segment-geometry';
+export const createBoxGeometry = (centerX, centerY, sizeX, sizeY) => {
+    return createRotatedBoxGeometry(centerX, centerY, sizeX, sizeY, 0);
+};
+export const createRotatedBoxGeometry = (centerX, centerY, sizeX, sizeY, rotation) => {
+    return buildBoxGeometry({
+        center: { x: centerX, y: centerY },
+        size: { x: sizeX, y: sizeY },
+        rotation,
+    });
+};
+export const createCircleGeometry = (centerX, centerY, radius) => buildCircleGeometry({
+    center: { x: centerX, y: centerY },
+    radius,
+});
+export const createSegmentGeometry = (point1X, point1Y, point2X, point2Y) => {
+    const centerX = (point1X + point2X) / 2;
+    const centerY = (point1Y + point2Y) / 2;
+    return buildSegmentGeometry(new Collider({
+        type: 'segment',
+        centerX,
+        centerY,
+        point1X: point1X - centerX,
+        point1Y: point1Y - centerY,
+        point2X: point2X - centerX,
+        point2Y: point2Y - centerY,
+        layer: 'default',
+    }), new Transform({
+        offsetX: 0,
+        offsetY: 0,
+        rotation: 0,
+        scaleX: 1,
+        scaleY: 1,
+    }));
+};
+export const createPointGeometry = (centerX, centerY) => buildPointGeometry({
+    point: { x: centerX, y: centerY },
+});
+export const createRayGeometry = (originX, originY, directionX, directionY, maxDistance) => buildRayGeometry({
+    origin: { x: originX, y: originY },
+    direction: new Vector2(directionX, directionY),
+    maxDistance,
+});
+export const createProxy = (geometry) => ({
+    geometry,
+});
+export const expectToBeClose = (point, x, y, digits = 6) => {
+    expect(point.x).toBeCloseTo(x, digits);
+    expect(point.y).toBeCloseTo(y, digits);
+};
+export const expectIntersection = (intersection) => {
+    expect(intersection).not.toBe(false);
+    if (intersection === false) {
+        throw new Error('Expected intersection, received false');
+    }
+    return intersection;
+};
+export const sortPoints = (points) => [...points].sort((point1, point2) => {
+    if (point1.x !== point2.x) {
+        return point1.x - point2.x;
+    }
+    return point1.y - point2.y;
+});

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

@@ -0,0 +1,9 @@
+import { Vector2 } from '../../../../../../engine/math-lib';
+import type { Point } from '../types';
+export declare const INTERSECTION_EPSILON = 0.000001;
+export declare const orientNormal: (normal: Vector2, from: Point, to: Point) => Vector2;
+export interface Projection {
+    min: number;
+    max: number;
+}
+export declare const projectPolygon: (points: Point[], axis: Vector2) => Projection;

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

@@ -0,0 +1,23 @@
+import { Vector2, VectorOps } from '../../../../../../engine/math-lib';
+export const INTERSECTION_EPSILON = 1e-6;
+export const orientNormal = (normal, from, to) => {
+    const direction = new Vector2(to.x - from.x, to.y - from.y);
+    if (VectorOps.dotProduct(direction, normal) < 0) {
+        return normal.clone().multiplyNumber(-1);
+    }
+    return normal;
+};
+export const projectPolygon = (points, axis) => {
+    let min = VectorOps.dotProduct(points[0], axis);
+    let max = min;
+    for (let i = 1; i < points.length; i += 1) {
+        const value = VectorOps.dotProduct(points[i], axis);
+        if (value < min) {
+            min = value;
+        }
+        else if (value > max) {
+            max = value;
+        }
+    }
+    return { min, max };
+};

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

@@ -0,0 +1,10 @@
+import type { Actor } from '../../../../../engine/actor';
+import type { OverlapBoxParams, OverlapCircleParams, OverlapPointParams, RaycastParams, RaycastHit } from '../../types';
+import type { ActorProxy, QueryProxy } from './types';
+type QueryType = 'point' | 'circle' | 'box' | 'ray';
+type QueryParams = OverlapBoxParams | OverlapCircleParams | OverlapPointParams | RaycastParams;
+export declare function buildQueryProxy(type: QueryType, params: QueryParams): QueryProxy;
+export declare const overlap: (type: QueryType, queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => Actor[];
+export declare const raycast: (queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => RaycastHit | null;
+export declare const raycastAll: (queryProxy: QueryProxy, proxies: Iterable<ActorProxy>) => RaycastHit[];
+export {};

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

@@ -0,0 +1,63 @@
+import { Collider } from '../../../../components';
+import { geometryBuilders } from './geometry-builders';
+import { aabbBuilders } from './aabb-builders';
+import { intersectionCheckers } from './intersection-checkers';
+export function buildQueryProxy(type, params) {
+    const geometry = geometryBuilders[type](params);
+    return {
+        aabb: aabbBuilders[type](geometry),
+        geometry,
+        layer: params.layer,
+    };
+}
+export const overlap = (type, queryProxy, proxies) => {
+    const actors = [];
+    for (const proxy of proxies) {
+        const collider = proxy.actor.getComponent(Collider);
+        const intersection = intersectionCheckers[type][collider.type](queryProxy, proxy);
+        if (intersection) {
+            actors.push(proxy.actor);
+        }
+    }
+    return actors;
+};
+export const raycast = (queryProxy, proxies) => {
+    let nearestIntersection = null;
+    let nearestActor = null;
+    let nearestDistance = Infinity;
+    for (const proxy of proxies) {
+        const collider = proxy.actor.getComponent(Collider);
+        const intersection = intersectionCheckers.ray[collider.type](queryProxy, proxy);
+        if (intersection && intersection.distance < nearestDistance) {
+            nearestIntersection = intersection;
+            nearestActor = proxy.actor;
+            nearestDistance = intersection.distance;
+        }
+    }
+    if (!nearestIntersection || !nearestActor) {
+        return null;
+    }
+    return {
+        actor: nearestActor,
+        point: nearestIntersection.contactPoints[0],
+        normal: nearestIntersection.normal,
+        distance: nearestDistance,
+    };
+};
+export const raycastAll = (queryProxy, proxies) => {
+    const hits = [];
+    for (const proxy of proxies) {
+        const collider = proxy.actor.getComponent(Collider);
+        const intersection = intersectionCheckers.ray[collider.type](queryProxy, proxy);
+        if (intersection) {
+            hits.push({
+                actor: proxy.actor,
+                point: intersection.contactPoints[0],
+                normal: intersection.normal,
+                distance: intersection.distance,
+            });
+        }
+    }
+    hits.sort((arg1, arg2) => arg1.distance - arg2.distance);
+    return hits;
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/check-collider.js

@@ -2,13 +2,22 @@ export const checkCollider = (collider, colliderOld) => {
     if (collider.type !== colliderOld.type) {
         return true;
     }
+    if (collider.layer !== colliderOld.layer) {
+        return true;
+    }
+    if (collider.centerX !== colliderOld.centerX ||
+        collider.centerY !== colliderOld.centerY) {
+        return true;
+    }
     if (collider.type === 'box') {
-        return collider.centerX !== colliderOld.centerX
-            || collider.centerY !== colliderOld.centerY
-            || collider.sizeX !== colliderOld.sizeX
-            || collider.sizeY !== colliderOld.sizeY;
-    }
-    return collider.centerX !== colliderOld.centerX
-        || collider.centerY !== colliderOld.centerY
-        || collider.radius !== colliderOld.radius;
+        return (collider.sizeX !== colliderOld.sizeX ||
+            collider.sizeY !== colliderOld.sizeY);
+    }
+    if (collider.type === 'circle') {
+        return collider.radius !== colliderOld.radius;
+    }
+    return (collider.point1?.x !== colliderOld.point1?.x ||
+        collider.point1?.y !== colliderOld.point1?.y ||
+        collider.point2?.x !== colliderOld.point2?.x ||
+        collider.point2?.y !== colliderOld.point2?.y);
 };

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

@@ -1,10 +1,7 @@
-import type { Vector2 } from '../../../../../engine/math-lib';
+import type { Vector2, Point } from '../../../../../engine/math-lib';
 import type { Actor } from '../../../../../engine/actor';
 import type { DispersionCalculator } from './dispersion-calculator';
-export interface Point {
-    x: number;
-    y: number;
-}
+export type { Point };
 export interface AABB {
     min: Point;
     max: Point;
@@ -25,7 +22,21 @@ export interface CircleGeometry {
     center: Point;
     radius: number;
 }
-export type Geometry = BoxGeometry | CircleGeometry;
+export interface SegmentGeometry {
+    center: Point;
+    point1: Point;
+    point2: Point;
+    normal: Vector2;
+}
+export interface PointGeometry {
+    center: Point;
+}
+export interface RayGeometry {
+    origin: Point;
+    direction: Vector2;
+    maxDistance: number;
+}
+export type Geometry = BoxGeometry | CircleGeometry | SegmentGeometry | PointGeometry | RayGeometry;
 export interface OrientationData {
     transform: {
         positionX: number;
@@ -36,22 +47,32 @@ export interface OrientationData {
     };
     collider: {
         type: string;
+        layer: string;
         centerX: number;
         centerY: number;
         radius?: number;
         sizeX?: number;
         sizeY?: number;
+        point1?: Point;
+        point2?: Point;
     };
 }
-export interface CollisionEntry {
+export interface ActorProxy {
     actor: Actor;
     aabb: AABB;
     geometry: Geometry;
     orientationData: OrientationData;
     edges: Record<Axis, [SortedItem, SortedItem]>;
+    layer: string;
+}
+export interface QueryProxy {
+    aabb: AABB;
+    geometry: Geometry;
+    layer?: string;
 }
+export type Proxy = ActorProxy | QueryProxy;
 export interface SortedItem {
-    entry: CollisionEntry;
+    proxy: ActorProxy;
     value: number;
 }
 export interface AxisEntry {
@@ -63,8 +84,17 @@ export interface Axes {
     x: AxisEntry;
     y: AxisEntry;
 }
-export type CollisionPair = [CollisionEntry, CollisionEntry];
+export type ProxyPair = [ActorProxy, ActorProxy];
+export interface Contact {
+    actor1: Actor;
+    actor2: Actor;
+    normal: Vector2;
+    penetration: number;
+    contactPoints: Point[];
+}
 export interface Intersection {
-    mtv1: Vector2;
-    mtv2: Vector2;
+    normal: Vector2;
+    penetration: number;
+    contactPoints: Point[];
+    distance?: number;
 }

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

@@ -1,4 +1 @@
-;
-;
-;
 export {};

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.d.ts

@@ -1,13 +1,10 @@
-import type { SceneSystemOptions } from '../../../../../engine/system';
+import type { Contact } from '../collision-detection/types';
 export declare class ConstraintSolver {
-    private scene;
-    private processedPairs;
-    private mtvMap;
-    constructor(options: SceneSystemOptions);
-    destroy(): void;
-    private handleCollision;
+    private validContacts;
     private validateCollision;
-    private setMtv;
-    private resolveCollision;
-    update(): void;
+    private getInverseMass;
+    private applyNormalImpulse;
+    private applyFrictionImpulse;
+    private applyPositionCorrection;
+    update(contacts: Contact[]): void;
 }