@gg-web-engine/rapier2d 0.0.57 → 0.0.58

package/dist/components/rapier-2d-rigid-body.component.d.ts

@@ -1,7 +1,7 @@
-import { Body2DOptions, CollisionGroup, DebugBody2DSettings, Entity2d, Gg2dWorld, IRigidBody2dComponent, Point2, Shape2DDescriptor, VisualTypeDocRepo2D } from '@gg-web-engine/core';
+import { Body2DOptions, CollisionGroup, DebugBody2DSettings, Entity2d, IRigidBody2dComponent, Point2, Shape2DDescriptor } from '@gg-web-engine/core';
 import { Collider, ColliderDesc, InteractionGroups, RigidBody, RigidBodyDesc } from '@dimforge/rapier2d-compat';
 import { Rapier2dWorldComponent } from './rapier-2d-world.component';
-import { Rapier2dPhysicsTypeDocRepo } from '../types';
+import { Rapier2dGgWorld, Rapier2dPhysicsTypeDocRepo } from '../types';
 export declare class Rapier2dRigidBodyComponent implements IRigidBody2dComponent<Rapier2dPhysicsTypeDocRepo> {
     protected readonly world: Rapier2dWorldComponent;
     protected _colliderDescr: ColliderDesc[];
@@ -36,8 +36,8 @@ export declare class Rapier2dRigidBodyComponent implements IRigidBody2dComponent
     get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
     set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     clone(): Rapier2dRigidBodyComponent;
-    addToWorld(world: Gg2dWorld<VisualTypeDocRepo2D, Rapier2dPhysicsTypeDocRepo>): void;
-    removeFromWorld(world: Gg2dWorld<VisualTypeDocRepo2D, Rapier2dPhysicsTypeDocRepo>): void;
+    addToWorld(world: Rapier2dGgWorld): void;
+    removeFromWorld(world: Rapier2dGgWorld): void;
     resetMotion(): void;
     dispose(): void;
 }

package/dist/components/rapier-2d-rigid-body.component.js

@@ -127,6 +127,7 @@ export class Rapier2dRigidBodyComponent {
             const col = this.world.nativeWorld.createCollider(c, this._nativeBody);
             col.setFriction(this._colliderOptions.friction);
             col.setRestitution(this._colliderOptions.restitution);
+            col.setCollisionGroups(this.collisionGroups);
             return col;
         });
         this.world.handleIdEntityMap.set(this._nativeBody.handle, this);

package/dist/components/rapier-2d-trigger.component.d.ts

@@ -1,22 +1,24 @@
 import { Observable, Subject } from 'rxjs';
 import { ColliderDesc, RigidBodyDesc } from '@dimforge/rapier2d-compat';
 import { Rapier2dRigidBodyComponent } from './rapier-2d-rigid-body.component';
-import { DebugBody2DSettings, Gg2dWorld, ITrigger2dComponent, Shape2DDescriptor, VisualTypeDocRepo2D } from '@gg-web-engine/core';
+import { DebugBody2DSettings, ITrigger2dComponent, Shape2DDescriptor } from '@gg-web-engine/core';
 import { Rapier2dWorldComponent } from './rapier-2d-world.component';
-import { Rapier2dPhysicsTypeDocRepo } from '../types';
+import { Rapier2dGgWorld, Rapier2dPhysicsTypeDocRepo } from '../types';
 export declare class Rapier2dTriggerComponent extends Rapier2dRigidBodyComponent implements ITrigger2dComponent<Rapier2dPhysicsTypeDocRepo> {
     protected readonly world: Rapier2dWorldComponent;
     protected _colliderDescr: ColliderDesc[];
     readonly shape: Shape2DDescriptor;
     protected _bodyDescr: RigidBodyDesc;
+    readonly debugBodySettings: DebugBody2DSettings;
     get onEntityEntered(): Observable<Rapier2dRigidBodyComponent>;
     get onEntityLeft(): Observable<Rapier2dRigidBodyComponent>;
+    protected readonly overlaps: Set<Rapier2dRigidBodyComponent>;
     protected readonly onEnter$: Subject<Rapier2dRigidBodyComponent>;
     protected readonly onLeft$: Subject<Rapier2dRigidBodyComponent>;
-    readonly debugBodySettings: DebugBody2DSettings;
-    protected intersectionsAmount: number;
     constructor(world: Rapier2dWorldComponent, _colliderDescr: ColliderDesc[], shape: Shape2DDescriptor, _bodyDescr: RigidBodyDesc);
-    addToWorld(world: Gg2dWorld<VisualTypeDocRepo2D, Rapier2dPhysicsTypeDocRepo>): void;
+    addToWorld(world: Rapier2dGgWorld): void;
+    removeFromWorld(world: Rapier2dGgWorld): void;
     checkOverlaps(): void;
     clone(): Rapier2dTriggerComponent;
+    dispose(): void;
 }

package/dist/components/rapier-2d-trigger.component.js

@@ -1,6 +1,6 @@
-import { map, merge, Subject } from 'rxjs';
+import { Subject } from 'rxjs';
 import { Rapier2dRigidBodyComponent } from './rapier-2d-rigid-body.component';
-import { DebugBody2DSettings, } from '@gg-web-engine/core';
+import { DebugBody2DSettings } from '@gg-web-engine/core';
 export class Rapier2dTriggerComponent extends Rapier2dRigidBodyComponent {
     get onEntityEntered() {
         return this.onEnter$.asObservable();
@@ -14,29 +14,28 @@ export class Rapier2dTriggerComponent extends Rapier2dRigidBodyComponent {
         this._colliderDescr = _colliderDescr;
         this.shape = shape;
         this._bodyDescr = _bodyDescr;
+        this.debugBodySettings = new DebugBody2DSettings({ type: 'TRIGGER', activated: () => this.overlaps.size > 0 }, this.shape);
+        this.overlaps = new Set();
         this.onEnter$ = new Subject();
         this.onLeft$ = new Subject();
-        this.debugBodySettings = new DebugBody2DSettings({ type: 'TRIGGER', activated: () => this.intersectionsAmount > 0 }, this.shape);
-        this.intersectionsAmount = 0;
-        merge(this.onEnter$.pipe(map(() => true)), this.onLeft$.pipe(map(() => false))).subscribe(enter => {
-            if (enter) {
-                this.intersectionsAmount++;
-            }
-            else {
-                this.intersectionsAmount--;
-            }
-        });
     }
     addToWorld(world) {
         if (world.physicsWorld != this.world) {
             throw new Error('Rapier2D bodies cannot be shared between different worlds');
         }
-        this.intersectionsAmount = 0;
+        this.overlaps.clear();
         this._nativeBody = this.world.nativeWorld.createRigidBody(this._bodyDescr);
         this._nativeBodyColliders = this._colliderDescr.map(c => this.world.nativeWorld.createCollider(c, this._nativeBody));
         this.world.handleIdEntityMap.set(this._nativeBody.handle, this);
         this.world.added$.next(this);
     }
+    removeFromWorld(world) {
+        for (const body of this.overlaps) {
+            this.onLeft$.next(body);
+        }
+        this.overlaps.clear();
+        super.removeFromWorld(world);
+    }
     checkOverlaps() {
         this.world.eventQueue.drainCollisionEvents((h1, h2, started) => {
             var _a, _b;
@@ -49,8 +48,21 @@ export class Rapier2dTriggerComponent extends Rapier2dRigidBodyComponent {
             }
             if (!otherBody)
                 return;
-            (started ? this.onEnter$ : this.onLeft$).next(otherBody);
+            if (started) {
+                this.overlaps.add(otherBody);
+                this.onEnter$.next(otherBody);
+            }
+            else {
+                this.overlaps.delete(otherBody);
+                this.onLeft$.next(otherBody);
+            }
         });
+        for (const body of this.overlaps.keys()) {
+            if (!body.nativeBody) {
+                this.overlaps.delete(body);
+                this.onLeft$.next(body);
+            }
+        }
     }
     clone() {
         const [colliderDescr, sd, bd] = super.factoryProps;
@@ -59,4 +71,8 @@ export class Rapier2dTriggerComponent extends Rapier2dRigidBodyComponent {
         component.interactWithCollisionGroups = this.interactWithCollisionGroups;
         return component;
     }
+    dispose() {
+        this.overlaps.clear();
+        super.dispose();
+    }
 }

package/dist/components/rapier-2d-world.component.d.ts

@@ -1,4 +1,4 @@
-import { CollisionGroup, IPhysicsWorld2dComponent, Point2 } from '@gg-web-engine/core';
+import { CollisionGroup, IPhysicsWorld2dComponent, Point2, RaycastOptions, RaycastResult } from '@gg-web-engine/core';
 import { EventQueue, World } from '@dimforge/rapier2d-compat';
 import { Rapier2dRigidBodyComponent } from './rapier-2d-rigid-body.component';
 import { Rapier2dFactory } from '../rapier-2d-factory';
@@ -26,5 +26,6 @@ export declare class Rapier2dWorldComponent implements IPhysicsWorld2dComponent<
     protected lockedCollisionGroups: number[];
     registerCollisionGroup(): CollisionGroup;
     deregisterCollisionGroup(group: CollisionGroup): void;
+    raycast(options: RaycastOptions<Point2>): RaycastResult<Point2, Rapier2dRigidBodyComponent>;
     dispose(): void;
 }

package/dist/components/rapier-2d-world.component.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Pnt2 } from '@gg-web-engine/core';
+import { BitMask, Pnt2, Pnt3, } from '@gg-web-engine/core';
 import { EventQueue, init, Vector2, World } from '@dimforge/rapier2d-compat';
 import { Rapier2dFactory } from '../rapier-2d-factory';
 import { Subject } from 'rxjs';
@@ -80,6 +80,48 @@ export class Rapier2dWorldComponent {
     deregisterCollisionGroup(group) {
         this.lockedCollisionGroups = this.lockedCollisionGroups.filter(x => x !== group);
     }
+    raycast(options) {
+        if (!this._nativeWorld) {
+            return { hasHit: false };
+        }
+        const origin = options.from;
+        let direction = Pnt2.sub(options.to, options.from);
+        const rayLength = Pnt2.len(direction);
+        direction = Pnt2.norm(direction);
+        const ray = {
+            origin: new Vector2(...Pnt2.spr(origin)),
+            dir: new Vector2(...Pnt2.spr(direction)),
+            pointAt: (t) => {
+                return new Vector2(origin.x + direction.x * t, origin.y + direction.y * t);
+            },
+        };
+        const mask = (groups) => {
+            return groups ? BitMask.pack(groups, 16) : BitMask.full(16);
+        };
+        const hit = this._nativeWorld.castRay(ray, rayLength, true, undefined, (mask(options.collisionFilterGroups) << 16) | mask(options.collisionFilterMask));
+        if (!hit) {
+            return { hasHit: false };
+        }
+        const result = {
+            hasHit: true,
+        };
+        const collider = hit.collider;
+        if (collider) {
+            const rigidBody = collider.parent();
+            if (!rigidBody) {
+                return { hasHit: false };
+            }
+            result.hitBody = this.handleIdEntityMap.get(rigidBody.handle);
+            result.hitDistance = hit.timeOfImpact;
+            result.hitPoint = Pnt2.add(origin, Pnt2.scalarMult(direction, hit.timeOfImpact));
+            const rayIntersection = hit.collider.castRayAndGetNormal(ray, hit.timeOfImpact, true);
+            result.hitNormal = Pnt2.clone((rayIntersection === null || rayIntersection === void 0 ? void 0 : rayIntersection.normal) || Pnt3.O);
+        }
+        else {
+            result.hasHit = false;
+        }
+        return result;
+    }
     dispose() {
         var _a;
         (_a = this._nativeWorld) === null || _a === void 0 ? void 0 : _a.free();

package/dist/types.d.ts

@@ -1,8 +1,11 @@
 import { Rapier2dFactory } from './rapier-2d-factory';
 import { Rapier2dRigidBodyComponent } from './components/rapier-2d-rigid-body.component';
 import { Rapier2dTriggerComponent } from './components/rapier-2d-trigger.component';
+import { Gg2dWorld, Gg2dWorldSceneTypeDocPPatch, Gg2dWorldTypeDocPPatch } from '@gg-web-engine/core';
+import { Rapier2dWorldComponent } from './components/rapier-2d-world.component';
 export type Rapier2dPhysicsTypeDocRepo = {
     factory: Rapier2dFactory;
     rigidBody: Rapier2dRigidBodyComponent;
     trigger: Rapier2dTriggerComponent;
 };
+export type Rapier2dGgWorld = Gg2dWorld<Gg2dWorldTypeDocPPatch<Rapier2dPhysicsTypeDocRepo>, Gg2dWorldSceneTypeDocPPatch<Rapier2dPhysicsTypeDocRepo, Rapier2dWorldComponent>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/rapier2d",
-  "version": "0.0.57",
+  "version": "0.0.58",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
   "homepage": "https://github.com/AndyGura/gg-web-engine#readme",
   "devDependencies": {
     "@dimforge/rapier2d-compat": "0.0.0-50223ff-20240729",
-    "@gg-web-engine/core": "0.0.57",
+    "@gg-web-engine/core": "0.0.58",
     "@types/jest": "^29.5.12",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
@@ -39,7 +39,7 @@
   },
   "peerDependencies": {
     "@dimforge/rapier2d-compat": "0.0.0-50223ff-20240729",
-    "@gg-web-engine/core": "0.0.57",
+    "@gg-web-engine/core": "0.0.58",
     "rxjs": "7.8.1"
   },
   "jest": {

package/test/components/rapier-2d-trigger.component.spec.ts

@@ -1,5 +1,5 @@
-import { Rapier2dFactory, Rapier2dWorldComponent } from '../../src';
 import { Pnt2 } from '@gg-web-engine/core';
+import { Rapier2dFactory, Rapier2dWorldComponent } from '../../src';
 
 describe(`Rapier2dTriggerComponent`, () => {
 
@@ -22,19 +22,19 @@ describe(`Rapier2dTriggerComponent`, () => {
   it(`should detect object intersection`, async () => {
     const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
-    const ball = factory.createRigidBody({
+    const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
       body: { dynamic: true, mass: 1 },
     }, { position: { x: 0, y: 12 } });
-    ball.addToWorld({ physicsWorld: world } as any);
-    ball.linearVelocity = { x: 0, y: -10 };
+    circle.addToWorld({ physicsWorld: world } as any);
+    circle.linearVelocity = { x: 0, y: -10 };
     let enterRegistered = false;
     let exitRegistered = false;
     trigger.onEntityEntered.subscribe(((obj) => {
-      enterRegistered = obj === ball;
+      enterRegistered = obj === circle;
     }));
     trigger.onEntityLeft.subscribe(((obj) => {
-      exitRegistered = obj === ball;
+      exitRegistered = obj === circle;
     }));
     world.simulate(500);
     trigger.checkOverlaps(); // trigger entity performs that on tick
@@ -50,15 +50,15 @@ describe(`Rapier2dTriggerComponent`, () => {
   it(`should detect end of object intersection`, async () => {
     const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
-    const ball = factory.createRigidBody({
+    const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
       body: { dynamic: true, mass: 1 },
     }, { position: { x: 0, y: 12 } });
-    ball.addToWorld({ physicsWorld: world } as any);
-    ball.linearVelocity = { x: 0, y: -10 };
+    circle.addToWorld({ physicsWorld: world } as any);
+    circle.linearVelocity = { x: 0, y: -10 };
     let exitRegistered = false;
     trigger.onEntityLeft.subscribe(((obj) => {
-      exitRegistered = obj === ball;
+      exitRegistered = obj === circle;
     }));
     world.simulate(1000);
     trigger.checkOverlaps();
@@ -71,54 +71,55 @@ describe(`Rapier2dTriggerComponent`, () => {
   it(`should fire object intersection if spawned inside`, async () => {
     const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
-    const ball = factory.createRigidBody({
+    const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
       body: { dynamic: true, mass: 1 },
-    }, { position: { x: 0, y: 0 } });
-    ball.addToWorld({ physicsWorld: world } as any);
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
     let enterRegistered = false;
     trigger.onEntityEntered.subscribe(((obj) => {
-      enterRegistered = obj === ball;
+      enterRegistered = obj === circle;
     }));
     world.simulate(1000);
     trigger.checkOverlaps();
     expect(enterRegistered).toBe(true);
   });
 
-  // TODO implement functionality below
-  // it(`should fire end of object intersection if trigger removed`, async () => {
-  //   const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
-  //   trigger.addToWorld({ physicsWorld: world } as any);
-  //   const ball = factory.createRigidBody({
-  //     shape: { shape: 'CIRCLE', radius: 1 },
-  //     body: { dynamic: true, mass: 1 },
-  //   }, { position: { x: 0, y: 0 } });
-  //   ball.addToWorld({ physicsWorld: world } as any);
-  //   let exitRegistered = false;
-  //   trigger.onEntityLeft.subscribe(((obj) => {
-  //     exitRegistered = obj === ball;
-  //   }));
-  //   world.simulate(1000);
-  //   trigger.checkOverlaps();
-  //   trigger.removeFromWorld({ physicsWorld: world } as any);
-  //   expect(exitRegistered).toBe(true);
-  // });
-  //
-  // it(`should fire end of object intersection if object removed`, async () => {
-  //   const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
-  //   trigger.addToWorld({ physicsWorld: world } as any);
-  //   const ball = factory.createRigidBody({
-  //     shape: { shape: 'CIRCLE', radius: 1 },
-  //     body: { dynamic: true, mass: 1 },
-  //   }, { position: { x: 0, y: 0 } });
-  //   ball.addToWorld({ physicsWorld: world } as any);
-  //   let exitRegistered = false;
-  //   trigger.onEntityLeft.subscribe(((obj) => {
-  //     exitRegistered = obj === ball;
-  //   }));
-  //   world.simulate(1000);
-  //   trigger.checkOverlaps();
-  //   ball.removeFromWorld({ physicsWorld: world } as any);
-  //   expect(exitRegistered).toBe(true);
-  // });
+  it(`should fire end of object intersection if trigger removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    world.simulate(1);
+    trigger.checkOverlaps();
+    trigger.removeFromWorld({ physicsWorld: world } as any);
+    expect(exitRegistered).toBe(true);
+  });
+
+  it(`should fire end of object intersection if object removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { dynamic: true, mass: 1 },
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    world.simulate(1);
+    trigger.checkOverlaps();
+    circle.removeFromWorld({ physicsWorld: world } as any);
+    world.simulate(1);
+    trigger.checkOverlaps();
+    expect(exitRegistered).toBe(true);
+  });
 });

package/test/components/rapier-2d-world.component.spec.ts

@@ -0,0 +1,296 @@
+import { Point2, RaycastOptions } from '@gg-web-engine/core';
+import { Rapier2dWorldComponent } from '../../src';
+
+describe('Rapier2dWorldComponent', () => {
+  let world: Rapier2dWorldComponent;
+
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new Rapier2dWorldComponent();
+    await world.init();
+    world.gravity = { x: 0, y: 0 }; // Set gravity to zero for predictable physics
+  });
+
+  afterAll(() => {
+    world.dispose();
+  });
+
+  describe('Rigid bodies', () => {
+
+    it('should simulate inertial motion of rigid body', () => {
+
+      const circle = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0 } });
+      circle.addToWorld({ physicsWorld: world } as any);
+      circle.linearVelocity = { x: 1, y: 0 };
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(circle.position.x).toBeCloseTo(1);
+    });
+
+    it('should simulate collision of two rigid bodies', () => {
+
+      const circle0 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0 } });
+      circle0.addToWorld({ physicsWorld: world } as any);
+      circle0.linearVelocity = { x: 1, y: 0 };
+
+      const circle1 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: 5, y: 0 } });
+      circle1.addToWorld({ physicsWorld: world } as any);
+      circle1.linearVelocity = { x: -1, y: 0 };
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(circle0.position.x).toBeLessThan(0);
+      expect(circle1.position.x).toBeGreaterThan(0);
+    });
+
+    it('should not simulate collision of two rigid bodies with different collision groups', () => {
+      const cg0 = world.registerCollisionGroup();
+      const circle0 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: -5, y: 0 } });
+      circle0.addToWorld({ physicsWorld: world } as any);
+      circle0.linearVelocity = { x: 1, y: 0 };
+      circle0.ownCollisionGroups = circle0.interactWithCollisionGroups = [cg0];
+
+      const cg1 = world.registerCollisionGroup();
+      const circle1 = world.factory.createRigidBody({
+        shape: { shape: 'CIRCLE', radius: 1 },
+        body: { dynamic: true, mass: 5 },
+      }, { position: { x: 5, y: 0 } });
+      circle1.addToWorld({ physicsWorld: world } as any);
+      circle1.linearVelocity = { x: -1, y: 0 };
+      circle1.ownCollisionGroups = circle1.interactWithCollisionGroups = [cg1];
+
+      // simulate for 6 seconds
+      for (let i = 0; i < 100; i++) {
+        world.simulate(60);
+      }
+      expect(circle0.position.x).toBeCloseTo(1);
+      expect(circle1.position.x).toBeCloseTo(-1);
+    });
+  });
+
+  describe('Raycast', () => {
+
+    it('should return no hit when ray does not intersect any object', () => {
+      // Create a square far away from the ray
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 10, y: 10 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that doesn't hit anything
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(false);
+      expect(result.hitPoint).toBeUndefined();
+      expect(result.hitNormal).toBeUndefined();
+      expect(result.hitDistance).toBeUndefined();
+    });
+
+    it('should detect hit when ray intersects an object', () => {
+      // Create a square in the path of the ray
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -5 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that hits the square
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+      expect(result.hitBody).toBe(square);
+      expect(result.hitPoint).toBeDefined();
+      expect(result.hitNormal).toBeDefined();
+      expect(result.hitDistance).toBeDefined();
+
+      // The hit should be at approximately y = -4 (box at y = -5 with size 2)
+      expect(result.hitPoint!.y).toBeCloseTo(-4, 0.1);
+
+      // The normal should point up (towards the ray origin)
+      expect(result.hitNormal!.y).toBeGreaterThan(0);
+    });
+
+    it('should respect collision filtering', () => {
+      // Register collision groups
+      const group1 = world.registerCollisionGroup();
+      const group2 = world.registerCollisionGroup();
+
+      // Create a square that only belongs to group1
+      const square1 = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: {
+          dynamic: false,
+          mass: 0,
+          ownCollisionGroups: [group1],
+          interactWithCollisionGroups: [group1, group2],
+        },
+      }, { position: { x: 0, y: -5 } });
+      square1.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Ray that only checks against group2 should not hit
+      const rayOptions1: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+        collisionFilterGroups: [group2],
+        collisionFilterMask: [group2],
+      };
+
+      const result1 = world.raycast(rayOptions1);
+      expect(result1.hasHit).toBe(false);
+
+      // Ray that checks against group1 should hit
+      const rayOptions2: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+        collisionFilterGroups: [group1],
+        collisionFilterMask: [group1],
+      };
+
+      const result2 = world.raycast(rayOptions2);
+      expect(result2.hasHit).toBe(true);
+      expect(result2.hitBody).toBe(square1);
+    });
+
+    it('should calculate hit distance correctly', () => {
+      // Create a square at a known distance
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -5 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray from origin to y = -10
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+
+      // The hit distance should be approximately 4 units
+      // (from origin to the edge of the square at y = -4)
+      expect(result.hitDistance).toBeCloseTo(4, 0.1);
+    });
+
+    it('should handle array of collision groups correctly', () => {
+      // Register collision groups
+      const group1 = world.registerCollisionGroup();
+      const group2 = world.registerCollisionGroup();
+
+      // Create a square that belongs to group1
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+        body: {
+          dynamic: false,
+          mass: 0,
+          ownCollisionGroups: [group1],
+          interactWithCollisionGroups: [group1, group2],
+        },
+      }, { position: { x: 0, y: -5 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Ray that checks against both groups should hit
+      const rayOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+        collisionFilterGroups: [group1, group2],
+        collisionFilterMask: [group1, group2],
+      };
+
+      const result = world.raycast(rayOptions);
+      expect(result.hasHit).toBe(true);
+    });
+
+    it('should return correct hit body', () => {
+      // Create two squares at different positions
+      const square1 = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -3 } });
+      square1.addToWorld({ physicsWorld: world } as any);
+
+      const square2 = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: -7 } });
+      square2.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray that should hit square1 first
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+      expect(result.hasHit).toBe(true);
+      expect(result.hitBody).toBe(square1);
+      expect(result.hitPoint!.y).toBeCloseTo(-2.5, 0.1); // square1 edge is at y = -2.5
+    });
+
+    it('should handle edge case with ray starting inside an object', () => {
+      // Create a square
+      const square = world.factory.createRigidBody({
+        shape: { shape: 'SQUARE', dimensions: { x: 4, y: 4 } },
+        body: { dynamic: false, mass: 0 },
+      }, { position: { x: 0, y: 0 } });
+      square.addToWorld({ physicsWorld: world } as any);
+
+      world.simulate(1);
+
+      // Cast a ray from inside the square
+      const raycastOptions: RaycastOptions<Point2> = {
+        from: { x: 0, y: 0 }, // Center of the square
+        to: { x: 0, y: -10 },
+      };
+
+      const result = world.raycast(raycastOptions);
+
+      // Behavior may vary depending on physics engine implementation
+      // Some engines might not detect hits when starting inside an object
+      // Others might detect the exit point
+      // We just verify the method doesn't crash and returns a valid result
+      expect(result).toBeDefined();
+    });
+  });
+});