dacha 0.18.0-alpha.7 → 0.18.0-alpha.9

package/build/contrib/systems/character-controller/index.js

@@ -3,8 +3,9 @@ import { SceneSystem } from '../../../engine/system';
 import { Vector2, VectorOps } from '../../../engine/math-lib';
 import { Collider, CharacterBody, RigidBody, Transform, } from '../../components';
 import { PhysicsAPI } from '../physics-system';
-import { OneWayValidator } from '../../utils/one-way-validator';
 import { CharacterHit } from '../../events';
+import { RemoveActor } from '../../../engine/events';
+import { OneWayValidator } from './one-way-validator';
 import { clipAgainstNormal } from './utils';
 const DISTANCE_EPSILON = 0.000001;
 const SNAP_EPSILON = 0.000001;
@@ -21,19 +22,26 @@ const SNAP_EPSILON = 0.000001;
 export class CharacterController extends SceneSystem {
     actorQuery;
     world;
+    time;
     oneWayValidator;
     constructor(options) {
         super();
         this.world = options.world;
+        this.time = options.time;
         this.actorQuery = new ActorQuery({
             scene: options.scene,
             filter: [CharacterBody, Transform, Collider, RigidBody],
         });
+        this.actorQuery.addEventListener(RemoveActor, this.handleRemoveActor);
         this.oneWayValidator = new OneWayValidator();
     }
     onSceneDestroy() {
+        this.actorQuery.removeEventListener(RemoveActor, this.handleRemoveActor);
         this.actorQuery.destroy();
     }
+    handleRemoveActor = (event) => {
+        this.oneWayValidator.delete(event.actor);
+    };
     isBlockingHit(actor, hit) {
         const rigidBody = hit.actor.getComponent(RigidBody);
         if (!rigidBody || rigidBody.disabled) {
@@ -42,22 +50,18 @@ export class CharacterController extends SceneSystem {
         if (!rigidBody?.oneWay || !rigidBody.oneWayNormal) {
             return true;
         }
-        return this.oneWayValidator.validate(hit.actor, actor, hit.normal);
+        return this.oneWayValidator.shouldBlock(hit.actor, actor, hit.normal);
     }
     isWalkable(actor, normal) {
         const character = actor.getComponent(CharacterBody);
         return (VectorOps.dotProduct(normal, character.upDirection) >=
             Math.cos(character.maxSlopeAngle));
     }
-    isRecoverableOverlap(actor, hit) {
+    isRecoverableOverlap(hit) {
         const rigidBody = hit.actor.getComponent(RigidBody);
-        if (!rigidBody || rigidBody.disabled || rigidBody.type === 'dynamic') {
-            return false;
-        }
-        if (!rigidBody.oneWay || !rigidBody.oneWayNormal) {
-            return true;
-        }
-        return this.oneWayValidator.validate(hit.actor, actor, hit.normal);
+        return (rigidBody !== undefined &&
+            !rigidBody.disabled &&
+            rigidBody.type !== 'dynamic');
     }
     resetGroundState(character) {
         if (character.onGround) {
@@ -79,6 +83,7 @@ export class CharacterController extends SceneSystem {
         const character = actor.getComponent(CharacterBody);
         const transform = actor.getComponent(Transform);
         const distance = displacement.magnitude;
+        this.oneWayValidator.touch(actor);
         return physicsApi.castActor({
             actor,
             offset: {
@@ -87,7 +92,7 @@ export class CharacterController extends SceneSystem {
             },
             direction: displacement,
             maxDistance: distance + character.skinWidth,
-            hitFilter,
+            hitFilter: (hit) => this.isBlockingHit(actor, hit) && hitFilter(hit),
         });
     }
     castMotion(actor, position, displacement) {
@@ -96,11 +101,11 @@ export class CharacterController extends SceneSystem {
                 VectorOps.dotProduct(displacement, hit.normal) > DISTANCE_EPSILON) {
                 return false;
             }
-            return this.isBlockingHit(actor, hit);
+            return true;
         });
     }
     castGround(actor, position, displacement) {
-        return this.cast(actor, position, displacement, (hit) => this.isBlockingHit(actor, hit) && this.isWalkable(actor, hit.normal));
+        return this.cast(actor, position, displacement, (hit) => this.isWalkable(actor, hit.normal));
     }
     recoverOverlaps(actor, position) {
         const character = actor.getComponent(CharacterBody);
@@ -119,7 +124,7 @@ export class CharacterController extends SceneSystem {
             });
             let recovered = false;
             for (const hit of hits) {
-                if (!this.isRecoverableOverlap(actor, hit)) {
+                if (!this.isRecoverableOverlap(hit)) {
                     continue;
                 }
                 const correction = hit.penetration + character.skinWidth;
@@ -189,7 +194,6 @@ export class CharacterController extends SceneSystem {
             position.x += direction.x * safeDistance;
             position.y += direction.y * safeDistance;
             this.handleHit(actor, hit);
-            clipAgainstNormal(character.velocity, hit.normal);
             const remainingDistance = Math.max(distance - safeDistance, 0);
             displacement.x = direction.x * remainingDistance;
             displacement.y = direction.y * remainingDistance;
@@ -221,11 +225,11 @@ export class CharacterController extends SceneSystem {
         target.x += snapDirection.x;
         target.y += snapDirection.y;
     }
-    fixedUpdate(options) {
+    fixedUpdate() {
         if (!this.world.systemApi.has(PhysicsAPI)) {
             return;
         }
-        const deltaTimeInSeconds = options.deltaTime / 1000;
+        const { fixedDeltaTime } = this.time;
         this.oneWayValidator.update();
         this.actorQuery.getActors().forEach((actor) => {
             const transform = actor.getComponent(Transform);
@@ -244,7 +248,7 @@ export class CharacterController extends SceneSystem {
             this.recoverOverlaps(actor, position);
             const displacement = character.velocity
                 .clone()
-                .multiplyNumber(deltaTimeInSeconds)
+                .multiplyNumber(fixedDeltaTime)
                 .add(character._displacement);
             const movingUp = VectorOps.dotProduct(displacement, character.upDirection) >
                 SNAP_EPSILON;

package/build/contrib/systems/character-controller/one-way-validator.d.ts

@@ -0,0 +1,15 @@
+import type { Actor } from '../../../engine/actor';
+import { type Point } from '../../../engine/math-lib';
+export declare class OneWayValidator {
+    private ignoredOneWayContacts;
+    private touchedActors;
+    private oneWayContactUpdateIndex;
+    constructor();
+    private clearOneWayContacts;
+    private trackOneWayContact;
+    touch(actor: Actor): void;
+    shouldBlock(oneWayActor: Actor, otherActor: Actor, normal: Point): boolean;
+    delete(actor: Actor): void;
+    update(): void;
+    lateUpdate(): void;
+}

package/build/contrib/systems/character-controller/one-way-validator.js

@@ -0,0 +1,73 @@
+import { RigidBody, Transform } from '../../components';
+import { VectorOps } from '../../../engine/math-lib';
+export class OneWayValidator {
+    ignoredOneWayContacts;
+    touchedActors;
+    oneWayContactUpdateIndex;
+    constructor() {
+        this.ignoredOneWayContacts = new Map();
+        this.touchedActors = new Set();
+        this.oneWayContactUpdateIndex = 0;
+    }
+    clearOneWayContacts() {
+        this.touchedActors.forEach((actor) => {
+            const ignoredContacts = this.ignoredOneWayContacts.get(actor);
+            if (!ignoredContacts) {
+                return;
+            }
+            ignoredContacts.forEach((lastSeenUpdate, otherActor) => {
+                if (lastSeenUpdate !== this.oneWayContactUpdateIndex) {
+                    ignoredContacts.delete(otherActor);
+                }
+            });
+            if (ignoredContacts.size === 0) {
+                this.ignoredOneWayContacts.delete(actor);
+            }
+        });
+        if (this.ignoredOneWayContacts.size === 0) {
+            this.oneWayContactUpdateIndex = 0;
+        }
+    }
+    trackOneWayContact(actor, oneWayActor) {
+        let ignoredContacts = this.ignoredOneWayContacts.get(actor);
+        if (!ignoredContacts) {
+            ignoredContacts = new Map();
+            this.ignoredOneWayContacts.set(actor, ignoredContacts);
+        }
+        ignoredContacts.set(oneWayActor, this.oneWayContactUpdateIndex);
+    }
+    touch(actor) {
+        this.touchedActors.add(actor);
+    }
+    shouldBlock(oneWayActor, otherActor, normal) {
+        if (this.ignoredOneWayContacts.get(otherActor)?.has(oneWayActor)) {
+            this.trackOneWayContact(otherActor, oneWayActor);
+            return false;
+        }
+        const rigidBody = oneWayActor.getComponent(RigidBody);
+        const transform = oneWayActor.getComponent(Transform);
+        const oneWayNormal = VectorOps.rotatePoint(rigidBody.oneWayNormal, transform.world.rotation);
+        if (VectorOps.dotProduct(oneWayNormal, normal) > 0) {
+            return true;
+        }
+        this.trackOneWayContact(otherActor, oneWayActor);
+        return false;
+    }
+    delete(actor) {
+        this.ignoredOneWayContacts.delete(actor);
+        this.touchedActors.delete(actor);
+        this.ignoredOneWayContacts.forEach((ignoredContacts, trackedActor) => {
+            ignoredContacts.delete(actor);
+            if (ignoredContacts.size === 0) {
+                this.ignoredOneWayContacts.delete(trackedActor);
+            }
+        });
+    }
+    update() {
+        this.oneWayContactUpdateIndex += 1;
+    }
+    lateUpdate() {
+        this.clearOneWayContacts();
+        this.touchedActors.clear();
+    }
+}

package/build/contrib/systems/game-stats-meter/index.d.ts

@@ -1,5 +1,5 @@
 import { WorldSystem } from '../../../engine/system';
-import type { WorldSystemOptions, UpdateOptions } from '../../../engine/system';
+import type { WorldSystemOptions } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 /**
  * Game statistics meter that tracks and reports performance metrics
@@ -13,12 +13,13 @@ import type { Scene } from '../../../engine/scene';
  */
 export declare class GameStatsMeter extends WorldSystem {
     private world;
+    private time;
     private actorQuery?;
     private frequency;
     private fps;
-    private time;
+    private elapsed;
     constructor(options: WorldSystemOptions);
     onSceneEnter(scene: Scene): void;
     onSceneExit(): void;
-    update(options: UpdateOptions): void;
+    update(): void;
 }

package/build/contrib/systems/game-stats-meter/index.js

@@ -1,7 +1,7 @@
 import { WorldSystem } from '../../../engine/system';
 import { GameStatsUpdate } from '../../events';
 import { ActorQuery } from '../../../engine/actor';
-const MS_IN_SEC = 1000;
+const DEFAULT_FREQUENCY = 1;
 /**
  * Game statistics meter that tracks and reports performance metrics
  *
@@ -14,17 +14,19 @@ const MS_IN_SEC = 1000;
  */
 export class GameStatsMeter extends WorldSystem {
     world;
+    time;
     actorQuery;
     frequency;
     fps;
-    time;
+    elapsed;
     constructor(options) {
         super();
         const { world, frequency } = options;
         this.world = world;
-        this.frequency = frequency || MS_IN_SEC;
+        this.time = options.time;
+        this.frequency = frequency || DEFAULT_FREQUENCY;
         this.fps = 0;
-        this.time = 0;
+        this.elapsed = 0;
     }
     onSceneEnter(scene) {
         this.actorQuery = new ActorQuery({ scene, filter: [] });
@@ -32,17 +34,16 @@ export class GameStatsMeter extends WorldSystem {
     onSceneExit() {
         this.actorQuery = undefined;
     }
-    update(options) {
-        const { deltaTime } = options;
+    update() {
         this.fps += 1;
-        this.time += deltaTime;
-        if (this.time >= this.frequency) {
+        this.elapsed += this.time.deltaTime;
+        if (this.elapsed >= this.frequency) {
             this.world.dispatchEvent(GameStatsUpdate, {
-                fps: (this.fps * MS_IN_SEC) / this.time,
+                fps: this.fps / this.elapsed,
                 actorsCount: this.actorQuery?.getActors().size ?? 0,
             });
             this.fps = 0;
-            this.time = 0;
+            this.elapsed = 0;
         }
     }
 }

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

@@ -0,0 +1,11 @@
+export declare const DEFAULT_SOLVER_ITERATIONS = 8;
+export declare const DEFAULT_LINEAR_SLEEP_THRESHOLD = 2;
+export declare const DEFAULT_ANGULAR_SLEEP_THRESHOLD = 0.05;
+export declare const DEFAULT_SLEEP_TIME_THRESHOLD = 0.5;
+export declare const DEFAULT_MAX_BIAS_VELOCITY = 60;
+export declare const DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION = 0.5;
+export declare const CONTACT_BIAS = 0.2;
+export declare const BIAS_ANGULAR_SLEEP_MULTIPLIER = 2;
+export declare const RESTITUTION_VELOCITY_THRESHOLD = 1;
+export declare const PENETRATION_SLEEP_MARGIN = 0.25;
+export declare const SUPPORT_MIN_GRAVITY_DOT = 0.5;

package/build/contrib/systems/physics-system/consts.js

@@ -0,0 +1,14 @@
+export const DEFAULT_SOLVER_ITERATIONS = 8;
+export const DEFAULT_LINEAR_SLEEP_THRESHOLD = 2;
+export const DEFAULT_ANGULAR_SLEEP_THRESHOLD = 0.05;
+export const DEFAULT_SLEEP_TIME_THRESHOLD = 0.5;
+export const DEFAULT_MAX_BIAS_VELOCITY = 60;
+export const DEFAULT_CONTACT_MAX_ALLOWED_PENETRATION = 0.5;
+export const CONTACT_BIAS = 0.2;
+export const BIAS_ANGULAR_SLEEP_MULTIPLIER = 2;
+export const RESTITUTION_VELOCITY_THRESHOLD = 1;
+// Kept above maxAllowedPenetration so a settled stack resting at the
+// allowed slop does not wake itself from its own steady-state penetration.
+export const PENETRATION_SLEEP_MARGIN = 0.25;
+// 0.5 treats surfaces up to ~60° from horizontal as holding a body up.
+export const SUPPORT_MIN_GRAVITY_DOT = 0.5;

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

@@ -1,5 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
-import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
 /**
  * Physics system that handles 2D physics simulation and collision detection
  *
@@ -21,5 +21,5 @@ export declare class PhysicsSystem extends SceneSystem {
     onSceneEnter(): void;
     onSceneExit(): void;
     onSceneDestroy(): void;
-    fixedUpdate(options: UpdateOptions): void;
+    fixedUpdate(): void;
 }

package/build/contrib/systems/physics-system/physics-system.js

@@ -21,16 +21,27 @@ export class PhysicsSystem extends SceneSystem {
     gravity;
     constructor(options) {
         super();
-        const { gravityX = 0, gravityY = 0 } = options;
+        const { gravityX = 0, gravityY = 0, solverIterations, linearSleepThreshold, angularSleepThreshold, sleepTimeThreshold, maxAllowedPenetration, maxBiasVelocity, } = options;
         this.gravity = new Vector2(gravityX, gravityY);
         this.world = options.world;
         this.physicsSubsystem = new PhysicsSubsystem({
             scene: options.scene,
+            time: options.time,
             getGravity: () => this.gravity,
+            linearSleepThreshold,
+            angularSleepThreshold,
+            sleepTimeThreshold,
         });
         this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
         this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
-        this.constraintSolver = new ConstraintSolver();
+        this.constraintSolver = new ConstraintSolver({
+            time: options.time,
+            getGravity: () => this.gravity,
+            solverIterations,
+            maxAllowedPenetration,
+            maxBiasVelocity,
+            linearSleepThreshold,
+        });
         this.physicsApi = new PhysicsAPI({
             raycast: (params) => this.collisionDetectionSubsystem.raycast(params),
             raycastAll: (params) => this.collisionDetectionSubsystem.raycastAll(params),
@@ -56,10 +67,13 @@ export class PhysicsSystem extends SceneSystem {
         this.physicsSubsystem.destroy();
         this.collisionDetectionSubsystem.destroy();
     }
-    fixedUpdate(options) {
-        this.physicsSubsystem.update(options);
+    fixedUpdate() {
+        this.physicsSubsystem.integrateVelocities();
+        this.physicsSubsystem.integrateKinematicPositions();
         const contacts = this.collisionDetectionSubsystem.update();
         this.constraintSolver.update(contacts);
+        this.physicsSubsystem.integrateDynamicPositions();
+        this.physicsSubsystem.updateSleepTimers();
         this.collisionBroadcastSubsystem.update(contacts);
         this.physicsSubsystem.lateUpdate();
     }

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

@@ -198,7 +198,9 @@ export class CollisionDetectionSubsystem {
         return (aabb1.max[axis] >= aabb2.min[axis] && aabb1.min[axis] <= aabb2.max[axis]);
     }
     testCollisionLayers(proxy1, proxy2) {
-        return this.collisionMatrix[proxy1.layer]?.[proxy2.layer] ?? true;
+        return (this.collisionMatrix[proxy1.layer]?.[proxy2.layer] ??
+            this.collisionMatrix[proxy2.layer]?.[proxy1.layer] ??
+            true);
     }
     testState(proxy1, proxy2) {
         const actor1 = 'actor' in proxy1 ? proxy1.actor : undefined;

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

@@ -1,5 +1,6 @@
 import { orientNormal } from '../common/normals';
-import { findMinBoxesOverlap, buildContactPoints } from './utils';
+import { sortPoints } from '../common/points';
+import { findMinBoxesOverlap, buildContactPoints, OVERLAP_TIE_EPSILON, } from './utils';
 /**
  * Checks box colliders for intersection.
  *
@@ -17,7 +18,7 @@ export const checkBoxesIntersection = (geometry1, geometry2) => {
     if (overlap2 === false) {
         return false;
     }
-    const isArg1Reference = overlap1.overlap <= overlap2.overlap;
+    const isArg1Reference = overlap1.overlap <= overlap2.overlap + OVERLAP_TIE_EPSILON;
     const referenceGeometry = isArg1Reference ? geometry1 : geometry2;
     const incidentGeometry = isArg1Reference ? geometry2 : geometry1;
     const referenceOverlap = isArg1Reference ? overlap1 : overlap2;
@@ -26,9 +27,10 @@ export const checkBoxesIntersection = (geometry1, geometry2) => {
     if (!isArg1Reference) {
         referenceNormal.multiplyNumber(-1);
     }
+    const contactPoints = buildContactPoints(referenceGeometry, referenceNormal, incidentGeometry);
     return {
         normal,
         penetration: referenceOverlap.overlap,
-        contactPoints: buildContactPoints(referenceGeometry, referenceNormal, incidentGeometry),
+        contactPoints: sortPoints(contactPoints, normal),
     };
 };

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

@@ -1,6 +1,7 @@
 import { Vector2 } from '../../../../../../../engine/math-lib';
 import type { BoxGeometry, Point } from '../../types';
 export declare const CONTACT_EPSILON = 0.0001;
+export declare const OVERLAP_TIE_EPSILON = 0.0001;
 export declare const MAX_CONTACT_POINTS = 2;
 export interface AxisOverlap {
     axis: Vector2;

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

@@ -1,6 +1,7 @@
 import { Vector2, VectorOps } from '../../../../../../../engine/math-lib';
 import { getProjectionOverlap, projectPolygon } from '../common/projections';
 export const CONTACT_EPSILON = 1e-4;
+export const OVERLAP_TIE_EPSILON = 1e-4;
 export const MAX_CONTACT_POINTS = 2;
 /**
  * Runs the SAT pass for one box's face normals against another box.
@@ -22,7 +23,7 @@ export const findMinBoxesOverlap = (geometry1, geometry2) => {
         if (overlap === false) {
             return false;
         }
-        if (overlap < minOverlap) {
+        if (overlap < minOverlap - OVERLAP_TIE_EPSILON) {
             minOverlap = overlap;
             bestAxis = axis;
         }

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

@@ -1,4 +1,5 @@
 import { orientNormal } from '../common/normals';
+import { sortPoints } from '../common/points';
 import { buildBoxCapsuleIntersection } from './utils';
 /**
  * Checks a box against a capsule.
@@ -23,8 +24,10 @@ export const checkBoxAndCapsuleIntersection = (box, capsule) => {
     if (!intersection) {
         return false;
     }
+    const normal = orientNormal(intersection.normal, box.center, capsule.center);
     return {
         ...intersection,
-        normal: orientNormal(intersection.normal, box.center, capsule.center),
+        normal,
+        contactPoints: sortPoints(intersection.contactPoints, normal),
     };
 };

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

@@ -1,5 +1,6 @@
 import { buildBoxSegmentContactPoints, findMinBoxSegmentOverlap, } from './utils';
 import { orientNormal } from '../common/normals';
+import { sortPoints } from '../common/points';
 /**
  * Checks a box against a segment.
  *
@@ -17,9 +18,10 @@ export const checkBoxAndSegmentIntersection = (box, segment) => {
     if (contactPoints.length === 0) {
         return false;
     }
+    const normal = orientNormal(overlap.axis.clone(), box.center, segment.center);
     return {
-        normal: orientNormal(overlap.axis.clone(), box.center, segment.center),
+        normal,
         penetration: overlap.overlap,
-        contactPoints,
+        contactPoints: sortPoints(contactPoints, normal),
     };
 };

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

@@ -1,4 +1,6 @@
+import type { Vector2 } from '../../../../../../../engine/math-lib';
 import type { Point } from '../../types';
 export declare const arePointsEqual: (point1: Point, point2: Point) => boolean;
 export declare const lerpPoint: (point1: Point, point2: Point, value: number) => Point;
 export declare const getDistanceSquared: (point1: Point, point2: Point) => number;
+export declare const sortPoints: (points: Point[], normal: Vector2) => Point[];

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

@@ -5,3 +5,19 @@ export const lerpPoint = (point1, point2, value) => ({
     y: point1.y + (point2.y - point1.y) * value,
 });
 export const getDistanceSquared = (point1, point2) => (point1.x - point2.x) ** 2 + (point1.y - point2.y) ** 2;
+export const sortPoints = (points, normal) => {
+    if (points.length !== 2) {
+        return points;
+    }
+    const tangentX = -normal.y;
+    const tangentY = normal.x;
+    const projection1 = points[0].x * tangentX + points[0].y * tangentY;
+    const projection2 = points[1].x * tangentX + points[1].y * tangentY;
+    if (projection1 <= projection2) {
+        return points;
+    }
+    const point = points[0];
+    points[0] = points[1];
+    points[1] = point;
+    return points;
+};

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

@@ -1,3 +1,4 @@
+import { sortPoints } from './common/points';
 import { checkBoxAndCapsuleIntersection } from './box-capsule/check-box-and-capsule-intersection';
 import { checkBoxAndCircleIntersection } from './box-circle/check-box-and-circle-intersection';
 import { checkBoxAndSegmentIntersection } from './box-segment/check-box-and-segment-intersection';
@@ -18,6 +19,7 @@ const swapArgs = (checker) => {
             return false;
         }
         intersection.normal.multiplyNumber(-1);
+        sortPoints(intersection.contactPoints, intersection.normal);
         return intersection;
     };
 };

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

@@ -5,6 +5,7 @@ import { buildCircleGeometry } from '../../geometry-builders/build-circle-geomet
 import { buildPointGeometry } from '../../geometry-builders/build-point-geometry';
 import { buildRayGeometry } from '../../geometry-builders/build-ray-geometry';
 import { buildSegmentGeometry } from '../../geometry-builders/build-segment-geometry';
+import { expectHit } from '../../tests/assertions';
 export const createBoxGeometry = (centerX, centerY, sizeX, sizeY) => {
     return createRotatedBoxGeometry(centerX, centerY, sizeX, sizeY, 0);
 };
@@ -71,20 +72,8 @@ 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 expectCastHit = (hit) => {
-    expect(hit).not.toBe(false);
-    if (hit === false) {
-        throw new Error('Expected cast hit, received false');
-    }
-    return hit;
-};
+export const expectIntersection = (intersection) => expectHit(intersection, 'intersection');
+export const expectCastHit = (hit) => expectHit(hit, 'cast hit');
 export const sortPoints = (points) => [...points].sort((point1, point2) => {
     if (point1.x !== point2.x) {
         return point1.x - point2.x;

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

@@ -2,6 +2,7 @@ import { Vector2 } from '../../../../../../../engine/math-lib';
 import { buildBoxCastGeometry } from '../../geometry-builders/build-box-cast-geometry';
 import { buildCapsuleCastGeometry } from '../../geometry-builders/build-capsule-cast-geometry';
 import { buildCircleCastGeometry } from '../../geometry-builders/build-circle-cast-geometry';
+import { expectHit } from '../../tests/assertions';
 export const createCircleCastGeometry = (centerX, centerY, radius, directionX, directionY, maxDistance) => buildCircleCastGeometry({
     shape: {
         type: 'circle',
@@ -30,10 +31,4 @@ export const createBoxCastGeometry = (centerX, centerY, sizeX, sizeY, directionX
     direction: new Vector2(directionX, directionY),
     maxDistance,
 });
-export const expectShapeCastHit = (hit) => {
-    expect(hit).not.toBe(false);
-    if (hit === false) {
-        throw new Error('Expected shape-cast hit, received false');
-    }
-    return hit;
-};
+export const expectShapeCastHit = (hit) => expectHit(hit, 'shape-cast hit');

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

@@ -0,0 +1 @@
+export declare const expectHit: <T>(hit: false | T, label: string) => T;

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

@@ -0,0 +1,7 @@
+export const expectHit = (hit, label) => {
+    expect(hit).not.toBe(false);
+    if (hit === false) {
+        throw new Error(`Expected ${label}, received false`);
+    }
+    return hit;
+};