@gg-web-engine/matter 0.0.72 → 0.0.74

package/test/components/matter-trigger.component.spec.ts

@@ -19,12 +19,103 @@ describe(`MatterTriggerComponent`, () => {
     world.dispose();
   });
 
-  // FIXME matter.js logic is kinda not intuitive. Spawning objects on some coordinates seems to cause collisions with
-  // all the objects that intersect the line between (0, 0) and desired position, sensors are flying away to the
-  // infinity just by setting it's position and other wonderful miracles. Investigate why these tests fail and try to fix.
+  it(`stays where it was placed under gravity, and never reports static level geometry`, async () => {
+    world.gravity = { x: 0, y: 9.82 };
+    const ground = factory.createRigidBody(
+      { shape: { shape: 'BOX', dimensions: { x: 100, y: 10 } }, body: { bodyType: 'static', mass: 0 } },
+      { position: { x: 0, y: 50 } },
+    );
+    ground.addToWorld({ physicsWorld: world } as any);
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } }, { position: { x: 0, y: 0 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    let entered = 0;
+    trigger.onEntityEntered.subscribe(() => entered++);
+    for (let i = 0; i < 300; i++) {
+      world.simulate(16);
+      trigger.checkOverlaps();
+    }
+    expect(trigger.position).toEqual({ x: 0, y: 0 });
+    expect(entered).toBe(0);
+  });
+
+  it(`detects a kinematic body moving in and out`, async () => {
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const platform = factory.createRigidBody(
+      { shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } }, body: { bodyType: 'kinematic_pos', mass: 0 } },
+      { position: { x: 20, y: 0 } },
+    );
+    warn.mockRestore();
+    platform.addToWorld({ physicsWorld: world } as any);
+    const events: string[] = [];
+    trigger.onEntityEntered.subscribe(obj => events.push(obj === platform ? 'enter' : 'other'));
+    trigger.onEntityLeft.subscribe(obj => events.push(obj === platform ? 'left' : 'other'));
+    const step = () => {
+      world.simulate(16);
+      trigger.checkOverlaps();
+    };
+    step();
+    platform.position = { x: 0, y: 0 };
+    step();
+    step();
+    expect(events).toEqual(['enter']);
+    platform.position = { x: 20, y: 0 };
+    step();
+    expect(events).toEqual(['enter', 'left']);
+  });
+
+  it(`keeps a body that falls asleep inside, and reports it leaving after waking up`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const box = factory.createRigidBody(
+      { shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } }, body: { bodyType: 'dynamic', mass: 1 } },
+      { position: Pnt2.O },
+    );
+    box.addToWorld({ physicsWorld: world } as any);
+    const events: string[] = [];
+    trigger.onEntityEntered.subscribe(obj => events.push(obj === box ? 'enter' : 'other'));
+    trigger.onEntityLeft.subscribe(obj => events.push(obj === box ? 'left' : 'other'));
+    const step = () => {
+      world.simulate(16);
+      trigger.checkOverlaps();
+    };
+    step();
+    expect(events).toEqual(['enter']);
+    box.sleep();
+    for (let i = 0; i < 10; i++) {
+      step();
+    }
+    expect(events).toEqual(['enter']);
+    box.wakeUp();
+    step();
+    step();
+    expect(events).toEqual(['enter']);
+    box.position = { x: 20, y: 0 };
+    step();
+    step();
+    expect(events).toEqual(['enter', 'left']);
+  });
+
+  it(`detects a body that is put to sleep before entering`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const box = factory.createRigidBody(
+      { shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } }, body: { bodyType: 'dynamic', mass: 1 } },
+      { position: Pnt2.O },
+    );
+    box.sleep();
+    box.addToWorld({ physicsWorld: world } as any);
+    let entered = 0;
+    trigger.onEntityEntered.subscribe(() => entered++);
+    world.simulate(16);
+    trigger.checkOverlaps();
+    expect(entered).toBe(1);
+  });
+
   // Note: this test is identical to rapier2d trigger test, and it is expected
-  it.skip(`should detect object intersection`, async () => {
-    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+  it(`should detect object intersection`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
     const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
@@ -52,8 +143,8 @@ describe(`MatterTriggerComponent`, () => {
     expect(exitRegistered).toBe(false);
   });
 
-  it.skip(`should detect end of object intersection`, async () => {
-    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+  it(`should detect end of object intersection`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
     const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
@@ -74,8 +165,8 @@ describe(`MatterTriggerComponent`, () => {
     expect(exitRegistered).toBe(true);
   });
 
-  it.skip(`should fire object intersection if spawned inside`, async () => {
-    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+  it(`should fire object intersection if spawned inside`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
     const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
@@ -91,8 +182,8 @@ describe(`MatterTriggerComponent`, () => {
     expect(enterRegistered).toBe(true);
   });
 
-  it.skip(`should fire end of object intersection if trigger removed`, async () => {
-    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+  it(`should fire end of object intersection if trigger removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
     const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
@@ -109,8 +200,8 @@ describe(`MatterTriggerComponent`, () => {
     expect(exitRegistered).toBe(true);
   });
 
-  it.skip(`should fire end of object intersection if object removed`, async () => {
-    const trigger = factory.createTrigger({ shape: 'SQUARE', dimensions: { x: 10, y: 10 } });
+  it(`should fire end of object intersection if object removed`, async () => {
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
     trigger.addToWorld({ physicsWorld: world } as any);
     const circle = factory.createRigidBody({
       shape: { shape: 'CIRCLE', radius: 1 },
@@ -124,8 +215,39 @@ describe(`MatterTriggerComponent`, () => {
     world.simulate(1);
     trigger.checkOverlaps();
     circle.removeFromWorld({ physicsWorld: world } as any);
+    // the removed$ reaction drops the overlap synchronously but emits onEntityLeft on a microtask
+    // (see MatterTriggerComponent.removedSub's own doc) - nothing a later step/checkOverlaps() poll
+    // could still notice, so give that microtask a chance to run
+    await Promise.resolve();
+    world.simulate(1);
+    trigger.checkOverlaps();
+    expect(exitRegistered).toBe(true);
+  });
+
+  it(`should fire end of object intersection on the next microtask when the object is removed, with no step or checkOverlaps() poll`, async () => {
+    // Composite.remove never fires a native collisionEnd for the body it removes, so the only thing
+    // that can fire onEntityLeft for it is the trigger's own removed$ reaction. That reaction must
+    // not emit inline from inside the removal's own call stack (a removal can happen partway
+    // through an unrelated component's own lifecycle operation, e.g. a character's crouch/stand
+    // capsule swap - see MatterTriggerComponent.removedSub's own doc), so the emission is deferred
+    // to a microtask: not yet observable synchronously after removeFromWorld, observable right after
+    // one microtask hop, with no simulate()/checkOverlaps() call in between at all.
+    const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });
+    trigger.addToWorld({ physicsWorld: world } as any);
+    const circle = factory.createRigidBody({
+      shape: { shape: 'CIRCLE', radius: 1 },
+      body: { bodyType: 'dynamic', mass: 1 },
+    }, { position: Pnt2.O });
+    circle.addToWorld({ physicsWorld: world } as any);
     world.simulate(1);
     trigger.checkOverlaps();
+    let exitRegistered = false;
+    trigger.onEntityLeft.subscribe(((obj) => {
+      exitRegistered = obj === circle;
+    }));
+    circle.removeFromWorld({ physicsWorld: world } as any);
+    expect(exitRegistered).toBe(false);
+    await Promise.resolve();
     expect(exitRegistered).toBe(true);
   });
 });

package/test/components/matter-world.component.spec.ts

@@ -118,12 +118,12 @@ describe('MatterWorldComponent', () => {
     });
   });
 
-  describe.skip('Raycast', () => {
+  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 } },
+          shape: { shape: 'BOX', dimensions: { x: 1, y: 1 } },
           body: { bodyType: 'static', mass: 0 },
         },
         { position: { x: 10, y: 10 } },
@@ -149,7 +149,7 @@ describe('MatterWorldComponent', () => {
       // Create a square in the path of the ray
       const square = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+          shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } },
           body: { bodyType: 'static', mass: 0 },
         },
         { position: { x: 0, y: -5 } },
@@ -186,7 +186,7 @@ describe('MatterWorldComponent', () => {
       // Create a square that only belongs to group1
       const square1 = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+          shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } },
           body: {
             bodyType: 'static',
             mass: 0,
@@ -228,7 +228,7 @@ describe('MatterWorldComponent', () => {
       // Create a square at a known distance
       const square = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+          shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } },
           body: { bodyType: 'static', mass: 0 },
         },
         { position: { x: 0, y: -5 } },
@@ -259,7 +259,7 @@ describe('MatterWorldComponent', () => {
       // Create a square that belongs to group1
       const square = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 2, y: 2 } },
+          shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } },
           body: {
             bodyType: 'static',
             mass: 0,
@@ -289,7 +289,7 @@ describe('MatterWorldComponent', () => {
       // Create two squares at different positions
       const square1 = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+          shape: { shape: 'BOX', dimensions: { x: 1, y: 1 } },
           body: { bodyType: 'static', mass: 0 },
         },
         { position: { x: 0, y: -3 } },
@@ -298,7 +298,7 @@ describe('MatterWorldComponent', () => {
 
       const square2 = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 1, y: 1 } },
+          shape: { shape: 'BOX', dimensions: { x: 1, y: 1 } },
           body: { bodyType: 'static', mass: 0 },
         },
         { position: { x: 0, y: -7 } },
@@ -323,7 +323,7 @@ describe('MatterWorldComponent', () => {
       // Create a square
       const square = world.factory.createRigidBody(
         {
-          shape: { shape: 'SQUARE', dimensions: { x: 4, y: 4 } },
+          shape: { shape: 'BOX', dimensions: { x: 4, y: 4 } },
           body: { bodyType: 'static', mass: 0 },
         },
         { position: { x: 0, y: 0 } },
@@ -346,5 +346,40 @@ describe('MatterWorldComponent', () => {
       // We just verify the method doesn't crash and returns a valid result
       expect(result).toBeDefined();
     });
+
+    it('should never resolve a hit against a trigger, even when the ray starts inside it', () => {
+      // A trigger is a sensor with no collision response (ITrigger2dComponent) and must never
+      // obstruct a raycast - a world-enclosing trigger (a map-bounds kill volume) would otherwise
+      // be "hit" at ~0 distance by every ray cast anywhere inside it. raycast() excludes sensor
+      // bodies from its candidate set outright (see its own doc).
+      const trigger = world.factory.createTrigger({ shape: 'BOX', dimensions: { x: 100, y: 100 } });
+      trigger.addToWorld({ physicsWorld: world } as any);
+      world.simulate(1);
+
+      // from well inside the trigger's volume, hitting nothing else
+      const result = world.raycast({
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: 10 },
+      });
+      expect(result.hasHit).toBe(false);
+
+      // a real solid body behind/through the trigger must still be hit normally
+      const square = world.factory.createRigidBody(
+        {
+          shape: { shape: 'BOX', dimensions: { x: 2, y: 2 } },
+          body: { bodyType: 'static', mass: 0 },
+        },
+        { position: { x: 0, y: -5 } },
+      );
+      square.addToWorld({ physicsWorld: world } as any);
+      world.simulate(1);
+
+      const throughResult = world.raycast({
+        from: { x: 0, y: 0 },
+        to: { x: 0, y: -10 },
+      });
+      expect(throughResult.hasHit).toBe(true);
+      expect(throughResult.hitBody).toBe(square);
+    });
   });
 });