dacha 0.17.1 → 0.18.0-alpha.0

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

@@ -6,6 +6,7 @@ export interface ColliderConfig {
     sizeX?: number;
     sizeY?: number;
     radius?: number;
+    layer: string;
 }
 /**
  * Collider component for defining collision boundaries.
@@ -21,7 +22,8 @@ export interface ColliderConfig {
  *   centerX: 0,
  *   centerY: 0,
  *   sizeX: 64,
- *   sizeY: 64
+ *   sizeY: 64,
+ *   layer: 'default',
  * });
  *
  * // Create a circle collider
@@ -29,7 +31,8 @@ export interface ColliderConfig {
  *   type: 'circle',
  *   centerX: 0,
  *   centerY: 0,
- *   radius: 32
+ *   radius: 32,
+ *   layer: 'default',
  * });
  *
  * // Add to actor
@@ -45,6 +48,7 @@ export declare class Collider extends Component {
     sizeX?: number;
     sizeY?: number;
     radius?: number;
+    layer: string;
     constructor(config: ColliderConfig);
     clone(): Collider;
 }

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

@@ -13,7 +13,8 @@ import { Component } from '../../../engine/component';
  *   centerX: 0,
  *   centerY: 0,
  *   sizeX: 64,
- *   sizeY: 64
+ *   sizeY: 64,
+ *   layer: 'default',
  * });
  *
  * // Create a circle collider
@@ -21,7 +22,8 @@ import { Component } from '../../../engine/component';
  *   type: 'circle',
  *   centerX: 0,
  *   centerY: 0,
- *   radius: 32
+ *   radius: 32,
+ *   layer: 'default',
  * });
  *
  * // Add to actor
@@ -37,6 +39,7 @@ export class Collider extends Component {
     sizeX;
     sizeY;
     radius;
+    layer;
     constructor(config) {
         super();
         this.type = config.type;
@@ -45,6 +48,7 @@ export class Collider extends Component {
         this.sizeX = config.sizeX;
         this.sizeY = config.sizeY;
         this.radius = config.radius;
+        this.layer = config.layer;
     }
     clone() {
         return new Collider({
@@ -54,6 +58,7 @@ export class Collider extends Component {
             sizeX: this.sizeX,
             sizeY: this.sizeY,
             radius: this.radius,
+            layer: this.layer,
         });
     }
 }

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

@@ -1,12 +1,12 @@
 import { Component } from '../../../engine/component';
+import { Vector2 } from '../../../engine/math-lib';
 export type RigidBodyType = 'dynamic' | 'static';
 export interface RigidBodyConfig {
     type: RigidBodyType;
     mass: number;
-    useGravity: boolean;
-    drag: number;
-    isPermeable: boolean;
-    ghost: boolean;
+    gravityScale: number;
+    linearDamping: number;
+    disabled: boolean;
 }
 /**
  * RigidBody component for defining rigid body physics.
@@ -20,10 +20,9 @@ export interface RigidBodyConfig {
  * const rigidBody = new RigidBody({
  *   type: 'dynamic',
  *   mass: 10,
- *   useGravity: true,
- *   isPermeable: false,
- *   ghost: false,
- *   drag: 1,
+ *   gravityScale: 1,
+ *   linearDamping: 1,
+ *   disabled: false,
  * });
  *
  * // Add to actor
@@ -36,22 +35,35 @@ export interface RigidBodyConfig {
  * @category Components
  */
 export declare class RigidBody extends Component {
+    private _mass;
+    private _inverseMass;
     /** Type of the rigid body */
     type: RigidBodyType;
     /** Mass of the rigid body */
-    mass: number;
-    /** Whether the rigid body is affected by gravity */
-    useGravity: boolean;
-    /** Whether the dynamic rigid body can pass through another dynamic body */
-    isPermeable: boolean;
-    /** Whether the rigid body can pass through any other rigid bodies */
-    ghost: boolean;
-    /** Drag of the rigid body, meaning it will slow down over time */
-    drag: number;
+    /** Gravity scale of the rigid body */
+    gravityScale: number;
+    /** Linear damping value used to slow down movement over time */
+    linearDamping: number;
+    /** Current linear velocity of the rigid body */
+    linearVelocity: Vector2;
+    /** Whether rigid body simulation is disabled */
+    disabled: boolean;
+    /** Whether rigid body is sleeping */
+    sleeping: boolean;
+    force: Vector2;
+    impulse: Vector2;
     /**
      * Creates a new RigidBody component.
      * @param config - Configuration for the rigid body
      */
     constructor(config: RigidBodyConfig);
+    get mass(): number;
+    set mass(value: number);
+    get inverseMass(): number;
+    applyForce(force: Vector2): void;
+    applyImpulse(impulse: Vector2): void;
+    wakeUp(): void;
+    sleep(): void;
+    clearForces(): void;
     clone(): RigidBody;
 }

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

@@ -1,4 +1,5 @@
 import { Component } from '../../../engine/component';
+import { Vector2 } from '../../../engine/math-lib';
 /**
  * RigidBody component for defining rigid body physics.
  *
@@ -11,10 +12,9 @@ import { Component } from '../../../engine/component';
  * const rigidBody = new RigidBody({
  *   type: 'dynamic',
  *   mass: 10,
- *   useGravity: true,
- *   isPermeable: false,
- *   ghost: false,
- *   drag: 1,
+ *   gravityScale: 1,
+ *   linearDamping: 1,
+ *   disabled: false,
  * });
  *
  * // Add to actor
@@ -27,39 +27,82 @@ import { Component } from '../../../engine/component';
  * @category Components
  */
 export class RigidBody extends Component {
+    _mass;
+    _inverseMass;
     /** Type of the rigid body */
     type;
     /** Mass of the rigid body */
-    mass;
-    /** Whether the rigid body is affected by gravity */
-    useGravity;
-    /** Whether the dynamic rigid body can pass through another dynamic body */
-    isPermeable;
-    /** Whether the rigid body can pass through any other rigid bodies */
-    ghost;
-    /** Drag of the rigid body, meaning it will slow down over time */
-    drag;
+    /** Gravity scale of the rigid body */
+    gravityScale;
+    /** Linear damping value used to slow down movement over time */
+    linearDamping;
+    /** Current linear velocity of the rigid body */
+    linearVelocity;
+    /** Whether rigid body simulation is disabled */
+    disabled;
+    /** Whether rigid body is sleeping */
+    sleeping;
+    force;
+    impulse;
     /**
      * Creates a new RigidBody component.
      * @param config - Configuration for the rigid body
      */
     constructor(config) {
         super();
+        this._mass = 0;
+        this._inverseMass = 0;
         this.type = config.type;
         this.mass = config.mass;
-        this.useGravity = config.useGravity;
-        this.isPermeable = config.isPermeable;
-        this.ghost = config.ghost;
-        this.drag = config.drag;
+        this.gravityScale = config.gravityScale;
+        this.linearDamping = config.linearDamping;
+        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);
+    }
+    get mass() {
+        return this._mass;
+    }
+    set mass(value) {
+        this._mass = value;
+        this._inverseMass = value > 0 ? 1 / value : 0;
+    }
+    get inverseMass() {
+        return this._inverseMass;
+    }
+    applyForce(force) {
+        if (this.disabled || this.type === 'static') {
+            return;
+        }
+        this.wakeUp();
+        this.force.add(force);
+    }
+    applyImpulse(impulse) {
+        if (this.disabled || this.type === 'static') {
+            return;
+        }
+        this.wakeUp();
+        this.impulse.add(impulse);
+    }
+    wakeUp() {
+        this.sleeping = false;
+    }
+    sleep() {
+        this.sleeping = true;
+    }
+    clearForces() {
+        this.force.multiplyNumber(0);
+        this.impulse.multiplyNumber(0);
     }
     clone() {
         return new RigidBody({
             mass: this.mass,
-            useGravity: this.useGravity,
-            isPermeable: this.isPermeable,
-            ghost: this.ghost,
+            gravityScale: this.gravityScale,
+            linearDamping: this.linearDamping,
+            disabled: this.disabled,
             type: this.type,
-            drag: this.drag,
         });
     }
 }

package/build/contrib/events/index.d.ts

@@ -1,7 +1,7 @@
 import type { Actor } from '../../engine/actor';
 import type { Vector2 } from '../../engine/math-lib';
 import type { CustomMouseEvent, CustomKeyboardEvent } from '../types/input-events';
-import type { ActorEvent, SceneEvent, WorldEvent } from '../../types/events';
+import type { ActorEvent, WorldEvent } from '../../types/events';
 /**
  * Dispatched when game statistics are updated
  *
@@ -11,15 +11,6 @@ import type { ActorEvent, SceneEvent, WorldEvent } from '../../types/events';
  * @category Events
  */
 export declare const GameStatsUpdate = "GameStatsUpdate";
-/**
- * Dispatched when two actors collide
- *
- * @event
- * @type {CollisionEvent}
- *
- * @category Events
- */
-export declare const Collision = "Collision";
 /**
  * Dispatched when keyboard input is received
  *
@@ -65,33 +56,6 @@ export declare const CollisionStay = "CollisionStay";
  * @category Events
  */
 export declare const CollisionLeave = "CollisionLeave";
-/**
- * Dispatched to add force to an actor
- *
- * @event
- * @type {AddForceEvent}
- *
- * @category Events
- */
-export declare const AddForce = "AddForce";
-/**
- * Dispatched to add impulse to an actor
- *
- * @event
- * @type {AddImpulseEvent}
- *
- * @category Events
- */
-export declare const AddImpulse = "AddImpulse";
-/**
- * Dispatched to stop physical movement of an actor
- *
- * @event
- * @type {ActorEvent}
- *
- * @category Events
- */
-export declare const StopMovement = "StopMovement";
 /**
  * Dispatched to play audio on an actor
  *
@@ -149,20 +113,6 @@ export type SetAudioGroupVolumeEvent = WorldEvent<{
     /** Volume value (0.0 to 1.0) */
     value: number;
 }>;
-/** Event signature for the {@link Collision} event
- *
- * @category Events
- */
-export type CollisionEvent = SceneEvent<{
-    /** First actor involved in the collision */
-    actor1: Actor;
-    /** Second actor involved in the collision */
-    actor2: Actor;
-    /** Minimum translation vector for the first actor */
-    mtv1: Vector2;
-    /** Minimum translation vector for the second actor */
-    mtv2: Vector2;
-}>;
 /** Event signature for mouse control events
  *
  * @category Events
@@ -180,8 +130,15 @@ export type KeyboardControlEvent<T = Record<string, never>> = ActorEvent<T>;
 type CollisionStateEvent = ActorEvent<{
     /** Actor that is colliding with the target */
     actor: Actor;
-    /** Minimum translation vector for the target to resolve the collision */
-    mtv: Vector2;
+    /** Collision normal pointing from the target actor to the colliding actor */
+    normal: Vector2;
+    /** Depth of penetration along the collision normal */
+    penetration: number;
+    /** Contact manifold points in world space */
+    contactPoints: {
+        x: number;
+        y: number;
+    }[];
 }>;
 /** Event signature for the {@link CollisionEnter} event
  *
@@ -198,22 +155,6 @@ export type CollisionStayEvent = CollisionStateEvent;
  * @category Events
  */
 export type CollisionLeaveEvent = CollisionStateEvent;
-/** Event signature for the {@link AddForce} event
- *
- * @category Events
- */
-export type AddForceEvent = ActorEvent<{
-    /** Force vector to apply to the actor */
-    value: Vector2;
-}>;
-/** Event signature for the {@link AddImpulse} event
- *
- * @category Events
- */
-export type AddImpulseEvent = ActorEvent<{
-    /** Impulse vector to apply to the actor */
-    value: Vector2;
-}>;
 /** Event signature for the {@link SetAudioVolume} event when used on actor level
  *
  * @category Events
@@ -229,16 +170,10 @@ declare module '../../types/events' {
         [GameStatsUpdate]: GameStatsUpdateEvent;
         [SetAudioVolume]: SetAudioGroupVolumeEvent;
     }
-    interface SceneEventMap {
-        [Collision]: CollisionEvent;
-    }
     interface ActorEventMap {
         [CollisionEnter]: CollisionEnterEvent;
         [CollisionStay]: CollisionStayEvent;
         [CollisionLeave]: CollisionLeaveEvent;
-        [AddForce]: AddForceEvent;
-        [AddImpulse]: AddImpulseEvent;
-        [StopMovement]: ActorEvent;
         [PlayAudio]: ActorEvent;
         [StopAudio]: ActorEvent;
         [SetAudioVolume]: SetAudioSourceVolumeEvent;

package/build/contrib/events/index.js

@@ -7,15 +7,6 @@
  * @category Events
  */
 export const GameStatsUpdate = 'GameStatsUpdate';
-/**
- * Dispatched when two actors collide
- *
- * @event
- * @type {CollisionEvent}
- *
- * @category Events
- */
-export const Collision = 'Collision';
 /**
  * Dispatched when keyboard input is received
  *
@@ -61,33 +52,6 @@ export const CollisionStay = 'CollisionStay';
  * @category Events
  */
 export const CollisionLeave = 'CollisionLeave';
-/**
- * Dispatched to add force to an actor
- *
- * @event
- * @type {AddForceEvent}
- *
- * @category Events
- */
-export const AddForce = 'AddForce';
-/**
- * Dispatched to add impulse to an actor
- *
- * @event
- * @type {AddImpulseEvent}
- *
- * @category Events
- */
-export const AddImpulse = 'AddImpulse';
-/**
- * Dispatched to stop physical movement of an actor
- *
- * @event
- * @type {ActorEvent}
- *
- * @category Events
- */
-export const StopMovement = 'StopMovement';
 /**
  * Dispatched to play audio on an actor
  *

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

@@ -13,7 +13,6 @@ export declare class PhysicsSystem extends SceneSystem {
     private physicsSubsystem;
     private collisionDetectionSubsystem;
     private collisionBroadcastSubsystem;
-    private collisionSolver;
     private constraintSolver;
     constructor(options: SceneSystemOptions);
     onSceneDestroy(): void;

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

@@ -1,5 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
-import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, CollisionSolver, ConstraintSolver, } from './subsystems';
+import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, ConstraintSolver, } from './subsystems';
 /**
  * Physics system that handles 2D physics simulation and collision detection
  *
@@ -13,28 +13,23 @@ export class PhysicsSystem extends SceneSystem {
     physicsSubsystem;
     collisionDetectionSubsystem;
     collisionBroadcastSubsystem;
-    collisionSolver;
     constraintSolver;
     constructor(options) {
         super();
         this.physicsSubsystem = new PhysicsSubsystem(options);
         this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
-        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem(options);
-        this.collisionSolver = new CollisionSolver(options);
-        this.constraintSolver = new ConstraintSolver(options);
+        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem();
+        this.constraintSolver = new ConstraintSolver();
     }
     onSceneDestroy() {
         this.physicsSubsystem.destroy();
         this.collisionDetectionSubsystem.destroy();
-        this.collisionSolver.destroy();
-        this.constraintSolver.destroy();
-        this.collisionBroadcastSubsystem.destroy();
     }
     fixedUpdate(options) {
         this.physicsSubsystem.update(options);
-        this.collisionDetectionSubsystem.update();
-        this.constraintSolver.update();
-        this.collisionBroadcastSubsystem.update();
+        const contacts = this.collisionDetectionSubsystem.update();
+        this.constraintSolver.update(contacts);
+        this.collisionBroadcastSubsystem.update(contacts);
     }
 }
 PhysicsSystem.systemName = 'PhysicsSystem';

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

@@ -1,13 +1,15 @@
 import type { Actor } from '../../../../../engine/actor';
 import type { Vector2 } from '../../../../../engine/math-lib';
+import type { Point } from '../collision-detection/types';
 export type CollisionState = 'enter' | 'stay' | 'leave';
 export declare class Collision {
     private lifetime;
     actor1: Actor;
     actor2: Actor;
-    mtv1: Vector2;
-    mtv2: Vector2;
-    constructor(actor1: Actor, actor2: Actor, mtv1: Vector2, mtv2: Vector2);
+    normal: Vector2;
+    penetration: number;
+    contactPoints: Point[];
+    constructor(actor1: Actor, actor2: Actor, normal: Vector2, penetration: number, contactPoints: Point[]);
     isFinished(): boolean;
     signal(): void;
     tick(): void;

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

@@ -7,14 +7,16 @@ export class Collision {
     lifetime;
     actor1;
     actor2;
-    mtv1;
-    mtv2;
-    constructor(actor1, actor2, mtv1, mtv2) {
+    normal;
+    penetration;
+    contactPoints;
+    constructor(actor1, actor2, normal, penetration, contactPoints) {
         this.actor1 = actor1;
         this.actor2 = actor2;
         this.lifetime = 2;
-        this.mtv1 = mtv1;
-        this.mtv2 = mtv2;
+        this.normal = normal;
+        this.penetration = penetration;
+        this.contactPoints = contactPoints;
     }
     isFinished() {
         return this.lifetime < 0;

package/build/contrib/systems/physics-system/subsystems/collision-broadcast/index.d.ts

@@ -1,11 +1,9 @@
-import type { SceneSystemOptions } from '../../../../../engine/system';
+import type { Contact } from '../collision-detection/types';
 export declare class CollisionBroadcastSubsystem {
-    private scene;
     private collisionMap;
     private activeCollisions;
-    constructor(options: SceneSystemOptions);
-    destroy(): void;
-    private handleCollision;
+    constructor();
+    private trackCollision;
     private publishEvent;
-    update(): void;
+    update(contacts: Contact[]): void;
 }

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

@@ -1,4 +1,4 @@
-import { Collision as RawCollision, CollisionEnter, CollisionStay, CollisionLeave, } from '../../../../events';
+import { CollisionEnter, CollisionStay, CollisionLeave, } from '../../../../events';
 import { Collision } from './collision';
 const STATE_TO_EVENT = {
     enter: CollisionEnter,
@@ -6,40 +6,43 @@ const STATE_TO_EVENT = {
     leave: CollisionLeave,
 };
 export class CollisionBroadcastSubsystem {
-    scene;
     collisionMap;
     activeCollisions;
-    constructor(options) {
-        this.scene = options.scene;
+    constructor() {
         this.collisionMap = {};
         this.activeCollisions = [];
-        this.scene.addEventListener(RawCollision, this.handleCollision);
     }
-    destroy() {
-        this.scene.removeEventListener(RawCollision, this.handleCollision);
-    }
-    handleCollision = (event) => {
-        const { actor1, actor2, mtv1, mtv2, } = event;
+    trackCollision(actor1, actor2, normal, penetration, contactPoints) {
         this.collisionMap[actor1.id] = this.collisionMap[actor1.id] || {};
         if (!this.collisionMap[actor1.id][actor2.id]) {
-            const collision = new Collision(actor1, actor2, mtv1, mtv2);
+            const collision = new Collision(actor1, actor2, normal, penetration, contactPoints);
             this.collisionMap[actor1.id][actor2.id] = collision;
             this.activeCollisions.push(collision);
         }
         else {
-            this.collisionMap[actor1.id][actor2.id].mtv1 = mtv1;
-            this.collisionMap[actor1.id][actor2.id].mtv2 = mtv2;
+            this.collisionMap[actor1.id][actor2.id].normal = normal;
+            this.collisionMap[actor1.id][actor2.id].penetration = penetration;
+            this.collisionMap[actor1.id][actor2.id].contactPoints = contactPoints;
             this.collisionMap[actor1.id][actor2.id].signal();
         }
-    };
+    }
     publishEvent(collision) {
-        const { actor1, actor2, mtv1, } = collision;
+        const { actor1, actor2, normal, penetration, contactPoints } = collision;
         actor1.dispatchEvent(STATE_TO_EVENT[collision.getState()], {
             actor: actor2,
-            mtv: mtv1,
+            normal,
+            penetration,
+            contactPoints,
         });
     }
-    update() {
+    update(contacts) {
+        contacts.forEach((contact) => {
+            const { actor1, actor2, normal, penetration, contactPoints } = contact;
+            const normal2 = contact.normal.clone();
+            normal2.multiplyNumber(-1);
+            this.trackCollision(actor1, actor2, normal, penetration, contactPoints);
+            this.trackCollision(actor2, actor1, normal2, penetration, contactPoints);
+        });
         this.activeCollisions = this.activeCollisions.filter((collision) => {
             const { actor1, actor2 } = collision;
             this.publishEvent(collision);

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

@@ -1,28 +1,31 @@
 import type { SceneSystemOptions } from '../../../../../engine/system';
+import type { Contact } from './types';
 export declare class CollisionDetectionSubsystem {
     private actorQuery;
-    private scene;
     private axis;
-    private entriesMap;
-    private collisionPairs;
-    private entriesToDelete;
+    private proxiesByActorId;
+    private proxyPairs;
+    private contacts;
+    private actorIdsToDelete;
+    private collisionMatrix;
     constructor(options: SceneSystemOptions);
     destroy(): void;
     private handleActorAdd;
     private handleActorRemove;
     private checkOnReorientation;
     private getOrientationData;
-    private addCollisionEntry;
-    private updateCollisionEntry;
+    private addProxy;
+    private updateProxy;
     private addToSortedList;
     private updateSortedList;
     private clearSortedList;
     private getAxes;
     private areStaticBodies;
     private testAABB;
+    private testCollisionLayers;
     private sweepAndPrune;
     private checkOnIntersection;
-    private sendCollisionEvent;
-    private clearDeletedEntries;
-    update(): void;
+    private storeContact;
+    private clearDeletedProxies;
+    update(): Contact[];
 }