dacha 0.17.2 → 0.18.0-alpha.0

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

@@ -1,6 +1,6 @@
-import { checkBoxAndCircleIntersection } from './check-box-and-circle-intersection';
-import { checkBoxesIntersection } from './check-boxes-intersection';
-import { checkCirclesIntersection } from './check-circles-intersection';
+import { checkBoxAndCircleIntersection } from './box-circle/check-box-and-circle-intersection';
+import { checkBoxesIntersection } from './box-box/check-boxes-intersection';
+import { checkCirclesIntersection } from './circle-circle/check-circles-intersection';
 export const intersectionCheckers = {
     box: {
         box: checkBoxesIntersection,

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

@@ -0,0 +1,17 @@
+import type { BoxGeometry, CircleGeometry, Intersection, Proxy } from '../../types';
+export declare const createBoxGeometry: (centerX: number, centerY: number, sizeX: number, sizeY: number) => BoxGeometry;
+export declare const createRotatedBoxGeometry: (centerX: number, centerY: number, sizeX: number, sizeY: number, rotation: number) => BoxGeometry;
+export declare const createCircleGeometry: (centerX: number, centerY: number, radius: number) => CircleGeometry;
+export declare const createProxy: (type: 'box' | 'circle', geometry: BoxGeometry | CircleGeometry) => Proxy;
+export declare const expectToBeClose: (point: {
+    x: number;
+    y: number;
+}, x: number, y: number, digits?: number) => void;
+export declare const expectIntersection: (intersection: Intersection | false) => Intersection;
+export declare const sortPoints: (points: {
+    x: number;
+    y: number;
+}[]) => {
+    x: number;
+    y: number;
+}[];

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

@@ -0,0 +1,66 @@
+import { VectorOps } from '../../../../../../../engine/math-lib';
+export const createBoxGeometry = (centerX, centerY, sizeX, sizeY) => {
+    return createRotatedBoxGeometry(centerX, centerY, sizeX, sizeY, 0);
+};
+export const createRotatedBoxGeometry = (centerX, centerY, sizeX, sizeY, rotation) => {
+    const halfX = sizeX / 2;
+    const halfY = sizeY / 2;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const points = [
+        { x: -halfX, y: -halfY },
+        { x: -halfX, y: halfY },
+        { x: halfX, y: halfY },
+        { x: halfX, y: -halfY },
+    ];
+    for (const point of points) {
+        const rotatedX = point.x * cos - point.y * sin;
+        const rotatedY = point.x * sin + point.y * cos;
+        point.x = rotatedX + centerX;
+        point.y = rotatedY + centerY;
+    }
+    const edges = points.map((point1, index, array) => {
+        const point2 = array[(index + 1) % array.length];
+        return {
+            point1,
+            point2,
+            normal: VectorOps.getNormal(point1.x, point2.x, point1.y, point2.y),
+        };
+    });
+    return {
+        center: {
+            x: centerX,
+            y: centerY,
+        },
+        points,
+        edges,
+    };
+};
+export const createCircleGeometry = (centerX, centerY, radius) => ({
+    center: { x: centerX, y: centerY },
+    radius,
+});
+export const createProxy = (type, geometry) => ({
+    actor: {
+        id: `${type}-${Math.random()}`,
+        getComponent: () => ({ type }),
+    },
+    geometry,
+});
+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 sortPoints = (points) => [...points].sort((point1, point2) => {
+    if (point1.x !== point2.x) {
+        return point1.x - point2.x;
+    }
+    return point1.y - point2.y;
+});

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

@@ -0,0 +1,4 @@
+import { Vector2 } from '../../../../../../engine/math-lib';
+import type { Point } from '../types';
+export declare const INTERSECTION_EPSILON = 0.000001;
+export declare const orientNormal: (normal: Vector2, from: Point, to: Point) => Vector2;

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

@@ -0,0 +1,9 @@
+import { Vector2, VectorOps } from '../../../../../../engine/math-lib';
+export const INTERSECTION_EPSILON = 1e-6;
+export const orientNormal = (normal, from, to) => {
+    const direction = new Vector2(to.x - from.x, to.y - from.y);
+    if (VectorOps.dotProduct(direction, normal) < 0) {
+        return normal.clone().multiplyNumber(-1);
+    }
+    return normal;
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/check-collider.js

@@ -2,6 +2,9 @@ export const checkCollider = (collider, colliderOld) => {
     if (collider.type !== colliderOld.type) {
         return true;
     }
+    if (collider.layer !== colliderOld.layer) {
+        return true;
+    }
     if (collider.type === 'box') {
         return collider.centerX !== colliderOld.centerX
             || collider.centerY !== colliderOld.centerY

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

@@ -41,9 +41,10 @@ export interface OrientationData {
         radius?: number;
         sizeX?: number;
         sizeY?: number;
+        layer: string;
     };
 }
-export interface CollisionEntry {
+export interface Proxy {
     actor: Actor;
     aabb: AABB;
     geometry: Geometry;
@@ -51,7 +52,7 @@ export interface CollisionEntry {
     edges: Record<Axis, [SortedItem, SortedItem]>;
 }
 export interface SortedItem {
-    entry: CollisionEntry;
+    proxy: Proxy;
     value: number;
 }
 export interface AxisEntry {
@@ -63,8 +64,16 @@ export interface Axes {
     x: AxisEntry;
     y: AxisEntry;
 }
-export type CollisionPair = [CollisionEntry, CollisionEntry];
+export type ProxyPair = [Proxy, Proxy];
+export interface Contact {
+    actor1: Actor;
+    actor2: Actor;
+    normal: Vector2;
+    penetration: number;
+    contactPoints: Point[];
+}
 export interface Intersection {
-    mtv1: Vector2;
-    mtv2: Vector2;
+    normal: Vector2;
+    penetration: number;
+    contactPoints: Point[];
 }

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

@@ -1,4 +1 @@
-;
-;
-;
 export {};

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

@@ -1,13 +1,10 @@
-import type { SceneSystemOptions } from '../../../../../engine/system';
+import type { Contact } from '../collision-detection/types';
 export declare class ConstraintSolver {
-    private scene;
-    private processedPairs;
-    private mtvMap;
-    constructor(options: SceneSystemOptions);
-    destroy(): void;
-    private handleCollision;
+    private validContacts;
     private validateCollision;
-    private setMtv;
-    private resolveCollision;
-    update(): void;
+    private getInverseMass;
+    private applyNormalImpulse;
+    private applyFrictionImpulse;
+    private applyPositionCorrection;
+    update(contacts: Contact[]): void;
 }

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.js

@@ -1,36 +1,12 @@
-import { Vector2 } from '../../../../../engine/math-lib';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { Collision } from '../../../../events';
 import { RIGID_BODY_TYPE } from '../../consts';
+const SOLVER_ITERATIONS = 8;
+const POSITION_CORRECTION_PERCENT = 0.8;
+const PENETRATION_SLOP = 0.01;
+const DEFAULT_CONTACT_FRICTION = 0.6;
 export class ConstraintSolver {
-    scene;
-    processedPairs;
-    mtvMap;
-    constructor(options) {
-        this.scene = options.scene;
-        this.processedPairs = new Map();
-        this.mtvMap = new Map();
-        this.scene.addEventListener(Collision, this.handleCollision);
-    }
-    destroy() {
-        this.scene.removeEventListener(Collision, this.handleCollision);
-    }
-    handleCollision = (event) => {
-        const { actor1, actor2, mtv1, mtv2 } = event;
-        if (this.processedPairs.has(actor2) &&
-            this.processedPairs.get(actor2).has(actor1)) {
-            return;
-        }
-        if (!this.processedPairs.has(actor1)) {
-            this.processedPairs.set(actor1, new Set());
-        }
-        this.processedPairs.get(actor1).add(actor2);
-        if (!this.validateCollision(actor1, actor2)) {
-            return;
-        }
-        this.resolveCollision(actor1, actor2, mtv1, mtv2);
-    };
+    validContacts = [];
     validateCollision(actor1, actor2) {
         const rigidBody1 = actor1.getComponent(RigidBody);
         const rigidBody2 = actor2.getComponent(RigidBody);
@@ -41,68 +17,130 @@ export class ConstraintSolver {
             rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
             return false;
         }
-        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC ||
-            rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
-            return !rigidBody1.ghost && !rigidBody2.ghost;
+        return true;
+    }
+    getInverseMass(rigidBody) {
+        if (rigidBody.disabled || rigidBody.type === RIGID_BODY_TYPE.STATIC) {
+            return 0;
+        }
+        return rigidBody.inverseMass;
+    }
+    applyNormalImpulse(contact) {
+        const { actor1, actor2, normal } = contact;
+        const rigidBody1 = actor1.getComponent(RigidBody);
+        const rigidBody2 = actor2.getComponent(RigidBody);
+        const inverseMass1 = this.getInverseMass(rigidBody1);
+        const inverseMass2 = this.getInverseMass(rigidBody2);
+        const inverseMassSum = inverseMass1 + inverseMass2;
+        if (inverseMassSum === 0) {
+            return 0;
+        }
+        const relativeVelocityX = rigidBody2.linearVelocity.x - rigidBody1.linearVelocity.x;
+        const relativeVelocityY = rigidBody2.linearVelocity.y - rigidBody1.linearVelocity.y;
+        const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
+        if (velocityAlongNormal >= 0) {
+            return 0;
+        }
+        const impulseMagnitude = -velocityAlongNormal / inverseMassSum;
+        const impulseX = normal.x * impulseMagnitude;
+        const impulseY = normal.y * impulseMagnitude;
+        if (inverseMass1 > 0) {
+            rigidBody1.linearVelocity.x -= impulseX * inverseMass1;
+            rigidBody1.linearVelocity.y -= impulseY * inverseMass1;
         }
-        return (!rigidBody1.ghost &&
-            !rigidBody1.isPermeable &&
-            !rigidBody2.ghost &&
-            !rigidBody2.isPermeable);
+        if (inverseMass2 > 0) {
+            rigidBody2.linearVelocity.x += impulseX * inverseMass2;
+            rigidBody2.linearVelocity.y += impulseY * inverseMass2;
+        }
+        return impulseMagnitude;
     }
-    setMtv(actor, mtvX, mtvY, type) {
-        if (!this.mtvMap.has(actor)) {
-            this.mtvMap.set(actor, {});
+    applyFrictionImpulse(contact, normalImpulseMagnitude) {
+        if (normalImpulseMagnitude <= 0) {
+            return;
+        }
+        const { normal } = contact;
+        const rigidBody1 = contact.actor1.getComponent(RigidBody);
+        const rigidBody2 = contact.actor2.getComponent(RigidBody);
+        const inverseMass1 = this.getInverseMass(rigidBody1);
+        const inverseMass2 = this.getInverseMass(rigidBody2);
+        const inverseMassSum = inverseMass1 + inverseMass2;
+        if (inverseMassSum === 0) {
+            return;
         }
-        const mtvs = this.mtvMap.get(actor);
-        if (!mtvs?.[type]) {
-            mtvs[type] = new Vector2(mtvX, mtvY);
+        const relativeVelocityX = rigidBody2.linearVelocity.x - rigidBody1.linearVelocity.x;
+        const relativeVelocityY = rigidBody2.linearVelocity.y - rigidBody1.linearVelocity.y;
+        const velocityAlongNormal = relativeVelocityX * normal.x + relativeVelocityY * normal.y;
+        const tangentX = relativeVelocityX - normal.x * velocityAlongNormal;
+        const tangentY = relativeVelocityY - normal.y * velocityAlongNormal;
+        const tangentMagnitude = Math.sqrt(tangentX ** 2 + tangentY ** 2);
+        if (tangentMagnitude === 0) {
             return;
         }
-        switch (type) {
-            case 'static':
-                mtvs[type].x =
-                    Math.abs(mtvX) > Math.abs(mtvs[type].x) ? mtvX : mtvs[type].x;
-                mtvs[type].y =
-                    Math.abs(mtvY) > Math.abs(mtvs[type].y) ? mtvY : mtvs[type].y;
-                break;
-            case 'dynamic':
-                mtvs[type].x += mtvX;
-                mtvs[type].y += mtvY;
+        const normalizedTangentX = tangentX / tangentMagnitude;
+        const normalizedTangentY = tangentY / tangentMagnitude;
+        const velocityAlongTangent = relativeVelocityX * normalizedTangentX +
+            relativeVelocityY * normalizedTangentY;
+        const unclampedImpulseMagnitude = -velocityAlongTangent / inverseMassSum;
+        const maxFrictionImpulseMagnitude = DEFAULT_CONTACT_FRICTION * normalImpulseMagnitude;
+        const impulseMagnitude = Math.max(-maxFrictionImpulseMagnitude, Math.min(unclampedImpulseMagnitude, maxFrictionImpulseMagnitude));
+        const impulseX = normalizedTangentX * impulseMagnitude;
+        const impulseY = normalizedTangentY * impulseMagnitude;
+        if (inverseMass1 > 0) {
+            rigidBody1.linearVelocity.x -= impulseX * inverseMass1;
+            rigidBody1.linearVelocity.y -= impulseY * inverseMass1;
+        }
+        if (inverseMass2 > 0) {
+            rigidBody2.linearVelocity.x += impulseX * inverseMass2;
+            rigidBody2.linearVelocity.y += impulseY * inverseMass2;
         }
     }
-    resolveCollision(actor1, actor2, mtv1, mtv2) {
+    applyPositionCorrection(contact) {
+        const { actor1, actor2, normal, penetration } = contact;
         const rigidBody1 = actor1.getComponent(RigidBody);
         const rigidBody2 = actor2.getComponent(RigidBody);
-        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC) {
-            this.setMtv(actor2, mtv2.x, mtv2.y, rigidBody1.type);
+        const inverseMass1 = this.getInverseMass(rigidBody1);
+        const inverseMass2 = this.getInverseMass(rigidBody2);
+        const inverseMassSum = inverseMass1 + inverseMass2;
+        if (inverseMassSum === 0) {
+            return;
         }
-        else if (rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
-            this.setMtv(actor1, mtv1.x, mtv1.y, rigidBody2.type);
+        const correctionMagnitude = (Math.max(penetration - PENETRATION_SLOP, 0) *
+            POSITION_CORRECTION_PERCENT) /
+            inverseMassSum;
+        if (correctionMagnitude === 0) {
+            return;
+        }
+        const correctionX = normal.x * correctionMagnitude;
+        const correctionY = normal.y * correctionMagnitude;
+        const transform1 = actor1.getComponent(Transform);
+        const transform2 = actor2.getComponent(Transform);
+        if (inverseMass1 > 0) {
+            transform1.world.position.x -= correctionX * inverseMass1;
+            transform1.world.position.y -= correctionY * inverseMass1;
         }
-        else {
-            this.setMtv(actor1, mtv1.x / 2, mtv1.y / 2, rigidBody2.type);
-            this.setMtv(actor2, mtv2.x / 2, mtv2.y / 2, rigidBody1.type);
+        if (inverseMass2 > 0) {
+            transform2.world.position.x += correctionX * inverseMass2;
+            transform2.world.position.y += correctionY * inverseMass2;
         }
     }
-    update() {
-        for (const [actor, entry] of this.mtvMap) {
-            const transform = actor.getComponent(Transform);
-            const { static: staticMtv, dynamic: dynamicMtv } = entry;
-            /*
-             * TODO:: Enable this part when it will be possible to run
-             * phycics pipeline several times per single game loop iteration
-             */
-            // transform.world.position.x += Math.sign(staticMtv.x) === Math.sign(dynamicMtv.x)
-            //   ? staticMtv.x + dynamicMtv.x
-            //   : staticMtv.x || dynamicMtv.x;
-            // transform.world.position.y += Math.sign(staticMtv.y) === Math.sign(dynamicMtv.y)
-            //   ? staticMtv.y + dynamicMtv.y
-            //   : staticMtv.y || dynamicMtv.y;
-            transform.world.position.x += (staticMtv?.x ?? 0) + (dynamicMtv?.x ?? 0);
-            transform.world.position.y += (staticMtv?.y ?? 0) + (dynamicMtv?.y ?? 0);
-        }
-        this.processedPairs.clear();
-        this.mtvMap.clear();
+    update(contacts) {
+        let validContactsCount = 0;
+        contacts.forEach((contact) => {
+            if (!this.validateCollision(contact.actor1, contact.actor2)) {
+                return;
+            }
+            this.validContacts[validContactsCount] = contact;
+            validContactsCount += 1;
+        });
+        this.validContacts.length = validContactsCount;
+        for (let iteration = 0; iteration < SOLVER_ITERATIONS; iteration += 1) {
+            this.validContacts.forEach((contact) => {
+                const normalImpulseMagnitude = this.applyNormalImpulse(contact);
+                this.applyFrictionImpulse(contact, normalImpulseMagnitude);
+            });
+        }
+        this.validContacts.forEach((contact) => {
+            this.applyPositionCorrection(contact);
+        });
     }
 }

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

@@ -1,5 +1,4 @@
 export { PhysicsSubsystem } from './physics';
 export { CollisionDetectionSubsystem } from './collision-detection';
 export { CollisionBroadcastSubsystem } from './collision-broadcast';
-export { CollisionSolver } from './collision-solver';
 export { ConstraintSolver } from './constraint-solver';

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

@@ -1,5 +1,4 @@
 export { PhysicsSubsystem } from './physics';
 export { CollisionDetectionSubsystem } from './collision-detection';
 export { CollisionBroadcastSubsystem } from './collision-broadcast';
-export { CollisionSolver } from './collision-solver';
 export { ConstraintSolver } from './constraint-solver';

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

@@ -1,17 +1,11 @@
 import type { SceneSystemOptions, UpdateOptions } from '../../../../../engine/system';
 export declare class PhysicsSubsystem {
-    private scene;
     private actorQuery;
     private gravity;
-    private actorVectors;
     constructor(options: SceneSystemOptions);
     destroy(): void;
-    private handleActorRemove;
-    private handleStopMovement;
-    private handleAddForce;
-    private handleAddImpulse;
-    private setUpVectors;
-    private applyDragForce;
-    private getGravityForce;
+    private applyLinearDamping;
+    private integrateVelocities;
+    private integratePositions;
     update(options: UpdateOptions): void;
 }

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

@@ -1,125 +1,89 @@
-import { Vector2 } from '../../../../../engine/math-lib';
 import { ActorQuery } from '../../../../../engine/actor';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { AddForce, AddImpulse, StopMovement } from '../../../../events';
-import { RemoveActor } from '../../../../../engine/events';
-const DIRECTION_VECTOR = {
-    UP: new Vector2(0, -1),
-    LEFT: new Vector2(-1, 0),
-    RIGHT: new Vector2(1, 0),
-    DOWN: new Vector2(0, 1),
-};
 export class PhysicsSubsystem {
-    scene;
     actorQuery;
     gravity;
-    actorVectors;
     constructor(options) {
         const { gravity, scene } = options;
-        this.scene = scene;
         this.actorQuery = new ActorQuery({ scene, filter: [RigidBody, Transform] });
         this.gravity = gravity;
-        this.actorVectors = {};
-        this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
-        this.scene.addEventListener(StopMovement, this.handleStopMovement);
-        this.scene.addEventListener(AddForce, this.handleAddForce);
-        this.scene.addEventListener(AddImpulse, this.handleAddImpulse);
     }
     destroy() {
-        this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
-        this.scene.removeEventListener(StopMovement, this.handleStopMovement);
-        this.scene.removeEventListener(AddForce, this.handleAddForce);
-        this.scene.removeEventListener(AddImpulse, this.handleAddImpulse);
+        this.actorQuery.destroy();
     }
-    handleActorRemove = (event) => {
-        const { actor } = event;
-        delete this.actorVectors[actor.id];
-    };
-    handleStopMovement = (event) => {
-        const { target } = event;
-        if (!this.actorVectors[target.id]) {
-            this.setUpVectors(target);
-        }
-        this.actorVectors[target.id].velocity.multiplyNumber(0);
-    };
-    handleAddForce = (event) => {
-        const { target, value } = event;
-        if (!this.actorVectors[target.id]) {
-            this.setUpVectors(target);
-        }
-        this.actorVectors[target.id].force.add(value);
-    };
-    handleAddImpulse = (event) => {
-        const { target, value } = event;
-        if (!this.actorVectors[target.id]) {
-            this.setUpVectors(target);
-        }
-        this.actorVectors[target.id].impulse.add(value);
-    };
-    setUpVectors(actor) {
-        this.actorVectors[actor.id] = {
-            velocity: new Vector2(0, 0),
-            force: new Vector2(0, 0),
-            impulse: new Vector2(0, 0),
-        };
-    }
-    applyDragForce(actor, deltaTime) {
-        const { mass, drag } = actor.getComponent(RigidBody);
-        const velocity = this.actorVectors[actor.id]?.velocity;
-        if (!drag || !velocity || (!velocity.x && !velocity.y)) {
+    applyLinearDamping(rigidBody, deltaTime) {
+        const { mass, linearDamping, linearVelocity } = rigidBody;
+        if (!linearDamping || (!linearVelocity.x && !linearVelocity.y)) {
             return;
         }
-        const velocitySignX = Math.sign(velocity.x);
-        const velocitySignY = Math.sign(velocity.y);
+        const velocitySignX = Math.sign(linearVelocity.x);
+        const velocitySignY = Math.sign(linearVelocity.y);
         const reactionForceValue = mass * this.gravity;
-        const dragForceValue = -1 * drag * reactionForceValue;
+        const dragForceValue = -1 * linearDamping * reactionForceValue;
         const forceToVelocityMultiplier = deltaTime / mass;
         const slowdownValue = dragForceValue * forceToVelocityMultiplier;
-        const normalizationMultiplier = 1 / velocity.magnitude;
-        const slowdown = velocity.clone();
-        slowdown.multiplyNumber(slowdownValue * normalizationMultiplier);
-        velocity.add(slowdown);
-        if (Math.sign(velocity.x) !== velocitySignX &&
-            Math.sign(velocity.y) !== velocitySignY) {
-            velocity.multiplyNumber(0);
+        const normalizationMultiplier = 1 / linearVelocity.magnitude;
+        const slowdownMultiplier = slowdownValue * normalizationMultiplier;
+        linearVelocity.x += linearVelocity.x * slowdownMultiplier;
+        linearVelocity.y += linearVelocity.y * slowdownMultiplier;
+        if (Math.sign(linearVelocity.x) !== velocitySignX &&
+            Math.sign(linearVelocity.y) !== velocitySignY) {
+            linearVelocity.multiplyNumber(0);
         }
     }
-    getGravityForce(rigidBody) {
-        const { mass, useGravity } = rigidBody;
-        const gravityVector = new Vector2(0, 0);
-        if (useGravity) {
-            gravityVector.add(DIRECTION_VECTOR.DOWN);
-            gravityVector.multiplyNumber(mass * this.gravity);
-        }
-        return gravityVector;
-    }
-    update(options) {
-        const { deltaTime } = options;
-        const deltaTimeInMsec = deltaTime;
-        const deltaTimeInSeconds = deltaTimeInMsec / 1000;
+    integrateVelocities(deltaTimeInSeconds) {
         this.actorQuery.getActors().forEach((actor) => {
             const rigidBody = actor.getComponent(RigidBody);
-            const transform = actor.getComponent(Transform);
-            const { mass } = rigidBody;
-            if (!this.actorVectors[actor.id]) {
-                this.setUpVectors(actor);
+            const { mass, inverseMass } = rigidBody;
+            if (rigidBody.disabled || rigidBody.type === 'static' || mass <= 0) {
+                rigidBody.clearForces();
+                return;
+            }
+            const { force, impulse } = rigidBody;
+            const velocity = rigidBody.linearVelocity;
+            if (rigidBody.sleeping) {
+                if (force.x || force.y || impulse.x || impulse.y) {
+                    rigidBody.wakeUp();
+                }
+                else {
+                    return;
+                }
+            }
+            if (rigidBody.gravityScale) {
+                force.y += mass * this.gravity * rigidBody.gravityScale;
             }
-            const { velocity, force, impulse } = this.actorVectors[actor.id];
-            force.add(this.getGravityForce(rigidBody));
             if (force.x || force.y) {
-                force.multiplyNumber(deltaTimeInSeconds / mass);
+                force.multiplyNumber(deltaTimeInSeconds * inverseMass);
                 velocity.add(force);
             }
             if (impulse.x || impulse.y) {
-                impulse.multiplyNumber(1 / mass);
+                impulse.multiplyNumber(inverseMass);
                 velocity.add(impulse);
             }
-            this.applyDragForce(actor, deltaTimeInSeconds);
-            transform.world.position.x += velocity.x * deltaTimeInSeconds;
-            transform.world.position.y += velocity.y * deltaTimeInSeconds;
-            force.multiplyNumber(0);
-            impulse.multiplyNumber(0);
+            this.applyLinearDamping(rigidBody, deltaTimeInSeconds);
+            rigidBody.clearForces();
         });
     }
+    integratePositions(deltaTimeInSeconds) {
+        this.actorQuery.getActors().forEach((actor) => {
+            const rigidBody = actor.getComponent(RigidBody);
+            const transform = actor.getComponent(Transform);
+            if (rigidBody.disabled ||
+                rigidBody.type === 'static' ||
+                rigidBody.mass <= 0 ||
+                rigidBody.sleeping) {
+                return;
+            }
+            transform.world.position.x +=
+                rigidBody.linearVelocity.x * deltaTimeInSeconds;
+            transform.world.position.y +=
+                rigidBody.linearVelocity.y * deltaTimeInSeconds;
+        });
+    }
+    update(options) {
+        const deltaTimeInSeconds = options.deltaTime / 1000;
+        this.integrateVelocities(deltaTimeInSeconds);
+        this.integratePositions(deltaTimeInSeconds);
+    }
 }

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

@@ -2,3 +2,12 @@ import type { SceneSystemOptions } from '../../../engine/system';
 export interface PhysicsSystemOptions extends SceneSystemOptions {
     gravity: number;
 }
+export interface CollisionLayer {
+    id: string;
+    name: string;
+}
+export type CollisionMatrix = Record<string, Record<string, boolean>>;
+export interface PhysicsSettings {
+    collisionLayers: CollisionLayer[];
+    collisionMatrix: CollisionMatrix;
+}