@gg-web-engine/matter 0.0.73 → 0.0.74

package/dist/components/matter-rigid-body.component.d.ts

@@ -60,4 +60,30 @@ export declare class MatterRigidBodyComponent implements IRigidBody2dComponent<M
     removeFromWorld(world: MatterGgWorld, dispose?: boolean): void;
     dispose(): void;
     resetMotion(): void;
+    /**
+     * A `kinematic_pos`/`kinematic_vel` request also reports `isStatic: true` here - see this
+     * component's own `bodyType`/`bodyOptions` doc for why matter-js can't distinguish that from a
+     * genuine `'static'` body natively. Both are equally never simulated as a sleepable dynamic body,
+     * so gating on the native `isStatic` flag rather than `this.bodyType === 'static'` is correct for
+     * both cases, not just the literal static one.
+     *
+     * Also always `false` regardless of `isStatic` unless the world's underlying `Matter.Engine` was
+     * created with `enableSleeping: true` - this adapter never turns that on itself (see
+     * `MatterWorldComponent`'s own doc on its `matterWorld`/engine setup), so a body constructed
+     * through this adapter alone never actually falls asleep on its own; `sleep()` below still forces
+     * it regardless of that engine setting.
+     */
+    get isSleeping(): boolean;
+    /**
+     * No-op on a body that reports `isStatic` (a genuine `'static'` body, or a `kinematic_pos`/
+     * `kinematic_vel` request - see `isSleeping`'s own doc for why both are treated the same here).
+     */
+    wakeUp(): void;
+    /**
+     * No-op on a body that reports `isStatic` (see `isSleeping`'s own doc). Forces sleep immediately,
+     * regardless of whether the world's `Matter.Engine` has `enableSleeping` turned on - unlike a
+     * body naturally falling asleep from inactivity (which requires that engine flag), an explicit
+     * `Sleeping.set(body, true)` call takes effect either way.
+     */
+    sleep(): void;
 }

package/dist/components/matter-rigid-body.component.js

@@ -1,5 +1,5 @@
 import { BitMask, DebugBody2DSettings, Pnt2, } from '@gg-web-engine/core';
-import { Body, Composite, Vector } from 'matter-js';
+import { Body, Composite, Sleeping, Vector } from 'matter-js';
 import { Subject } from 'rxjs';
 // FIXME why this needs to be introduced? investigate units in matter.js
 const MATTER_VELOCITY_SCALE = 0.0166667;
@@ -14,7 +14,7 @@ export class MatterRigidBodyComponent {
         return this.nativeBody.angle;
     }
     set rotation(value) {
-        this.nativeBody.angle = value;
+        Body.setAngle(this.nativeBody, value);
     }
     get linearVelocity() {
         return Pnt2.scalarMult(this.nativeBody.velocity, 1 / MATTER_VELOCITY_SCALE);
@@ -70,7 +70,7 @@ export class MatterRigidBodyComponent {
         // rather than what an app originally asked for - the console warning at creation time is what
         // tells a developer their kinematic request wasn't honored, not this view.
         this.debugBodySettings = new DebugBody2DSettings(isFinite(this.nativeBody.mass)
-            ? { type: 'RIGID_DYNAMIC', sleeping: () => this.nativeBody.isSleeping }
+            ? { type: 'RIGID_DYNAMIC', sleeping: () => this.isSleeping }
             : { type: 'RIGID_STATIC' }, this.shape);
         this._interactWithCGsMask = BitMask.full(16);
         this._ownCGsMask = BitMask.full(16);
@@ -172,4 +172,42 @@ export class MatterRigidBodyComponent {
         Body.setVelocity(this.nativeBody, Pnt2.O);
         Body.setAngularVelocity(this.nativeBody, 0);
     }
+    /**
+     * A `kinematic_pos`/`kinematic_vel` request also reports `isStatic: true` here - see this
+     * component's own `bodyType`/`bodyOptions` doc for why matter-js can't distinguish that from a
+     * genuine `'static'` body natively. Both are equally never simulated as a sleepable dynamic body,
+     * so gating on the native `isStatic` flag rather than `this.bodyType === 'static'` is correct for
+     * both cases, not just the literal static one.
+     *
+     * Also always `false` regardless of `isStatic` unless the world's underlying `Matter.Engine` was
+     * created with `enableSleeping: true` - this adapter never turns that on itself (see
+     * `MatterWorldComponent`'s own doc on its `matterWorld`/engine setup), so a body constructed
+     * through this adapter alone never actually falls asleep on its own; `sleep()` below still forces
+     * it regardless of that engine setting.
+     */
+    get isSleeping() {
+        return !this.nativeBody.isStatic && this.nativeBody.isSleeping;
+    }
+    /**
+     * No-op on a body that reports `isStatic` (a genuine `'static'` body, or a `kinematic_pos`/
+     * `kinematic_vel` request - see `isSleeping`'s own doc for why both are treated the same here).
+     */
+    wakeUp() {
+        if (this.nativeBody.isStatic) {
+            return;
+        }
+        Sleeping.set(this.nativeBody, false);
+    }
+    /**
+     * No-op on a body that reports `isStatic` (see `isSleeping`'s own doc). Forces sleep immediately,
+     * regardless of whether the world's `Matter.Engine` has `enableSleeping` turned on - unlike a
+     * body naturally falling asleep from inactivity (which requires that engine flag), an explicit
+     * `Sleeping.set(body, true)` call takes effect either way.
+     */
+    sleep() {
+        if (this.nativeBody.isStatic) {
+            return;
+        }
+        Sleeping.set(this.nativeBody, true);
+    }
 }

package/dist/components/matter-trigger.component.d.ts

@@ -20,6 +20,10 @@ export declare class MatterTriggerComponent extends MatterRigidBodyComponent imp
     readonly debugBodySettings: DebugBody2DSettings;
     protected intersectionsAmount: number;
     protected currentOverlaps: Set<MatterRigidBodyComponent>;
+    /** The subset of `currentOverlaps` whose exit `checkOverlaps()` detects by polling, because matter's
+     * detector doesn't pair them with this (static) trigger body - see {@link isPolled}. A body moves
+     * back to the native-event path once a native `collisionStart` reports it (it woke up inside). */
+    protected polledOverlaps: Set<MatterRigidBodyComponent>;
     /** `Composite.remove` (what `removeFromWorld` calls) never fires a native `collisionEnd` for the
      * body it removes - matter-js simply stops considering that body's pairs on the next step, it
      * doesn't retroactively report the pairs that were active at removal time. Without this, a body
@@ -44,6 +48,14 @@ export declare class MatterTriggerComponent extends MatterRigidBodyComponent imp
     private removedSub?;
     private handleCollisionStart;
     private handleCollisionEnd;
+    /**
+     * Whether matter's detector never pairs `comp` with this trigger: it skips every pair whose bodies
+     * are both static or sleeping, and the trigger body is static. That covers sleeping bodies and
+     * kinematic ones (built as static here, see `MatterFactory`). Bodies requested as `'static'` are
+     * level geometry and are never reported.
+     */
+    protected isPolled(comp: MatterRigidBodyComponent): boolean;
+    protected overlaps(comp: MatterRigidBodyComponent): boolean;
     constructor(nativeBody: Body, shape: Shape2DDescriptor, world: MatterWorldComponent);
     addToWorld(world: MatterGgWorld): void;
     removeFromWorld(world: MatterGgWorld, dispose?: boolean): void;
@@ -52,9 +64,10 @@ export declare class MatterTriggerComponent extends MatterRigidBodyComponent imp
      * enter/exit subjects are a separate pair this subclass owns and must complete itself. */
     dispose(): void;
     /**
-     * Regular rigid-body overlaps are handled entirely by `handleCollisionStart`/`handleCollisionEnd`
-     * above, off matter's own native `collisionStart`/`collisionEnd` engine events - so this used to be
-     * a pure no-op for matter-js. A `MatterCharacterControllerComponent`'s own phantom body is
+     * Awake dynamic bodies are handled by `handleCollisionStart`/`handleCollisionEnd` above, off
+     * matter's own native `collisionStart`/`collisionEnd` engine events; kinematic and sleeping ones,
+     * which matter never pairs with this static body, are polled by `checkPolledBodyOverlaps()`.
+     * A `MatterCharacterControllerComponent`'s own phantom body is
      * deliberately never added to `Composite`/`engine.world` at all (see that class's own doc), so no
      * native collision pair - and thus no native event - can ever involve it. Since `checkOverlaps()` is
      * already called once per tick by `Trigger2dEntity` regardless of backend, this is the natural place
@@ -66,5 +79,12 @@ export declare class MatterTriggerComponent extends MatterRigidBodyComponent imp
      * ordinary bodies.
      */
     checkOverlaps(): void;
+    /**
+     * Enter/exit of the rigid bodies matter's detector never pairs with this trigger (see
+     * {@link isPolled}): a kinematic platform moving in or out, a body asleep inside. Like the
+     * character poll below, `Query.collides` ignores `collisionFilter`, so `Detector.canCollide` is
+     * checked by hand.
+     */
+    protected checkPolledBodyOverlaps(): void;
     clone(): MatterTriggerComponent;
 }

package/dist/components/matter-trigger.component.js

@@ -22,6 +22,11 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
             if (body) {
                 let comp = this.world.children.find(c => c.nativeBody === body);
                 if (comp instanceof MatterRigidBodyComponent) {
+                    if (this.currentOverlaps.has(comp)) {
+                        // already inside via polling (it was asleep or kinematic): the native pair takes over
+                        this.polledOverlaps.delete(comp);
+                        continue;
+                    }
                     this.currentOverlaps.add(comp);
                     this.onEnter$.next(comp);
                 }
@@ -39,13 +44,31 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
             }
             if (body) {
                 let comp = this.world.children.find(c => c.nativeBody === body);
-                if (comp instanceof MatterRigidBodyComponent) {
+                if (comp instanceof MatterRigidBodyComponent && this.currentOverlaps.has(comp)) {
+                    if (this.isPolled(comp) && this.overlaps(comp)) {
+                        // a body falling asleep inside: matter drops the pair without it having left
+                        this.polledOverlaps.add(comp);
+                        continue;
+                    }
                     this.currentOverlaps.delete(comp);
+                    this.polledOverlaps.delete(comp);
                     this.onLeft$.next(comp);
                 }
             }
         }
     }
+    /**
+     * Whether matter's detector never pairs `comp` with this trigger: it skips every pair whose bodies
+     * are both static or sleeping, and the trigger body is static. That covers sleeping bodies and
+     * kinematic ones (built as static here, see `MatterFactory`). Bodies requested as `'static'` are
+     * level geometry and are never reported.
+     */
+    isPolled(comp) {
+        return comp.bodyType === 'kinematic_pos' || comp.bodyType === 'kinematic_vel' || comp.nativeBody.isSleeping;
+    }
+    overlaps(comp) {
+        return Query.collides(this.nativeBody, [comp.nativeBody]).length > 0;
+    }
     constructor(nativeBody, shape, world) {
         super(nativeBody, shape);
         this.shape = shape;
@@ -60,7 +83,17 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
         this.debugBodySettings = new DebugBody2DSettings({ type: 'TRIGGER', activated: () => this.intersectionsAmount > 0 }, this.shape);
         this.intersectionsAmount = 0;
         this.currentOverlaps = new Set();
+        /** The subset of `currentOverlaps` whose exit `checkOverlaps()` detects by polling, because matter's
+         * detector doesn't pair them with this (static) trigger body - see {@link isPolled}. A body moves
+         * back to the native-event path once a native `collisionStart` reports it (it woke up inside). */
+        this.polledOverlaps = new Set();
         this.nativeBody.isSensor = true;
+        // A trigger is a fixed volume: left non-static, matter-js integrates its sensor body under
+        // gravity like any dynamic body, and since a sensor never collides it falls through the level
+        // (overlapping, and reporting, whatever it passes on the way down). Static also keeps
+        // static-static pairs (trigger vs level geometry) out of matter's broadphase entirely - which
+        // drops kinematic and sleeping bodies too, so `checkOverlaps()` polls those.
+        Body.setStatic(this.nativeBody, true);
         merge(this.onEnter$.pipe(map(() => true)), this.onLeft$.pipe(map(() => false))).subscribe(enter => {
             if (enter) {
                 this.intersectionsAmount++;
@@ -78,6 +111,7 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
         }
         this.intersectionsAmount = 0;
         this.currentOverlaps.clear();
+        this.polledOverlaps.clear();
         super.addToWorld(world);
         Events.on(world.physicsWorld.matterEngine, 'collisionStart', this.handleCollisionStart);
         Events.on(world.physicsWorld.matterEngine, 'collisionEnd', this.handleCollisionEnd);
@@ -91,6 +125,7 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
                 }
             }
             else if (c instanceof MatterRigidBodyComponent && this.currentOverlaps.delete(c)) {
+                this.polledOverlaps.delete(c);
                 queueMicrotask(() => this.onLeft$.next(c));
             }
         });
@@ -104,6 +139,7 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
             this.onLeft$.next(body);
         }
         this.currentOverlaps.clear();
+        this.polledOverlaps.clear();
         for (const character of this.currentCharacterOverlaps) {
             this.onLeft$.next(character);
         }
@@ -119,9 +155,10 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
         super.dispose();
     }
     /**
-     * Regular rigid-body overlaps are handled entirely by `handleCollisionStart`/`handleCollisionEnd`
-     * above, off matter's own native `collisionStart`/`collisionEnd` engine events - so this used to be
-     * a pure no-op for matter-js. A `MatterCharacterControllerComponent`'s own phantom body is
+     * Awake dynamic bodies are handled by `handleCollisionStart`/`handleCollisionEnd` above, off
+     * matter's own native `collisionStart`/`collisionEnd` engine events; kinematic and sleeping ones,
+     * which matter never pairs with this static body, are polled by `checkPolledBodyOverlaps()`.
+     * A `MatterCharacterControllerComponent`'s own phantom body is
      * deliberately never added to `Composite`/`engine.world` at all (see that class's own doc), so no
      * native collision pair - and thus no native event - can ever involve it. Since `checkOverlaps()` is
      * already called once per tick by `Trigger2dEntity` regardless of backend, this is the natural place
@@ -133,6 +170,7 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
      * ordinary bodies.
      */
     checkOverlaps() {
+        this.checkPolledBodyOverlaps();
         // `Query.collides` tests raw geometry only and knows nothing about `collisionFilter` (see
         // `MatterCharacterControllerComponent.collectObstacles`'s own doc on this same gap) - call
         // matter's own `Detector.canCollide` directly so a character controller whose collision groups
@@ -164,6 +202,33 @@ export class MatterTriggerComponent extends MatterRigidBodyComponent {
             }
         }
     }
+    /**
+     * Enter/exit of the rigid bodies matter's detector never pairs with this trigger (see
+     * {@link isPolled}): a kinematic platform moving in or out, a body asleep inside. Like the
+     * character poll below, `Query.collides` ignores `collisionFilter`, so `Detector.canCollide` is
+     * checked by hand.
+     */
+    checkPolledBodyOverlaps() {
+        for (const comp of this.world.children) {
+            if (comp instanceof MatterRigidBodyComponent &&
+                !(comp instanceof MatterTriggerComponent) &&
+                !this.currentOverlaps.has(comp) &&
+                this.isPolled(comp) &&
+                Detector.canCollide(this.nativeBody.collisionFilter, comp.nativeBody.collisionFilter) &&
+                this.overlaps(comp)) {
+                this.currentOverlaps.add(comp);
+                this.polledOverlaps.add(comp);
+                this.onEnter$.next(comp);
+            }
+        }
+        for (const comp of this.polledOverlaps) {
+            if (!this.overlaps(comp)) {
+                this.polledOverlaps.delete(comp);
+                this.currentOverlaps.delete(comp);
+                this.onLeft$.next(comp);
+            }
+        }
+    }
     clone() {
         const clonedBody = Body.create(Object.assign(Object.assign({}, this.nativeBody), { isSensor: true, collisionFilter: Object.assign({}, this.nativeBody.collisionFilter) }));
         const component = new MatterTriggerComponent(clonedBody, this.shape, this.world);

package/dist/components/matter-world.component.d.ts

@@ -27,6 +27,18 @@ export declare class MatterWorldComponent implements IPhysicsWorld2dComponent<Ma
     set gravity(value: Point2);
     readonly mainCollisionGroup: CollisionGroup;
     constructor();
+    /**
+     * `Engine.create` is never given `enableSleeping: true` here, matching matter-js's own default -
+     * so a body this world creates never *naturally* falls asleep from prolonged inactivity, no matter
+     * how long it rests. `IRigidBodyComponent.sleep()`/`wakeUp()` still work regardless of this flag
+     * (`Matter.Sleeping.set` writes a body's `isSleeping` flag directly, and `Engine.update`'s own
+     * per-body integration skip checks that flag unconditionally, not gated behind
+     * `engine.enableSleeping` - only the *automatic* fall-asleep-from-rest/wake-on-collision behavior
+     * is gated behind that flag) - only automatic, inactivity-driven sleeping is unavailable under the
+     * current setup. A future change enabling it should re-check
+     * `gg-engine-physics-adapter-matter`'s own note on this before assuming every existing
+     * position/velocity setter still behaves the same way once bodies can sleep on their own.
+     */
     init(): Promise<void>;
     private findRigidBody;
     /**

package/dist/components/matter-world.component.js

@@ -118,6 +118,18 @@ export class MatterWorldComponent {
         this.handleCollisionStart = this.handleCollisionStart.bind(this);
         this.handleCollisionEnd = this.handleCollisionEnd.bind(this);
     }
+    /**
+     * `Engine.create` is never given `enableSleeping: true` here, matching matter-js's own default -
+     * so a body this world creates never *naturally* falls asleep from prolonged inactivity, no matter
+     * how long it rests. `IRigidBodyComponent.sleep()`/`wakeUp()` still work regardless of this flag
+     * (`Matter.Sleeping.set` writes a body's `isSleeping` flag directly, and `Engine.update`'s own
+     * per-body integration skip checks that flag unconditionally, not gated behind
+     * `engine.enableSleeping` - only the *automatic* fall-asleep-from-rest/wake-on-collision behavior
+     * is gated behind that flag) - only automatic, inactivity-driven sleeping is unavailable under the
+     * current setup. A future change enabling it should re-check
+     * `gg-engine-physics-adapter-matter`'s own note on this before assuming every existing
+     * position/velocity setter still behaves the same way once bodies can sleep on their own.
+     */
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             this.matterEngine_ = Engine.create({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/matter",
-  "version": "0.0.73",
+  "version": "0.0.74",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,7 +30,7 @@
     "poly-decomp": "^0.3.0"
   },
   "devDependencies": {
-    "@gg-web-engine/core": "0.0.73",
+    "@gg-web-engine/core": "0.0.74",
     "@types/jest": "^30.0.0",
     "@types/matter-js": "0.20.2",
     "@types/node": "^26.4.0",
@@ -43,7 +43,7 @@
     "typescript": "~6.0.3"
   },
   "peerDependencies": {
-    "@gg-web-engine/core": "0.0.73",
+    "@gg-web-engine/core": "0.0.74",
     "matter-js": "0.20.0",
     "rxjs": "7.8.2"
   },

package/test/components/matter-rigid-body-sleep.spec.ts

@@ -0,0 +1,79 @@
+import { Pnt2 } from '@gg-web-engine/core';
+import { MatterFactory, MatterWorldComponent } from '../../src';
+
+describe('MatterRigidBodyComponent sleep API', () => {
+  let world: MatterWorldComponent;
+  let factory: MatterFactory;
+
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new MatterWorldComponent();
+    factory = new MatterFactory(world);
+    await world.init();
+    world.gravity = Pnt2.O;
+  });
+
+  afterAll(() => {
+    world.dispose();
+  });
+
+  it('reports a fresh dynamic body as not sleeping', () => {
+    const body = factory.createRigidBody(
+      { shape: { shape: 'CIRCLE', radius: 1 }, body: { bodyType: 'dynamic', mass: 1 } },
+      { position: { x: 0, y: 0 } },
+    );
+    body.addToWorld({ physicsWorld: world } as any);
+
+    expect(body.isSleeping).toBe(false);
+  });
+
+  it('sleep() forces isSleeping true, wakeUp() flips it back - regardless of the world engine\'s enableSleeping setting', () => {
+    const body = factory.createRigidBody(
+      { shape: { shape: 'CIRCLE', radius: 1 }, body: { bodyType: 'dynamic', mass: 1 } },
+      { position: { x: 0, y: 0 } },
+    );
+    body.addToWorld({ physicsWorld: world } as any);
+
+    body.sleep();
+    expect(body.isSleeping).toBe(true);
+
+    body.wakeUp();
+    expect(body.isSleeping).toBe(false);
+  });
+
+  it('a position write on a sleeping body does NOT wake it back up - unlike every other adapter', () => {
+    const body = factory.createRigidBody(
+      { shape: { shape: 'CIRCLE', radius: 1 }, body: { bodyType: 'dynamic', mass: 1 } },
+      { position: { x: 0, y: 0 } },
+    );
+    body.addToWorld({ physicsWorld: world } as any);
+
+    body.sleep();
+    expect(body.isSleeping).toBe(true);
+
+    body.position = { x: 1, y: 2 };
+    expect(body.isSleeping).toBe(true);
+    // the write itself is not silently dropped - a caller that must write state on a sleeping
+    // body without waking it (the whole point of this adapter's setters preserving sleep state)
+    // still sees the new position take effect.
+    expect(body.position).toEqual({ x: 1, y: 2 });
+  });
+
+  it('a static body always reports not sleeping, and sleep()/wakeUp() are no-ops', () => {
+    const floor = factory.createRigidBody(
+      { shape: { shape: 'BOX', dimensions: { x: 10, y: 1 } }, body: { bodyType: 'static' } },
+      { position: { x: 0, y: 0 } },
+    );
+    floor.addToWorld({ physicsWorld: world } as any);
+
+    expect(floor.isSleeping).toBe(false);
+
+    floor.sleep();
+    expect(floor.isSleeping).toBe(false);
+
+    floor.wakeUp();
+    expect(floor.isSleeping).toBe(false);
+  });
+});

package/test/components/matter-rigid-body.component.spec.ts

@@ -56,3 +56,43 @@ describe('MatterRigidBodyComponent.bodyOptions', () => {
     expect(body.bodyOptions.interactWithCollisionGroups).toEqual([5, 6]);
   });
 });
+
+describe('MatterRigidBodyComponent.rotation', () => {
+  let world: MatterWorldComponent;
+  let factory: MatterFactory;
+
+  beforeEach(async () => {
+    if (world) {
+      world.dispose();
+    }
+    world = new MatterWorldComponent();
+    factory = new MatterFactory(world);
+    await world.init();
+    world.gravity = Pnt2.O;
+  });
+
+  afterAll(() => {
+    world.dispose();
+  });
+
+  it('rotates via Body.setAngle, preserving angular velocity and actually rotating the vertices', () => {
+    const body = factory.createRigidBody(
+      { shape: { shape: 'BOX', dimensions: { x: 2, y: 1 } }, body: { bodyType: 'dynamic', mass: 1 } },
+      { position: { x: 0, y: 0 } },
+    );
+    body.addToWorld({ physicsWorld: world } as any);
+
+    body.rotation = Math.PI / 2;
+    world.simulate(60);
+
+    expect(body.rotation).toBeCloseTo(Math.PI / 2);
+    expect(body.angularVelocity).toBeCloseTo(0);
+
+    // A 2x1 box rotated 90 degrees should report swapped width/height bounds - proof the
+    // underlying vertices were actually rotated, not just the `.angle` field bumped.
+    const width = body.nativeBody.bounds.max.x - body.nativeBody.bounds.min.x;
+    const height = body.nativeBody.bounds.max.y - body.nativeBody.bounds.min.y;
+    expect(width).toBeCloseTo(1);
+    expect(height).toBeCloseTo(2);
+  });
+});

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

@@ -19,6 +19,100 @@ describe(`MatterTriggerComponent`, () => {
     world.dispose();
   });
 
+  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(`should detect object intersection`, async () => {
     const trigger = factory.createTrigger({ shape: 'BOX', dimensions: { x: 10, y: 10 } });