dacha 0.18.0-alpha.3 → 0.18.0-alpha.4

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

@@ -7,6 +7,7 @@ export interface BaseColliderConfig {
     offsetY: number;
     layer: string;
     debugColor?: string;
+    disabled: boolean;
 }
 export interface BoxColliderConfig extends BaseColliderConfig {
     type: 'box';
@@ -26,10 +27,7 @@ export interface SegmentColliderConfig extends BaseColliderConfig {
 }
 export interface CapsuleColliderConfig extends BaseColliderConfig {
     type: 'capsule';
-    point1X: number;
-    point1Y: number;
-    point2X: number;
-    point2Y: number;
+    height: number;
     radius: number;
 }
 export type ColliderConfig = BoxColliderConfig | CircleColliderConfig | SegmentColliderConfig | CapsuleColliderConfig;
@@ -48,8 +46,7 @@ export interface SegmentColliderShape {
 }
 export interface CapsuleColliderShape {
     type: 'capsule';
-    point1: Point;
-    point2: Point;
+    height: number;
     radius: number;
 }
 export type ColliderShape = BoxColliderShape | CircleColliderShape | SegmentColliderShape | CapsuleColliderShape;
@@ -69,6 +66,7 @@ export type ColliderShape = BoxColliderShape | CircleColliderShape | SegmentColl
  *   sizeX: 64,
  *   sizeY: 64,
  *   layer: 'default',
+ *   disabled: false,
  * });
  *
  * // Create a circle collider
@@ -78,6 +76,7 @@ export type ColliderShape = BoxColliderShape | CircleColliderShape | SegmentColl
  *   offsetY: 0,
  *   radius: 32,
  *   layer: 'default',
+ *   disabled: false,
  * });
  *
  * // Add to actor
@@ -90,6 +89,7 @@ export declare class Collider extends Component {
     offset: Point;
     layer: string;
     debugColor?: string;
+    disabled: boolean;
     shape: ColliderShape;
     constructor(config: ColliderConfig);
 }

package/build/contrib/components/collider/index.js

@@ -15,6 +15,7 @@ import { Component } from '../../../engine/component';
  *   sizeX: 64,
  *   sizeY: 64,
  *   layer: 'default',
+ *   disabled: false,
  * });
  *
  * // Create a circle collider
@@ -24,6 +25,7 @@ import { Component } from '../../../engine/component';
  *   offsetY: 0,
  *   radius: 32,
  *   layer: 'default',
+ *   disabled: false,
  * });
  *
  * // Add to actor
@@ -36,12 +38,14 @@ export class Collider extends Component {
     offset;
     layer;
     debugColor;
+    disabled;
     shape;
     constructor(config) {
         super();
         this.offset = { x: config.offsetX, y: config.offsetY };
         this.layer = config.layer;
         this.debugColor = config.debugColor;
+        this.disabled = config.disabled;
         switch (config.type) {
             case 'box':
                 this.shape = {
@@ -65,8 +69,7 @@ export class Collider extends Component {
             case 'capsule':
                 this.shape = {
                     type: config.type,
-                    point1: { x: config.point1X, y: config.point1Y },
-                    point2: { x: config.point2X, y: config.point2Y },
+                    height: config.height,
                     radius: config.radius,
                 };
         }

package/build/contrib/components/rigid-body/index.d.ts

@@ -1,12 +1,15 @@
 import { Component } from '../../../engine/component';
 import { Vector2 } from '../../../engine/math-lib';
-export type RigidBodyType = 'dynamic' | 'static';
+export type RigidBodyType = 'dynamic' | 'static' | 'kinematic';
 export interface RigidBodyConfig {
     type: RigidBodyType;
-    mass: number;
-    gravityScale: number;
-    linearDamping: number;
+    mass?: number;
+    gravityScale?: number;
+    linearDamping?: number;
     disabled: boolean;
+    oneWay: boolean;
+    oneWayNormalX?: number;
+    oneWayNormalY?: number;
 }
 /**
  * RigidBody component for defining rigid body physics.
@@ -37,9 +40,10 @@ export interface RigidBodyConfig {
 export declare class RigidBody extends Component {
     private _mass;
     private _inverseMass;
-    /** Type of the rigid body */
-    type: RigidBodyType;
-    /** Mass of the rigid body */
+    /** @internal Pending one-step kinematic movement target */
+    _movementTarget: Vector2 | null;
+    /** Body type that defines how the rigid body participates in simulation */
+    readonly type: RigidBodyType;
     /** Gravity scale of the rigid body */
     gravityScale: number;
     /** Linear damping value used to slow down movement over time */
@@ -50,19 +54,61 @@ export declare class RigidBody extends Component {
     disabled: boolean;
     /** Whether rigid body is sleeping */
     sleeping: boolean;
+    /** Force applied to the rigid body */
     force: Vector2;
+    /** Impulse applied to the rigid body */
     impulse: Vector2;
+    /** Whether contacts should only be resolved from one side */
+    oneWay: boolean;
+    /** Local-space normal that points toward the blocking side */
+    oneWayNormal?: Vector2;
     /**
      * Creates a new RigidBody component.
      * @param config - Configuration for the rigid body
      */
     constructor(config: RigidBodyConfig);
     get mass(): number;
+    /**
+     * Sets the mass used by dynamic bodies.
+     *
+     * Non-positive values make the body immovable by forces and impulses.
+     */
     set mass(value: number);
+    /**
+     * Returns the inverse mass.
+     *
+     * Bodies with zero or negative mass return `0`.
+     */
     get inverseMass(): number;
+    /**
+     * Adds a continuous force to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyForce(force: Vector2): void;
+    /**
+     * Adds an instantaneous impulse to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyImpulse(impulse: Vector2): void;
+    /**
+     * Marks the rigid body as awake so it can be simulated.
+     */
     wakeUp(): void;
+    /**
+     * Marks the rigid body as sleeping so dynamic integration can skip it.
+     */
     sleep(): void;
+    /**
+     * Clears all accumulated force and impulse values.
+     */
     clearForces(): void;
+    /**
+     * Moves a kinematic body to a target position on the next physics step.
+     *
+     * The physics system computes a one-step velocity from the current position
+     * to this target so contacts can react to the kinematic movement.
+     */
+    movePosition(position: Vector2): void;
 }

package/build/contrib/components/rigid-body/index.js

@@ -29,9 +29,10 @@ import { Vector2 } from '../../../engine/math-lib';
 export class RigidBody extends Component {
     _mass;
     _inverseMass;
-    /** Type of the rigid body */
+    /** @internal Pending one-step kinematic movement target */
+    _movementTarget;
+    /** Body type that defines how the rigid body participates in simulation */
     type;
-    /** Mass of the rigid body */
     /** Gravity scale of the rigid body */
     gravityScale;
     /** Linear damping value used to slow down movement over time */
@@ -42,8 +43,14 @@ export class RigidBody extends Component {
     disabled;
     /** Whether rigid body is sleeping */
     sleeping;
+    /** Force applied to the rigid body */
     force;
+    /** Impulse applied to the rigid body */
     impulse;
+    /** Whether contacts should only be resolved from one side */
+    oneWay;
+    /** Local-space normal that points toward the blocking side */
+    oneWayNormal;
     /**
      * Creates a new RigidBody component.
      * @param config - Configuration for the rigid body
@@ -52,49 +59,98 @@ export class RigidBody extends Component {
         super();
         this._mass = 0;
         this._inverseMass = 0;
+        this._movementTarget = null;
         this.type = config.type;
-        this.mass = config.mass;
-        this.gravityScale = config.gravityScale;
-        this.linearDamping = config.linearDamping;
+        this.mass = config.mass ?? 0;
+        this.gravityScale = config.gravityScale ?? 0;
+        this.linearDamping = config.linearDamping ?? 0;
         this.linearVelocity = new Vector2(0, 0);
         this.disabled = config.disabled;
         this.sleeping = false;
         this.force = new Vector2(0, 0);
         this.impulse = new Vector2(0, 0);
+        this.oneWay = config.oneWay ?? false;
+        if (this.oneWay) {
+            this.oneWayNormal = new Vector2(config.oneWayNormalX ?? 0, config.oneWayNormalY ?? 0).normalize();
+            if (this.oneWayNormal.magnitude === 0) {
+                throw new Error('One-way rigid body normal must be non-zero');
+            }
+        }
     }
     get mass() {
         return this._mass;
     }
+    /**
+     * Sets the mass used by dynamic bodies.
+     *
+     * Non-positive values make the body immovable by forces and impulses.
+     */
     set mass(value) {
         this._mass = value;
         this._inverseMass = value > 0 ? 1 / value : 0;
     }
+    /**
+     * Returns the inverse mass.
+     *
+     * Bodies with zero or negative mass return `0`.
+     */
     get inverseMass() {
         return this._inverseMass;
     }
+    /**
+     * Adds a continuous force to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyForce(force) {
-        if (this.disabled || this.type === 'static') {
+        if (this.disabled || this.type !== 'dynamic') {
             return;
         }
         this.wakeUp();
         this.force.add(force);
     }
+    /**
+     * Adds an instantaneous impulse to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyImpulse(impulse) {
-        if (this.disabled || this.type === 'static') {
+        if (this.disabled || this.type !== 'dynamic') {
             return;
         }
         this.wakeUp();
         this.impulse.add(impulse);
     }
+    /**
+     * Marks the rigid body as awake so it can be simulated.
+     */
     wakeUp() {
         this.sleeping = false;
     }
+    /**
+     * Marks the rigid body as sleeping so dynamic integration can skip it.
+     */
     sleep() {
         this.sleeping = true;
     }
+    /**
+     * Clears all accumulated force and impulse values.
+     */
     clearForces() {
         this.force.multiplyNumber(0);
         this.impulse.multiplyNumber(0);
     }
+    /**
+     * Moves a kinematic body to a target position on the next physics step.
+     *
+     * The physics system computes a one-step velocity from the current position
+     * to this target so contacts can react to the kinematic movement.
+     */
+    movePosition(position) {
+        if (this.disabled || this.type !== 'kinematic') {
+            return;
+        }
+        this._movementTarget = position.clone();
+    }
 }
 RigidBody.componentName = 'RigidBody';

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

@@ -1,6 +1,6 @@
 import type { Actor } from '../../../engine/actor';
 import type { CollisionDetectionSubsystem } from './subsystems';
-import type { RaycastHit, RaycastParams, OverlapBoxParams, OverlapCircleParams, OverlapPointParams } from './types';
+import type { CastHit, RaycastParams, OverlapParams, ShapeCastParams } from './types';
 /**
  * API that provides methods for performing physics queries such as raycasting and overlap tests.
  *
@@ -23,7 +23,7 @@ export declare class PhysicsAPI {
      * @param params - Raycast parameters
      * @returns The nearest hit or `null` when nothing is hit
      */
-    raycast(params: RaycastParams): RaycastHit | null;
+    raycast(params: RaycastParams): CastHit | null;
     /**
      * Casts a ray and returns all hits sorted by distance.
      *
@@ -33,26 +33,26 @@ export declare class PhysicsAPI {
      * @param params - Raycast parameters
      * @returns All hits sorted from nearest to farthest
      */
-    raycastAll(params: RaycastParams): RaycastHit[];
+    raycastAll(params: RaycastParams): CastHit[];
     /**
-     * Returns all actors whose colliders contain the given point.
+     * Returns all actors whose colliders overlap the given query shape.
      *
-     * @param params - Point overlap parameters
-     * @returns Actors whose colliders overlap the point
+     * @param params - Overlap parameters
+     * @returns Actors whose colliders overlap the shape
      */
-    overlapPoint(params: OverlapPointParams): Actor[];
+    overlapShape(params: OverlapParams): Actor[];
     /**
-     * Returns all actors whose colliders overlap the given circle.
+     * Casts a shape and returns the nearest hit, if any.
      *
-     * @param params - Circle overlap parameters
-     * @returns Actors whose colliders overlap the circle
+     * @param params - Shape cast parameters
+     * @returns The nearest hit or `null` when nothing is hit
      */
-    overlapCircle(params: OverlapCircleParams): Actor[];
+    shapeCast(params: ShapeCastParams): CastHit | null;
     /**
-     * Returns all actors whose colliders overlap the given box.
+     * Casts a shape and returns all hits sorted by distance.
      *
-     * @param params - Box overlap parameters
-     * @returns Actors whose colliders overlap the box
+     * @param params - Shape cast parameters
+     * @returns All hits sorted from nearest to farthest
      */
-    overlapBox(params: OverlapBoxParams): Actor[];
+    shapeCastAll(params: ShapeCastParams): CastHit[];
 }

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

@@ -38,30 +38,30 @@ export class PhysicsAPI {
         return this.collisionDetectionSubsystem.raycastAll(params);
     }
     /**
-     * Returns all actors whose colliders contain the given point.
+     * Returns all actors whose colliders overlap the given query shape.
      *
-     * @param params - Point overlap parameters
-     * @returns Actors whose colliders overlap the point
+     * @param params - Overlap parameters
+     * @returns Actors whose colliders overlap the shape
      */
-    overlapPoint(params) {
-        return this.collisionDetectionSubsystem.overlapPoint(params);
+    overlapShape(params) {
+        return this.collisionDetectionSubsystem.overlapShape(params);
     }
     /**
-     * Returns all actors whose colliders overlap the given circle.
+     * Casts a shape and returns the nearest hit, if any.
      *
-     * @param params - Circle overlap parameters
-     * @returns Actors whose colliders overlap the circle
+     * @param params - Shape cast parameters
+     * @returns The nearest hit or `null` when nothing is hit
      */
-    overlapCircle(params) {
-        return this.collisionDetectionSubsystem.overlapCircle(params);
+    shapeCast(params) {
+        return this.collisionDetectionSubsystem.shapeCast(params);
     }
     /**
-     * Returns all actors whose colliders overlap the given box.
+     * Casts a shape and returns all hits sorted by distance.
      *
-     * @param params - Box overlap parameters
-     * @returns Actors whose colliders overlap the box
+     * @param params - Shape cast parameters
+     * @returns All hits sorted from nearest to farthest
      */
-    overlapBox(params) {
-        return this.collisionDetectionSubsystem.overlapBox(params);
+    shapeCastAll(params) {
+        return this.collisionDetectionSubsystem.shapeCastAll(params);
     }
 }

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

@@ -42,6 +42,7 @@ export class PhysicsSystem extends SceneSystem {
         const contacts = this.collisionDetectionSubsystem.update();
         this.constraintSolver.update(contacts);
         this.collisionBroadcastSubsystem.update(contacts);
+        this.physicsSubsystem.lateUpdate();
     }
 }
 PhysicsSystem.systemName = 'PhysicsSystem';

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

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

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

@@ -0,0 +1,18 @@
+export const buildBoxCastAABB = (params) => {
+    const { points, direction, maxDistance } = params;
+    const endPoints = points.map((point) => ({
+        x: point.x + direction.x * maxDistance,
+        y: point.y + direction.y * maxDistance,
+    }));
+    const castPoints = [...points, ...endPoints];
+    return {
+        min: {
+            x: Math.min(...castPoints.map((point) => point.x)),
+            y: Math.min(...castPoints.map((point) => point.y)),
+        },
+        max: {
+            x: Math.max(...castPoints.map((point) => point.x)),
+            y: Math.max(...castPoints.map((point) => point.y)),
+        },
+    };
+};

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

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

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

@@ -0,0 +1,21 @@
+export const buildCapsuleCastAABB = (params) => {
+    const { point1, point2, radius, direction, maxDistance } = params;
+    const endPoint1 = {
+        x: point1.x + direction.x * maxDistance,
+        y: point1.y + direction.y * maxDistance,
+    };
+    const endPoint2 = {
+        x: point2.x + direction.x * maxDistance,
+        y: point2.y + direction.y * maxDistance,
+    };
+    return {
+        min: {
+            x: Math.min(point1.x, point2.x, endPoint1.x, endPoint2.x) - radius,
+            y: Math.min(point1.y, point2.y, endPoint1.y, endPoint2.y) - radius,
+        },
+        max: {
+            x: Math.max(point1.x, point2.x, endPoint1.x, endPoint2.x) + radius,
+            y: Math.max(point1.y, point2.y, endPoint1.y, endPoint2.y) + radius,
+        },
+    };
+};

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

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

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

@@ -0,0 +1,15 @@
+export const buildCircleCastAABB = (params) => {
+    const { center, radius, direction, maxDistance } = params;
+    const endX = center.x + direction.x * maxDistance;
+    const endY = center.y + direction.y * maxDistance;
+    return {
+        min: {
+            x: Math.min(center.x, endX) - radius,
+            y: Math.min(center.y, endY) - radius,
+        },
+        max: {
+            x: Math.max(center.x, endX) + radius,
+            y: Math.max(center.y, endY) + radius,
+        },
+    };
+};

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

@@ -4,6 +4,9 @@ import { buildCircleAABB } from './build-circle-aabb';
 import { buildPointAABB } from './build-point-aabb';
 import { buildRayAABB } from './build-ray-aabb';
 import { buildSegmentAABB } from './build-segment-aabb';
+import { buildCircleCastAABB } from './build-circle-cast-aabb';
+import { buildCapsuleCastAABB } from './build-capsule-cast-aabb';
+import { buildBoxCastAABB } from './build-box-cast-aabb';
 export const aabbBuilders = {
     box: buildBoxAABB,
     capsule: buildCapsuleAABB,
@@ -11,4 +14,7 @@ export const aabbBuilders = {
     segment: buildSegmentAABB,
     point: buildPointAABB,
     ray: buildRayAABB,
+    circleCast: buildCircleCastAABB,
+    capsuleCast: buildCapsuleCastAABB,
+    boxCast: buildBoxCastAABB,
 };

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

@@ -0,0 +1,3 @@
+import type { BoxCastGeometry } from '../types';
+import type { BoxCastParams } from '../../../types';
+export declare function buildBoxCastGeometry(shapeCast: BoxCastParams): BoxCastGeometry;

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

@@ -0,0 +1,24 @@
+import { buildBoxGeometry } from './build-box-geometry';
+export function buildBoxCastGeometry(shapeCast) {
+    const box = buildBoxGeometry(shapeCast);
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (const point of box.points) {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    }
+    return {
+        ...box,
+        origin: box.center,
+        direction: shapeCast.direction.normalize(),
+        maxDistance: shapeCast.maxDistance,
+        halfExtents: {
+            x: (maxX - minX) / 2,
+            y: (maxY - minY) / 2,
+        },
+    };
+}

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

@@ -25,7 +25,7 @@ export function buildBoxGeometry(colliderOrOverlap, transform) {
         scaleY = transform.world.scale.y;
     }
     else {
-        const overlap = colliderOrOverlap;
+        const overlap = colliderOrOverlap.shape;
         centerX = 0;
         centerY = 0;
         sizeX = overlap.size.x;

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

@@ -0,0 +1,3 @@
+import type { CapsuleCastGeometry } from '../types';
+import type { CapsuleCastParams } from '../../../types';
+export declare function buildCapsuleCastGeometry(shapeCast: CapsuleCastParams): CapsuleCastGeometry;

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

@@ -0,0 +1,43 @@
+import { isZero, isDefinitelyPositive } from '../utils';
+import { buildCapsuleGeometry } from './build-capsule-geometry';
+import { buildBoxCastGeometry } from './build-box-cast-geometry';
+export function buildCapsuleCastGeometry(shapeCast) {
+    const capsule = buildCapsuleGeometry(shapeCast);
+    const boxSizeX = isZero(capsule.point2.x - capsule.point1.x)
+        ? capsule.radius * 2
+        : Math.abs(capsule.point2.x - capsule.point1.x);
+    const boxSizeY = isZero(capsule.point2.y - capsule.point1.y)
+        ? capsule.radius * 2
+        : Math.abs(capsule.point2.y - capsule.point1.y);
+    return {
+        ...capsule,
+        cap1: {
+            center: capsule.point1,
+            origin: capsule.point1,
+            radius: capsule.radius,
+            direction: shapeCast.direction,
+            maxDistance: shapeCast.maxDistance,
+        },
+        cap2: {
+            center: capsule.point2,
+            origin: capsule.point2,
+            radius: capsule.radius,
+            direction: shapeCast.direction,
+            maxDistance: shapeCast.maxDistance,
+        },
+        box: isDefinitelyPositive(boxSizeX) && isDefinitelyPositive(boxSizeY)
+            ? buildBoxCastGeometry({
+                shape: {
+                    type: 'box',
+                    center: capsule.center,
+                    size: { x: boxSizeX, y: boxSizeY },
+                },
+                direction: shapeCast.direction,
+                maxDistance: shapeCast.maxDistance,
+            })
+            : null,
+        origin: capsule.center,
+        direction: shapeCast.direction.normalize(),
+        maxDistance: shapeCast.maxDistance,
+    };
+}

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

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