dacha 0.18.0-alpha.1 → 0.18.0-alpha.2

package/build/contrib/components/collider/index.d.ts

@@ -1,7 +1,7 @@
 import { Component } from '../../../engine/component';
 import type { Point } from '../../../engine/math-lib';
 export interface ColliderConfig {
-    type: 'box' | 'circle' | 'segment';
+    type: 'box' | 'circle' | 'segment' | 'capsule';
     centerX: number;
     centerY: number;
     sizeX?: number;
@@ -48,7 +48,7 @@ export interface ColliderConfig {
  * @category Components
  */
 export declare class Collider extends Component {
-    type: 'box' | 'circle' | 'segment';
+    type: 'box' | 'circle' | 'segment' | 'capsule';
     centerX: number;
     centerY: number;
     sizeX?: number;

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-capsule-aabb.d.ts

@@ -0,0 +1,2 @@
+import type { AABB, Geometry } from '../types';
+export declare const buildCapsuleAABB: (geometry: Geometry) => AABB;

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-capsule-aabb.js

@@ -0,0 +1,13 @@
+export const buildCapsuleAABB = (geometry) => {
+    const { point1, point2, radius } = geometry;
+    return {
+        min: {
+            x: Math.min(point1.x, point2.x) - radius,
+            y: Math.min(point1.y, point2.y) - radius,
+        },
+        max: {
+            x: Math.max(point1.x, point2.x) + radius,
+            y: Math.max(point1.y, point2.y) + radius,
+        },
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-segment-aabb.js

@@ -1,4 +1,4 @@
-import { INTERSECTION_EPSILON } from '../intersection-checkers/utils';
+import { INTERSECTION_EPSILON } from '../constants';
 export const buildSegmentAABB = (geometry) => {
     const { point1, point2 } = geometry;
     return {

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/index.js

@@ -1,10 +1,12 @@
 import { buildBoxAABB } from './build-box-aabb';
+import { buildCapsuleAABB } from './build-capsule-aabb';
 import { buildCircleAABB } from './build-circle-aabb';
 import { buildPointAABB } from './build-point-aabb';
 import { buildRayAABB } from './build-ray-aabb';
 import { buildSegmentAABB } from './build-segment-aabb';
 export const aabbBuilders = {
     box: buildBoxAABB,
+    capsule: buildCapsuleAABB,
     circle: buildCircleAABB,
     segment: buildSegmentAABB,
     point: buildPointAABB,

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

@@ -0,0 +1 @@
+export declare const INTERSECTION_EPSILON = 0.000001;

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

@@ -0,0 +1 @@
+export const INTERSECTION_EPSILON = 1e-6;

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

@@ -16,12 +16,26 @@ export class DispersionCalculator {
         this.sampleSize += 1;
     }
     removeFromSample(aabb) {
-        const average = (aabb.min[this.axis] + aabb.max[this.axis]) * 0.5;
-        this.sum -= average;
-        this.squaredSum -= average ** 2;
+        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() {
-        return (this.squaredSum / this.sampleSize) - (this.sum / this.sampleSize) ** 2;
+        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/systems/physics-system/subsystems/collision-detection/geometry-builders/build-capsule-geometry.d.ts

@@ -0,0 +1,3 @@
+import type { Collider, Transform } from '../../../../../components';
+import type { CapsuleGeometry } from '../types';
+export declare function buildCapsuleGeometry(collider: Collider, transform: Transform): CapsuleGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-capsule-geometry.js

@@ -0,0 +1,34 @@
+import { VectorOps } from '../../../../../../engine/math-lib';
+export function buildCapsuleGeometry(collider, transform) {
+    const centerX = collider.centerX + transform.world.position.x;
+    const centerY = collider.centerY + transform.world.position.y;
+    const point1X = collider.point1?.x ?? 0;
+    const point1Y = collider.point1?.y ?? 0;
+    const point2X = collider.point2?.x ?? 0;
+    const point2Y = collider.point2?.y ?? 0;
+    const rotation = transform.world.rotation;
+    const scaleX = transform.world.scale.x;
+    const scaleY = transform.world.scale.y;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const buildPoint = (x, y) => {
+        const scaledX = x * scaleX;
+        const scaledY = y * scaleY;
+        return {
+            x: scaledX * cos - scaledY * sin + centerX,
+            y: scaledX * sin + scaledY * cos + centerY,
+        };
+    };
+    const point1 = buildPoint(point1X, point1Y);
+    const point2 = buildPoint(point2X, point2Y);
+    return {
+        center: {
+            x: (point1.x + point2.x) / 2,
+            y: (point1.y + point2.y) / 2,
+        },
+        point1,
+        point2,
+        normal: VectorOps.getNormal(point1.x, point2.x, point1.y, point2.y),
+        radius: (collider.radius ?? 0) * Math.max(scaleX, scaleY),
+    };
+}

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/index.d.ts

@@ -1,6 +1,7 @@
 import type { Collider, Transform } from '../../../../../components';
 import type { Geometry } from '../types';
 import { buildBoxGeometry } from './build-box-geometry';
+import { buildCapsuleGeometry } from './build-capsule-geometry';
 import { buildCircleGeometry } from './build-circle-geometry';
 import { buildPointGeometry } from './build-point-geometry';
 import { buildRayGeometry } from './build-ray-geometry';
@@ -8,6 +9,7 @@ import { buildSegmentGeometry } from './build-segment-geometry';
 export type BuildGeometryFn = (collider: Collider, transform: Transform) => Geometry;
 export declare const geometryBuilders: {
     box: typeof buildBoxGeometry;
+    capsule: typeof buildCapsuleGeometry;
     circle: typeof buildCircleGeometry;
     segment: typeof buildSegmentGeometry;
     point: typeof buildPointGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/index.js

@@ -1,10 +1,12 @@
 import { buildBoxGeometry } from './build-box-geometry';
+import { buildCapsuleGeometry } from './build-capsule-geometry';
 import { buildCircleGeometry } from './build-circle-geometry';
 import { buildPointGeometry } from './build-point-geometry';
 import { buildRayGeometry } from './build-ray-geometry';
 import { buildSegmentGeometry } from './build-segment-geometry';
 export const geometryBuilders = {
     box: buildBoxGeometry,
+    capsule: buildCapsuleGeometry,
     circle: buildCircleGeometry,
     segment: buildSegmentGeometry,
     point: buildPointGeometry,

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

@@ -183,7 +183,7 @@ export class CollisionDetectionSubsystem {
     testAABB(proxy1, proxy2, axis) {
         const aabb1 = proxy1.aabb;
         const aabb2 = proxy2.aabb;
-        return (aabb1.max[axis] > aabb2.min[axis] && aabb1.min[axis] < aabb2.max[axis]);
+        return (aabb1.max[axis] >= aabb2.min[axis] && aabb1.min[axis] <= aabb2.max[axis]);
     }
     testCollisionLayers(proxy1, proxy2) {
         return this.collisionMatrix[proxy1.layer]?.[proxy2.layer] ?? true;

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

@@ -1,4 +1,4 @@
-import { orientNormal } from '../utils';
+import { orientNormal } from '../common/normals';
 import { findMinBoxesOverlap, buildContactPoints } from './utils';
 /**
  * Checks box colliders for intersection.

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

@@ -6,12 +6,23 @@ export interface AxisOverlap {
     axis: Vector2;
     overlap: number;
 }
+/**
+ * Runs the SAT pass for one box's face normals against another box.
+ *
+ * Each face normal is a potential separating axis. If any projection pair does
+ * not overlap, the boxes cannot intersect. Otherwise, the axis with the
+ * smallest overlap is the least expensive direction to separate the boxes, so
+ * it becomes the candidate collision normal for this polygon.
+ */
 export declare const findMinBoxesOverlap: (geometry1: BoxGeometry, geometry2: BoxGeometry) => AxisOverlap | false;
 /**
  * Builds up to two box-vs-box contact points by clipping the incident edge
  * against the side planes of the reference edge.
  *
- * The returned points lie on the reference face plane, which makes them
- * suitable to use as world-space contact points in a simple impulse solver.
+ * The process mirrors the standard contact manifold construction for SAT:
+ * choose a reference face, choose the incident face most opposed to it, clip
+ * the incident segment by the reference face's tangent bounds, then project
+ * surviving points back onto the reference face plane. The projected points are
+ * suitable as world-space contacts for impulse resolution.
  */
 export declare const buildContactPoints: (referencePolygon: BoxGeometry, referenceNormal: Vector2, incidentPolygon: BoxGeometry) => Point[];

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

@@ -1,20 +1,27 @@
 import { Vector2, VectorOps } from '../../../../../../../engine/math-lib';
-import { INTERSECTION_EPSILON, projectPolygon } from '../utils';
+import { getProjectionOverlap, projectPolygon } from '../common/projections';
 export const CONTACT_EPSILON = 1e-4;
 export const MAX_CONTACT_POINTS = 2;
+/**
+ * Runs the SAT pass for one box's face normals against another box.
+ *
+ * Each face normal is a potential separating axis. If any projection pair does
+ * not overlap, the boxes cannot intersect. Otherwise, the axis with the
+ * smallest overlap is the least expensive direction to separate the boxes, so
+ * it becomes the candidate collision normal for this polygon.
+ */
 export const findMinBoxesOverlap = (geometry1, geometry2) => {
     let minOverlap = Infinity;
     let bestAxis = geometry1.edges[0].normal;
-    for (const edge of geometry1.edges) {
+    for (let i = 0; i < 2; i += 1) {
+        const edge = geometry1.edges[i];
         const axis = edge.normal;
         const projection1 = projectPolygon(geometry1.points, axis);
         const projection2 = projectPolygon(geometry2.points, axis);
-        const distance1 = projection1.min - projection2.max;
-        const distance2 = projection2.min - projection1.max;
-        if (distance1 > INTERSECTION_EPSILON || distance2 > INTERSECTION_EPSILON) {
+        const overlap = getProjectionOverlap(projection1.min, projection1.max, projection2.min, projection2.max);
+        if (overlap === false) {
             return false;
         }
-        const overlap = Math.min(Math.abs(distance1), Math.abs(distance2));
         if (overlap < minOverlap) {
             minOverlap = overlap;
             bestAxis = axis;
@@ -46,6 +53,12 @@ const clipSegmentToLine = (vertices, normal, offset) => {
     }
     return clipped;
 };
+/**
+ * Selects the incident edge for clipping.
+ *
+ * The incident edge should face into the reference face, so it is the edge
+ * whose normal points most strongly opposite the reference collision normal.
+ */
 const getMostAntiParallelEdge = (polygon, normal) => {
     let bestEdge = polygon.edges[0];
     let minDot = VectorOps.dotProduct(bestEdge.normal, normal);
@@ -58,6 +71,12 @@ const getMostAntiParallelEdge = (polygon, normal) => {
     }
     return bestEdge;
 };
+/**
+ * Selects the reference edge that owns the collision plane.
+ *
+ * The reference edge is the edge whose normal most closely matches the chosen
+ * collision normal. Its side planes bound the incident edge during clipping.
+ */
 const getMostParallelEdge = (polygon, normal) => {
     let bestEdge = polygon.edges[0];
     let maxDot = VectorOps.dotProduct(bestEdge.normal, normal);
@@ -88,8 +107,11 @@ const dedupePoints = (points) => {
  * Builds up to two box-vs-box contact points by clipping the incident edge
  * against the side planes of the reference edge.
  *
- * The returned points lie on the reference face plane, which makes them
- * suitable to use as world-space contact points in a simple impulse solver.
+ * The process mirrors the standard contact manifold construction for SAT:
+ * choose a reference face, choose the incident face most opposed to it, clip
+ * the incident segment by the reference face's tangent bounds, then project
+ * surviving points back onto the reference face plane. The projected points are
+ * suitable as world-space contacts for impulse resolution.
  */
 export const buildContactPoints = (referencePolygon, referenceNormal, incidentPolygon) => {
     const referenceEdge = getMostParallelEdge(referencePolygon, referenceNormal);

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

@@ -0,0 +1,20 @@
+import type { Intersection, Proxy } from '../../types';
+/**
+ * Checks a box against a capsule.
+ *
+ * A capsule is treated as a line segment swept by a radius. The fast rejection
+ * path finds the closest distance between each box edge and the capsule axis;
+ * if that distance is greater than the capsule radius, the shapes are
+ * separated.
+ *
+ * When the capsule axis is already inside the box, SAT is used with
+ * the box face normals plus the capsule axis normal, with the capsule
+ * projection expanded by its radius.
+ *
+ * For deep axis overlaps, the capsule axis
+ * is clipped by the box and then shifted by the capsule radius along the
+ * collision normal so contacts lie on the capsule surface.
+ *
+ * Side and corner contacts use the nearest box point.
+ */
+export declare const checkBoxAndCapsuleIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

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

@@ -0,0 +1,32 @@
+import { orientNormal } from '../common/normals';
+import { buildBoxCapsuleIntersection } from './utils';
+/**
+ * Checks a box against a capsule.
+ *
+ * A capsule is treated as a line segment swept by a radius. The fast rejection
+ * path finds the closest distance between each box edge and the capsule axis;
+ * if that distance is greater than the capsule radius, the shapes are
+ * separated.
+ *
+ * When the capsule axis is already inside the box, SAT is used with
+ * the box face normals plus the capsule axis normal, with the capsule
+ * projection expanded by its radius.
+ *
+ * For deep axis overlaps, the capsule axis
+ * is clipped by the box and then shifted by the capsule radius along the
+ * collision normal so contacts lie on the capsule surface.
+ *
+ * Side and corner contacts use the nearest box point.
+ */
+export const checkBoxAndCapsuleIntersection = (arg1, arg2) => {
+    const box = arg1.geometry;
+    const capsule = arg2.geometry;
+    const intersection = buildBoxCapsuleIntersection(box, capsule);
+    if (!intersection) {
+        return false;
+    }
+    return {
+        ...intersection,
+        normal: orientNormal(intersection.normal, box.center, capsule.center),
+    };
+};

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

@@ -0,0 +1,15 @@
+import type { BoxGeometry, CapsuleGeometry, Intersection } from '../../types';
+/**
+ * Builds a box-vs-capsule manifold using the cheapest valid path for the
+ * contact shape.
+ *
+ * Edge-to-axis distance handles the common side/corner case directly: if the
+ * closest box edge and capsule axis are farther apart than the capsule radius,
+ * the shapes are separated; otherwise the closest box point is already a good
+ * contact. When the axis penetrates or lies inside the box, distance alone
+ * cannot pick a stable separation direction, so the function falls back to SAT
+ * over the box face normals plus the capsule axis normal. The chosen SAT axis
+ * gives penetration depth, and clipped axis contacts produce one or two
+ * surface points for deeper face-like overlaps.
+ */
+export declare const buildBoxCapsuleIntersection: (box: BoxGeometry, capsule: CapsuleGeometry) => Intersection | false;

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

@@ -0,0 +1,135 @@
+import { MathOps, Vector2, VectorOps, } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../../constants';
+import { orientNormal } from '../common/normals';
+import { arePointsEqual, lerpPoint } from '../common/points';
+import { getProjectionOverlap, projectPolygon, projectSegment, } from '../common/projections';
+import { getClosestPointsBetweenSegments } from '../common/segment-distance';
+/**
+ * Clips the capsule axis to the portion that lies inside the box.
+ *
+ * A capsule is a segment swept by a radius, so when the best collision axis is
+ * a face-like axis we first find the interval of the center segment that
+ * survives all box half-spaces. The resulting endpoint(s) are then shifted by
+ * the capsule radius opposite the contact normal so the manifold lies on the
+ * capsule surface rather than on its center line.
+ */
+const buildAxisContactPoints = (box, capsule, normal) => {
+    let start = 0;
+    let end = 1;
+    for (const edge of box.edges) {
+        const offset = VectorOps.dotProduct(edge.point1, edge.normal);
+        const point1Distance = VectorOps.dotProduct(capsule.point1, edge.normal) - offset;
+        const point2Distance = VectorOps.dotProduct(capsule.point2, edge.normal) - offset;
+        if (point1Distance > INTERSECTION_EPSILON &&
+            point2Distance > INTERSECTION_EPSILON) {
+            return [];
+        }
+        if (point1Distance <= INTERSECTION_EPSILON &&
+            point2Distance <= INTERSECTION_EPSILON) {
+            continue;
+        }
+        const denominator = point1Distance - point2Distance;
+        const t = denominator === 0 ? 0 : point1Distance / denominator;
+        if (point1Distance > INTERSECTION_EPSILON) {
+            start = Math.max(start, t);
+        }
+        else {
+            end = Math.min(end, t);
+        }
+        if (start > end + INTERSECTION_EPSILON) {
+            return [];
+        }
+    }
+    const contact1 = lerpPoint(capsule.point1, capsule.point2, MathOps.clamp(start, 0, 1));
+    contact1.x -= normal.x * capsule.radius;
+    contact1.y -= normal.y * capsule.radius;
+    if (Math.abs(end - start) <= INTERSECTION_EPSILON) {
+        return [contact1];
+    }
+    const contact2 = lerpPoint(capsule.point1, capsule.point2, MathOps.clamp(end, 0, 1));
+    contact2.x -= normal.x * capsule.radius;
+    contact2.y -= normal.y * capsule.radius;
+    return arePointsEqual(contact1, contact2) ? [contact1] : [contact1, contact2];
+};
+const getAxisOverlap = (box, capsule, axis) => {
+    const boxProjection = projectPolygon(box.points, axis);
+    const segmentProjection = projectSegment(capsule.point1, capsule.point2, axis);
+    const capsuleMin = segmentProjection.min - capsule.radius;
+    const capsuleMax = segmentProjection.max + capsule.radius;
+    return getProjectionOverlap(capsuleMin, capsuleMax, boxProjection.min, boxProjection.max);
+};
+/**
+ * Builds a box-vs-capsule manifold using the cheapest valid path for the
+ * contact shape.
+ *
+ * Edge-to-axis distance handles the common side/corner case directly: if the
+ * closest box edge and capsule axis are farther apart than the capsule radius,
+ * the shapes are separated; otherwise the closest box point is already a good
+ * contact. When the axis penetrates or lies inside the box, distance alone
+ * cannot pick a stable separation direction, so the function falls back to SAT
+ * over the box face normals plus the capsule axis normal. The chosen SAT axis
+ * gives penetration depth, and clipped axis contacts produce one or two
+ * surface points for deeper face-like overlaps.
+ */
+export const buildBoxCapsuleIntersection = (box, capsule) => {
+    let closestBoxPoint = box.points[0];
+    let closestCapsulePoint = capsule.point1;
+    let minDistance = Infinity;
+    for (const edge of box.edges) {
+        const closest = getClosestPointsBetweenSegments(edge, capsule);
+        if (closest.distance < minDistance) {
+            minDistance = closest.distance;
+            closestBoxPoint = closest.point1;
+            closestCapsulePoint = closest.point2;
+        }
+    }
+    if (VectorOps.isPointInPolygon(capsule.point1, box.edges)) {
+        minDistance = 0;
+        closestBoxPoint = capsule.point1;
+        closestCapsulePoint = capsule.point1;
+    }
+    else if (VectorOps.isPointInPolygon(capsule.point2, box.edges)) {
+        minDistance = 0;
+        closestBoxPoint = capsule.point2;
+        closestCapsulePoint = capsule.point2;
+    }
+    if (minDistance > capsule.radius + INTERSECTION_EPSILON) {
+        return false;
+    }
+    if (minDistance > INTERSECTION_EPSILON) {
+        const normal = new Vector2(closestCapsulePoint.x - closestBoxPoint.x, closestCapsulePoint.y - closestBoxPoint.y).normalize();
+        return {
+            normal,
+            penetration: Math.max(0, capsule.radius - minDistance),
+            contactPoints: [closestBoxPoint],
+        };
+    }
+    let minOverlap = Infinity;
+    let bestAxis = box.edges[0].normal;
+    for (let i = 0; i < 2; i += 1) {
+        const edge = box.edges[i];
+        const overlap = getAxisOverlap(box, capsule, edge.normal);
+        if (overlap === false) {
+            return false;
+        }
+        if (overlap < minOverlap) {
+            minOverlap = overlap;
+            bestAxis = edge.normal;
+        }
+    }
+    const capsuleAxisOverlap = getAxisOverlap(box, capsule, capsule.normal);
+    if (capsuleAxisOverlap === false) {
+        return false;
+    }
+    if (capsuleAxisOverlap < minOverlap) {
+        minOverlap = capsuleAxisOverlap;
+        bestAxis = capsule.normal;
+    }
+    const contactNormal = orientNormal(bestAxis.clone(), box.center, capsule.center);
+    const contactPoints = buildAxisContactPoints(box, capsule, contactNormal);
+    return {
+        normal: bestAxis.clone(),
+        penetration: minOverlap,
+        contactPoints: contactPoints.length > 0 ? contactPoints : [closestBoxPoint],
+    };
+};

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

@@ -1,5 +1,6 @@
 import { MathOps, Vector2, VectorOps, } from '../../../../../../../engine/math-lib';
-import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+import { INTERSECTION_EPSILON } from '../../constants';
+import { orientNormal } from '../common/normals';
 const buildNormal = (circle, closestEdge, closestPoint) => {
     let normal = new Vector2(circle.center.x - closestPoint.x, circle.center.y - closestPoint.y);
     if (normal.magnitude === 0) {
@@ -15,9 +16,8 @@ const buildNormal = (circle, closestEdge, closestPoint) => {
  * collision direction and penetration is measured to that face.
  */
 export const checkBoxAndCircleIntersection = (arg1, arg2) => {
-    const isBoxFirst = 'radius' in arg2.geometry;
-    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
-    const circle = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    const box = arg1.geometry;
+    const circle = arg2.geometry;
     let closestEdge = box.edges[0];
     let closestPoint = box.points[0];
     let minDistance = Infinity;
@@ -39,7 +39,7 @@ export const checkBoxAndCircleIntersection = (arg1, arg2) => {
         ? circle.radius + minDistance
         : Math.max(0, circle.radius - minDistance);
     return {
-        normal: orientNormal(buildNormal(circle, closestEdge, closestPoint), arg1.geometry.center, arg2.geometry.center),
+        normal: orientNormal(buildNormal(circle, closestEdge, closestPoint), box.center, circle.center),
         penetration,
         contactPoints: [closestPoint],
     };

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

@@ -1,5 +1,5 @@
 import { buildBoxSegmentContactPoints, findMinBoxSegmentOverlap } from './utils';
-import { orientNormal } from '../utils';
+import { orientNormal } from '../common/normals';
 /**
  * Checks a box against a segment.
  *
@@ -9,9 +9,8 @@ import { orientNormal } from '../utils';
  * segment, and explicit edge/segment intersections.
  */
 export const checkBoxAndSegmentIntersection = (arg1, arg2) => {
-    const isBoxFirst = 'edges' in arg1.geometry;
-    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
-    const segment = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    const box = arg1.geometry;
+    const segment = arg2.geometry;
     const overlap = findMinBoxSegmentOverlap(box, segment);
     if (overlap === false) {
         return false;
@@ -21,7 +20,7 @@ export const checkBoxAndSegmentIntersection = (arg1, arg2) => {
         return false;
     }
     return {
-        normal: orientNormal(overlap.axis.clone(), arg1.geometry.center, arg2.geometry.center),
+        normal: orientNormal(overlap.axis.clone(), box.center, segment.center),
         penetration: overlap.overlap,
         contactPoints,
     };

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

@@ -1,6 +1,5 @@
 import { type Vector2 } from '../../../../../../../engine/math-lib';
 import type { BoxGeometry, Point, SegmentGeometry } from '../../types';
-export declare const lerpPoint: (point1: Point, point2: Point, value: number) => Point;
 export declare const findMinBoxSegmentOverlap: (box: BoxGeometry, segment: SegmentGeometry) => {
     axis: Vector2;
     overlap: number;

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

@@ -1,29 +1,34 @@
 import { MathOps, VectorOps, } from '../../../../../../../engine/math-lib';
-import { INTERSECTION_EPSILON, projectPolygon } from '../utils';
-const arePointsEqual = (point1, point2) => Math.abs(point1.x - point2.x) <= INTERSECTION_EPSILON &&
-    Math.abs(point1.y - point2.y) <= INTERSECTION_EPSILON;
-export const lerpPoint = (point1, point2, value) => ({
-    x: point1.x + (point2.x - point1.x) * value,
-    y: point1.y + (point2.y - point1.y) * value,
-});
+import { arePointsEqual, lerpPoint } from '../common/points';
+import { INTERSECTION_EPSILON } from '../../constants';
+import { getProjectionOverlap, projectPolygon, projectSegment, } from '../common/projections';
+const getBoxSegmentAxisOverlap = (box, segment, axis) => {
+    const boxProjection = projectPolygon(box.points, axis);
+    const segmentProjection = projectSegment(segment.point1, segment.point2, axis);
+    return getProjectionOverlap(segmentProjection.min, segmentProjection.max, boxProjection.min, boxProjection.max);
+};
 export const findMinBoxSegmentOverlap = (box, segment) => {
-    const axes = [...box.edges.map((edge) => edge.normal), segment.normal];
     let minOverlap = Infinity;
-    let bestAxis = axes[0];
-    for (const axis of axes) {
-        const boxProjection = projectPolygon(box.points, axis);
-        const segmentProjection = projectPolygon([segment.point1, segment.point2], axis);
-        const distance1 = segmentProjection.min - boxProjection.max;
-        const distance2 = boxProjection.min - segmentProjection.max;
-        if (distance1 > INTERSECTION_EPSILON || distance2 > INTERSECTION_EPSILON) {
+    let bestAxis = box.edges[0].normal;
+    for (let i = 0; i < 2; i += 1) {
+        const edge = box.edges[i];
+        const overlap = getBoxSegmentAxisOverlap(box, segment, edge.normal);
+        if (overlap === false) {
             return false;
         }
-        const overlap = Math.min(Math.abs(distance1), Math.abs(distance2));
         if (overlap < minOverlap) {
             minOverlap = overlap;
-            bestAxis = axis;
+            bestAxis = edge.normal;
         }
     }
+    const segmentAxisOverlap = getBoxSegmentAxisOverlap(box, segment, segment.normal);
+    if (segmentAxisOverlap === false) {
+        return false;
+    }
+    if (segmentAxisOverlap < minOverlap) {
+        minOverlap = segmentAxisOverlap;
+        bestAxis = segment.normal;
+    }
     return {
         axis: bestAxis,
         overlap: minOverlap,

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

@@ -0,0 +1,14 @@
+import type { Intersection, Proxy } from '../../types';
+/**
+ * Checks two capsules for intersection.
+ *
+ * Each capsule is represented by its center segment swept by a radius. The
+ * closest points between the two finite center segments define the collision
+ * direction. The capsules overlap when that segment distance is less than or
+ * equal to the sum of both radii.
+ *
+ * The contact point is placed on the surface
+ * of the second capsule along the separating direction, matching the manifold
+ * orientation used by the other pair checkers.
+ */
+export declare const checkCapsulesIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;