@codexo/exojs 0.6.11 → 0.6.12

package/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to ExoJS are documented in this file.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.12] - 2026-05-02
+
+Adds swept (continuous) collision detection. Pure-math addition —
+prevents fast-moving shapes from tunneling through stationary
+colliders during a single frame's update.
+
+### Added
+
+- **`sweepRectangle(moving, deltaX, deltaY, target)`** — swept AABB
+  vs AABB via the slab method. Returns `SweptHit | null` with time
+  of impact `t ∈ [0..1]`, contact position `(x, y)`, and surface
+  normal `(normalX, normalY)`. Handles already-overlapping case
+  (returns `t = 0` with deepest-penetration axis as normal).
+- **`sweepCircleVsCircle(moving, deltaX, deltaY, target)`** —
+  closed-form quadratic solution.
+- **`sweepCircleVsRectangle(moving, deltaX, deltaY, target)`** —
+  v1 uses the simple expanded-AABB fallback (rectangle expanded
+  by circle radius, treated as AABB swept against zero-sized
+  moving circle). Over-collides slightly at corners — true
+  Minkowski corner rounding is V2.
+- **`sweepRectangleAgainst(moving, dx, dy, targets)`** /
+  **`sweepCircleAgainst(moving, dx, dy, targets)`** — earliest
+  hit against an array of static colliders. Broad-phase swept-AABB
+  early-out per target.
+- **`substepSweep(fromX, fromY, deltaX, deltaY, maxStepSize)`** —
+  generator that yields `(x, y, t)` snapshots along a movement
+  vector at fixed intervals. Use this for arbitrary shape pairs
+  that lack a closed-form swept test: iterate, place shape at
+  each snapshot, run discrete intersection.
+- **`SweptHit` interface** exported.
+
+### Notes
+
+- Pure math only — no Scene / RenderNode / Physics integration. User
+  code calls these in their game's update step.
+- v1 covers the common cases (AABB + Circle). Polygon-vs-anything
+  swept tests are V2 (use `substepSweep` as a fallback for now).
+- Returns the hit; does NOT compute response. Sliding / bouncing /
+  velocity adjustment is the caller's responsibility.
+
 ## [0.6.11] - 2026-05-02
 
 Adds a fluent-builder Tween / Animation system. Pure addition — no

package/dist/esm/index.js

@@ -58,6 +58,7 @@ export { Random } from './math/Random.js';
 export { Segment } from './math/Segment.js';
 export { Size } from './math/Size.js';
 export { PolarVector } from './math/PolarVector.js';
+export { substepSweep, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst } from './math/swept-collision.js';
 export { ColorAffector } from './particles/affectors/ColorAffector.js';
 export { ForceAffector } from './particles/affectors/ForceAffector.js';
 export { ScaleAffector } from './particles/affectors/ScaleAffector.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/math/index.d.ts

@@ -24,3 +24,4 @@ export * from './Random';
 export * from './Segment';
 export * from './Size';
 export * from './PolarVector';
+export * from './swept-collision';

package/dist/esm/math/swept-collision.d.ts

@@ -0,0 +1,90 @@
+import { Rectangle } from './Rectangle';
+import type { CircleLike } from './CircleLike';
+/**
+ * Result of a swept-collision query. The moving shape's reference point
+ * is at `(x, y)` at impact, having travelled fraction `t` ∈ [0..1] of
+ * the requested move (where 0 = no movement, 1 = full move). The
+ * `(normalX, normalY)` vector is the contact normal pointing AWAY from
+ * the target (suitable for sliding response: project the remaining
+ * velocity onto the perpendicular).
+ */
+export interface SweptHit {
+    readonly t: number;
+    readonly x: number;
+    readonly y: number;
+    readonly normalX: number;
+    readonly normalY: number;
+}
+/**
+ * Swept axis-aligned box vs. axis-aligned box.
+ *
+ * Uses the separating-axis slab method: for each axis we compute the entry
+ * and exit times of the moving box's slab vs the static box's slab, then
+ * combine.  `t` is the fraction of the requested move at which first contact
+ * occurs (0 = already overlapping at start, 1 = just barely reaches).
+ *
+ * Already-overlapping case (tEntry < 0 overall): returns `t = 0` with the
+ * normal of the deepest-penetration axis, allowing callers to handle the
+ * "I'm already inside" situation without a separate discrete test.
+ */
+export declare function sweepRectangle(moving: Rectangle, deltaX: number, deltaY: number, target: Rectangle): SweptHit | null;
+/**
+ * Swept circle vs. axis-aligned box.
+ *
+ * **V1 implementation** uses the simple Minkowski expansion fallback:
+ * the target rectangle is expanded by `circle.radius` on all sides, then
+ * `sweepRectangle` is run treating the circle centre as a zero-sized moving
+ * box.  This over-collides at rectangle corners (the circle collides with the
+ * expanded-rect's flat face when geometrically it should curve around the
+ * corner), producing slightly early hits in corner-quadrant trajectories —
+ * a known and acceptable accuracy trade-off for V1.
+ *
+ * TODO (V2): Replace with the full Minkowski rounded-rectangle formulation
+ * that handles the four corner quadrants with per-corner circle-vs-circle
+ * sub-tests.
+ */
+export declare function sweepCircleVsRectangle(moving: CircleLike, deltaX: number, deltaY: number, target: Rectangle): SweptHit | null;
+/**
+ * Swept circle vs. stationary circle.
+ *
+ * Solves `|(moving.centre + delta*t) − target.centre|² = (r1+r2)²` for t,
+ * yielding a quadratic.  Returns the smaller root if it is in [0, 1].
+ *
+ * Already-overlapping case: returns `{ t: 0 }` with the normal pointing from
+ * target → moving (or an arbitrary normal if both centres coincide).
+ */
+export declare function sweepCircleVsCircle(moving: CircleLike, deltaX: number, deltaY: number, target: CircleLike): SweptHit | null;
+/**
+ * Returns the earliest `SweptHit` against an array of rectangle targets, or
+ * `null` if none are hit.
+ *
+ * Optimisation: before testing each target individually the swept AABB of the
+ * moving rectangle is computed once; targets whose AABB does not overlap the
+ * swept AABB are skipped.
+ */
+export declare function sweepRectangleAgainst(moving: Rectangle, deltaX: number, deltaY: number, targets: ReadonlyArray<Rectangle>): SweptHit | null;
+/**
+ * Returns the earliest `SweptHit` against an array of circle targets, or
+ * `null` if none are hit.
+ *
+ * Optimisation: the swept AABB of the moving circle is computed once and used
+ * to skip targets that cannot possibly be reached.
+ */
+export declare function sweepCircleAgainst(moving: CircleLike, deltaX: number, deltaY: number, targets: ReadonlyArray<CircleLike>): SweptHit | null;
+/**
+ * Generator that yields evenly-spaced position snapshots along a movement
+ * vector so the caller can run their own discrete intersection check at each
+ * step.  Useful for arbitrary shape pairs that lack a closed-form swept test.
+ *
+ * `maxStepSize` controls the step granularity — smaller values produce more
+ * accurate detection but more iterations.  Use the smallest dimension of the
+ * smaller collider as a sensible default.
+ *
+ * Always yields at least 2 snapshots (t=0 and t=1), even for zero-length
+ * deltas.
+ */
+export declare function substepSweep(fromX: number, fromY: number, deltaX: number, deltaY: number, maxStepSize: number): IterableIterator<{
+    x: number;
+    y: number;
+    t: number;
+}>;

package/dist/esm/math/swept-collision.js

@@ -0,0 +1,255 @@
+import { Rectangle } from './Rectangle.js';
+
+// ---------------------------------------------------------------------------
+// sweepRectangle — AABB vs AABB slab method
+// ---------------------------------------------------------------------------
+/**
+ * Swept axis-aligned box vs. axis-aligned box.
+ *
+ * Uses the separating-axis slab method: for each axis we compute the entry
+ * and exit times of the moving box's slab vs the static box's slab, then
+ * combine.  `t` is the fraction of the requested move at which first contact
+ * occurs (0 = already overlapping at start, 1 = just barely reaches).
+ *
+ * Already-overlapping case (tEntry < 0 overall): returns `t = 0` with the
+ * normal of the deepest-penetration axis, allowing callers to handle the
+ * "I'm already inside" situation without a separate discrete test.
+ */
+function sweepRectangle(moving, deltaX, deltaY, target) {
+    const movMinX = moving.x;
+    const movMaxX = moving.x + moving.width;
+    const movMinY = moving.y;
+    const movMaxY = moving.y + moving.height;
+    const tarMinX = target.x;
+    const tarMaxX = target.x + target.width;
+    const tarMinY = target.y;
+    const tarMaxY = target.y + target.height;
+    // X axis
+    let tEntryX = -Infinity;
+    let tExitX = Infinity;
+    if (deltaX > 0) {
+        tEntryX = (tarMinX - movMaxX) / deltaX;
+        tExitX = (tarMaxX - movMinX) / deltaX;
+    }
+    else if (deltaX < 0) {
+        tEntryX = (tarMaxX - movMinX) / deltaX;
+        tExitX = (tarMinX - movMaxX) / deltaX;
+    }
+    else if (movMaxX <= tarMinX || movMinX >= tarMaxX) {
+        // No movement on X and no static overlap — can never collide
+        return null;
+    }
+    // Y axis
+    let tEntryY = -Infinity;
+    let tExitY = Infinity;
+    if (deltaY > 0) {
+        tEntryY = (tarMinY - movMaxY) / deltaY;
+        tExitY = (tarMaxY - movMinY) / deltaY;
+    }
+    else if (deltaY < 0) {
+        tEntryY = (tarMaxY - movMinY) / deltaY;
+        tExitY = (tarMinY - movMaxY) / deltaY;
+    }
+    else if (movMaxY <= tarMinY || movMinY >= tarMaxY) {
+        // No movement on Y and no static overlap — can never collide
+        return null;
+    }
+    const tEntry = Math.max(tEntryX, tEntryY);
+    const tExit = Math.min(tExitX, tExitY);
+    // No overlap window
+    if (tEntry > tExit || tExit < 0 || tEntry > 1) {
+        return null;
+    }
+    const t = Math.max(0, tEntry);
+    const hitX = moving.x + deltaX * t;
+    const hitY = moving.y + deltaY * t;
+    // Normal is on the axis whose slab entry was latest.
+    // Already-overlapping: use the deepest-penetration axis normal.
+    let normalX = 0;
+    let normalY = 0;
+    if (tEntry <= 0) {
+        // Already overlapping — pick the axis with least penetration
+        const overlapX = Math.min(movMaxX - tarMinX, tarMaxX - movMinX);
+        const overlapY = Math.min(movMaxY - tarMinY, tarMaxY - movMinY);
+        if (overlapX < overlapY) {
+            normalX = movMinX < tarMinX ? -1 : 1;
+        }
+        else {
+            normalY = movMinY < tarMinY ? -1 : 1;
+        }
+    }
+    else if (tEntryX > tEntryY) {
+        // X axis had the latest entry
+        normalX = deltaX > 0 ? -1 : 1;
+    }
+    else {
+        // Y axis had the latest entry
+        normalY = deltaY > 0 ? -1 : 1;
+    }
+    return { t, x: hitX, y: hitY, normalX, normalY };
+}
+// ---------------------------------------------------------------------------
+// sweepCircleVsRectangle — expanded-AABB simple fallback (V1)
+// ---------------------------------------------------------------------------
+/**
+ * Swept circle vs. axis-aligned box.
+ *
+ * **V1 implementation** uses the simple Minkowski expansion fallback:
+ * the target rectangle is expanded by `circle.radius` on all sides, then
+ * `sweepRectangle` is run treating the circle centre as a zero-sized moving
+ * box.  This over-collides at rectangle corners (the circle collides with the
+ * expanded-rect's flat face when geometrically it should curve around the
+ * corner), producing slightly early hits in corner-quadrant trajectories —
+ * a known and acceptable accuracy trade-off for V1.
+ *
+ * TODO (V2): Replace with the full Minkowski rounded-rectangle formulation
+ * that handles the four corner quadrants with per-corner circle-vs-circle
+ * sub-tests.
+ */
+function sweepCircleVsRectangle(moving, deltaX, deltaY, target) {
+    const r = moving.radius;
+    // Expanded target: grow each side by the circle radius
+    const expanded = new Rectangle(target.x - r, target.y - r, target.width + r * 2, target.height + r * 2);
+    // Treat the circle centre as a zero-sized moving box
+    const centreBox = new Rectangle(moving.x, moving.y, 0, 0);
+    return sweepRectangle(centreBox, deltaX, deltaY, expanded);
+}
+// ---------------------------------------------------------------------------
+// sweepCircleVsCircle — quadratic equation
+// ---------------------------------------------------------------------------
+/**
+ * Swept circle vs. stationary circle.
+ *
+ * Solves `|(moving.centre + delta*t) − target.centre|² = (r1+r2)²` for t,
+ * yielding a quadratic.  Returns the smaller root if it is in [0, 1].
+ *
+ * Already-overlapping case: returns `{ t: 0 }` with the normal pointing from
+ * target → moving (or an arbitrary normal if both centres coincide).
+ */
+function sweepCircleVsCircle(moving, deltaX, deltaY, target) {
+    const dx = moving.x - target.x;
+    const dy = moving.y - target.y;
+    const r = moving.radius + target.radius;
+    const a = deltaX * deltaX + deltaY * deltaY;
+    const b = 2 * (dx * deltaX + dy * deltaY);
+    const c = dx * dx + dy * dy - r * r;
+    // Already overlapping at start
+    if (c <= 0) {
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        const normalX = dist > 0 ? dx / dist : 1;
+        const normalY = dist > 0 ? dy / dist : 0;
+        return { t: 0, x: moving.x, y: moving.y, normalX, normalY };
+    }
+    // No movement
+    if (a === 0) {
+        return null;
+    }
+    const disc = b * b - 4 * a * c;
+    if (disc < 0) {
+        return null;
+    }
+    const t = (-b - Math.sqrt(disc)) / (2 * a);
+    if (t < 0 || t > 1) {
+        return null;
+    }
+    const hitX = moving.x + deltaX * t;
+    const hitY = moving.y + deltaY * t;
+    // Normal points from target centre → hit circle centre
+    const normalX = (hitX - target.x) / r;
+    const normalY = (hitY - target.y) / r;
+    return { t, x: hitX, y: hitY, normalX, normalY };
+}
+// ---------------------------------------------------------------------------
+// Batch helpers — sweep a shape against multiple targets
+// ---------------------------------------------------------------------------
+/**
+ * Returns the earliest `SweptHit` against an array of rectangle targets, or
+ * `null` if none are hit.
+ *
+ * Optimisation: before testing each target individually the swept AABB of the
+ * moving rectangle is computed once; targets whose AABB does not overlap the
+ * swept AABB are skipped.
+ */
+function sweepRectangleAgainst(moving, deltaX, deltaY, targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    // Swept AABB of the moving rectangle (broad-phase skip)
+    const sweptMinX = Math.min(moving.x, moving.x + deltaX);
+    const sweptMaxX = Math.max(moving.x + moving.width, moving.x + moving.width + deltaX);
+    const sweptMinY = Math.min(moving.y, moving.y + deltaY);
+    const sweptMaxY = Math.max(moving.y + moving.height, moving.y + moving.height + deltaY);
+    let earliest = null;
+    for (const target of targets) {
+        // Broad-phase: skip if swept AABB doesn't overlap target AABB
+        if (sweptMaxX <= target.x
+            || sweptMinX >= target.x + target.width
+            || sweptMaxY <= target.y
+            || sweptMinY >= target.y + target.height) {
+            continue;
+        }
+        const hit = sweepRectangle(moving, deltaX, deltaY, target);
+        if (hit !== null && (earliest === null || hit.t < earliest.t)) {
+            earliest = hit;
+        }
+    }
+    return earliest;
+}
+/**
+ * Returns the earliest `SweptHit` against an array of circle targets, or
+ * `null` if none are hit.
+ *
+ * Optimisation: the swept AABB of the moving circle is computed once and used
+ * to skip targets that cannot possibly be reached.
+ */
+function sweepCircleAgainst(moving, deltaX, deltaY, targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    // Swept AABB of the moving circle
+    const sweptMinX = Math.min(moving.x, moving.x + deltaX) - moving.radius;
+    const sweptMaxX = Math.max(moving.x, moving.x + deltaX) + moving.radius;
+    const sweptMinY = Math.min(moving.y, moving.y + deltaY) - moving.radius;
+    const sweptMaxY = Math.max(moving.y, moving.y + deltaY) + moving.radius;
+    let earliest = null;
+    for (const target of targets) {
+        // Broad-phase: skip if swept AABB doesn't overlap target's AABB
+        if (sweptMaxX <= target.x - target.radius
+            || sweptMinX >= target.x + target.radius
+            || sweptMaxY <= target.y - target.radius
+            || sweptMinY >= target.y + target.radius) {
+            continue;
+        }
+        const hit = sweepCircleVsCircle(moving, deltaX, deltaY, target);
+        if (hit !== null && (earliest === null || hit.t < earliest.t)) {
+            earliest = hit;
+        }
+    }
+    return earliest;
+}
+// ---------------------------------------------------------------------------
+// substepSweep — generic fallback iterator
+// ---------------------------------------------------------------------------
+/**
+ * Generator that yields evenly-spaced position snapshots along a movement
+ * vector so the caller can run their own discrete intersection check at each
+ * step.  Useful for arbitrary shape pairs that lack a closed-form swept test.
+ *
+ * `maxStepSize` controls the step granularity — smaller values produce more
+ * accurate detection but more iterations.  Use the smallest dimension of the
+ * smaller collider as a sensible default.
+ *
+ * Always yields at least 2 snapshots (t=0 and t=1), even for zero-length
+ * deltas.
+ */
+function* substepSweep(fromX, fromY, deltaX, deltaY, maxStepSize) {
+    const length = Math.hypot(deltaX, deltaY);
+    const stepCount = Math.max(1, Math.ceil(length / maxStepSize));
+    for (let i = 0; i <= stepCount; i++) {
+        const t = i / stepCount;
+        yield { x: fromX + deltaX * t, y: fromY + deltaY * t, t };
+    }
+}
+
+export { substepSweep, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst };
+//# sourceMappingURL=swept-collision.js.map

package/dist/esm/math/swept-collision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swept-collision.js","sources":["../../../../src/math/swept-collision.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}