fix: [#3098] Make collision events consistent targets (#3238)

* fix: consistent events

* fix tests

* fix lint

* fix sandbox

* fix docs

* fix docs

CHANGELOG.md

@@ -7,6 +7,15 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Breaking Changes
 
+- Collision events now only target `ex.Collider` types, this previously would sometimes emit an `ex.Entity` if you attached to the `ex.ColliderComponent`
+  * `ex.PreCollisionEvent`
+  * `ex.PostCollisionEvent`
+  * `ex.ContactStartEvent`
+  * `ex.ContactEndEvent`
+  * `ex.CollisionPreSolveEvent`
+  * `ex.CollisionPostSolveEvent`
+  * `ex.CollisionStartEvent`
+  * `ex.CollisionEndEvent`
 - `System.priority` is refactored to be static.
 - `ex.Timer` now only takes the option bag constructor
 - `PreDrawEvent`, `PostDrawEvent`, `PreTransformDrawEvent`, `PostTransformDrawEvent`, `PreUpdateEvent`, `PostUpdateEvent` now use `elapsedMs` instead of `delta` for the elapsed milliseconds between the last frame.460696
@@ -118,6 +127,7 @@ are doing mtv adjustments during precollision.
 
 ### Fixed
 
+- Fixed issue where Collision events ahd inconsistent targets, sometimes they were Colliders and sometimes they were Entities
 - Fixed issue where `ex.Engine.screenshot()` images may not yet be loaded in time for use in `ex.Transition`s
 - Fixed issue where there would be an incorrect background color for 1 frame when transitioning to a new scene
 - Fixed issue where `blockInput: true` on scene transition only blocked input events, not accessors like `wasHeld(...)` etc.

sandbox/src/game.ts

@@ -664,7 +664,7 @@ player.on('collisionstart', () => {
 });
 
 player.on('collisionend', (e) => {
-  console.log('collision end', e.other.collider);
+  console.log('collision end', e.other);
 });
 
 // Health bar example
@@ -952,8 +952,8 @@ player.on('postcollision', (data: ex.PostCollisionEvent) => {
         game.input.keyboard.isHeld(ex.Keys.Down)
       )
     ) {
-      player.vel.x = data.other.vel.x;
-      player.vel.y = data.other.vel.y;
+      player.vel.x = data.other.owner.vel.x;
+      player.vel.y = data.other.owner.vel.y;
     }
 
     if (!data.other) {
@@ -964,7 +964,7 @@ player.on('postcollision', (data: ex.PostCollisionEvent) => {
 
   if (data.side === ex.Side.Top) {
     if (data.other) {
-      player.vel.y = data.other.vel.y - player.vel.y;
+      player.vel.y = data.other.owner.vel.y - player.vel.y;
     } else {
       player.vel.y = 0;
     }

sandbox/tests/collision/touching.ts

@@ -19,7 +19,7 @@ ball.on('collisionstart', (evt: ex.CollisionStartEvent) => {
 
 ball.on('collisionend', (evt: ex.CollisionEndEvent) => {
   console.log('Ball was being touched on frame:', game.stats.currFrame.id);
-  evt.actor.vel = ex.vec(0, -speed);
+  evt.self.owner.vel = ex.vec(0, -speed);
 });
 ball.on('postupdate', function () {
   if (ball.pos.y < 0) {

sandbox/tests/high-gravity-arcade/index.ts

@@ -40,16 +40,16 @@ class TouchingComponent extends ex.Component {
     this.origin = new ex.Vector(owner.pos.x, owner.pos.y);
     // collect up all of the collisionstart/end events for each frame
     owner.on('collisionstart', (ev) => {
-      if (ev.other.collider) {
+      if (ev.other) {
         // console.log(ev.contact.colliderA.worldPos, ev.contact.colliderB.worldPos)
-        if (ev.other.body?.collisionType === ex.CollisionType.Passive) {
-          this.passives.add(ev.other);
+        if (ev.other.owner.body?.collisionType === ex.CollisionType.Passive) {
+          this.passives.add(ev.other.owner);
         } else {
           const side = ev.side;
 
           this.contacts.set(ev.contact.id, {
             contact: ev.contact,
-            actor: ev.other,
+            actor: ev.other.owner,
             side
           });
           this.updateSides();
@@ -58,8 +58,8 @@ class TouchingComponent extends ex.Component {
     });
 
     owner.on('collisionend', (ev) => {
-      if (ev.other.body?.collisionType === ex.CollisionType.Passive) {
-        this.passives.delete(ev.other);
+      if (ev.other.owner.body?.collisionType === ex.CollisionType.Passive) {
+        this.passives.delete(ev.other.owner);
       } else {
         this.contacts.delete(ev.lastContact.id);
         this.updateSides();

site/docs/00-your-first-game.mdx

@@ -304,15 +304,15 @@ declare const game: ex.Engine;
 declare const ball: ex.Actor;
 declare const ballSpeed: ex.Vector;
 declare type Actor = any;
-declare const bricks: ex.Actor[];
+declare const bricks: ex.Entity[];
 // ---cut---
 // On collision remove the brick, bounce the ball
 let colliding = false;
 ball.on("collisionstart", function (ev) {
-  if (bricks.indexOf(ev.other) > -1) {
+  if (bricks.indexOf(ev.other.owner) > -1) {
     // kill removes an actor from the current scene
     // therefore it will no longer be drawn or updated
-    ev.other.kill();
+    ev.other.owner.kill();
   }
 
   // reverse course after any collision
@@ -349,7 +349,7 @@ declare const game: ex.Engine;
 declare const ball: ex.Actor;
 declare const ballSpeed: ex.Vector;
 declare type Actor = any;
-declare const bricks: ex.Actor[];
+declare const bricks: ex.Entity[];
 // ---cut---
 // Loss condition
 ball.on("exitviewport", () => {

src/engine/Collision/ColliderComponent.ts

@@ -157,46 +157,40 @@ export class ColliderComponent extends Component {
       const precollision = evt as PreCollisionEvent<Collider>;
       entity.events.emit(
         'precollision',
-        new PreCollisionEvent(
-          precollision.target.owner,
-          precollision.other.owner,
-          precollision.side,
-          precollision.intersection,
-          precollision.contact
-        )
+        new PreCollisionEvent(precollision.self, precollision.other, precollision.side, precollision.intersection, precollision.contact)
       );
       if (entity instanceof Actor) {
-        entity.onPreCollisionResolve(precollision.target, precollision.other, precollision.side, precollision.contact);
+        entity.onPreCollisionResolve(precollision.self, precollision.other, precollision.side, precollision.contact);
       }
     });
     this.events.on('postcollision', (evt: any) => {
       const postcollision = evt as PostCollisionEvent<Collider>;
       entity.events.emit(
         'postcollision',
         new PostCollisionEvent(
-          postcollision.target.owner,
-          postcollision.other.owner,
+          postcollision.self,
+          postcollision.other,
           postcollision.side,
           postcollision.intersection,
           postcollision.contact
         )
       );
       if (entity instanceof Actor) {
-        entity.onPostCollisionResolve(postcollision.target, postcollision.other, postcollision.side, postcollision.contact);
+        entity.onPostCollisionResolve(postcollision.self, postcollision.other, postcollision.side, postcollision.contact);
       }
     });
     this.events.on('collisionstart', (evt: any) => {
       const start = evt as CollisionStartEvent<Collider>;
-      entity.events.emit('collisionstart', new CollisionStartEvent(start.target.owner, start.other.owner, start.side, start.contact));
+      entity.events.emit('collisionstart', new CollisionStartEvent(start.self, start.other, start.side, start.contact));
       if (entity instanceof Actor) {
-        entity.onCollisionStart(start.target, start.other, start.side, start.contact);
+        entity.onCollisionStart(start.self, start.other, start.side, start.contact);
       }
     });
     this.events.on('collisionend', (evt: any) => {
       const end = evt as CollisionEndEvent<Collider>;
-      entity.events.emit('collisionend', new CollisionEndEvent(end.target.owner, end.other.owner, end.side, end.lastContact));
+      entity.events.emit('collisionend', new CollisionEndEvent(end.self, end.other, end.side, end.lastContact));
       if (entity instanceof Actor) {
-        entity.onCollisionEnd(end.target, end.other, end.side, end.lastContact);
+        entity.onCollisionEnd(end.self, end.other, end.side, end.lastContact);
       }
     });
   }