One-way collision detection strategy

[ewal]

Hi, I'm trying to find a good strategy on how to resolve one-way collisions within a Tiled object layer.
I have a solution working but every now and then the collision check fails and the main actor is allowed to pass through the colliding object actor.
Each object has a Fixed CollisionType by default on which I toggle the collisionType depending on the colliding side.
The event listeners is hooked up in the Scenes onInitialize hook. Example below...

// this === Scene
const oneWayActors = this.actors.filter(
  (actor) => actor.name === 'OneWay'
);

oneWayActors.forEach((actor) => {
  actor.on('precollision', (event) => {
    if (event.side === Side.Top) {
      event.target.body.collisionType = CollisionType.Fixed;
    } else {
      event.target.body.collisionType = CollisionType.Passive;
    }
  });
});

As stated, this works most of the times, but, if I stress the collider with enough events the actor will eventually fall through.
I'm trying to debug the problem but I'm rather suspecting that my strategy is faulty...

Any ideas? :)

[eonarheim]

@ewal I was thinking something similar as a solution!

I bet you might have more robust results if you used raycasting from the actor to the platform, then deciding it's collision type (or perhaps collision group?). For example if the actor is above the platform, a downward ray could detect that and make the platform collision fixed, but if the platform is above the downward ray would not be intersecting the platform and could be passive?

The latest alpha has arbitrary raycasting against a scene built in that might make this a bit easier to code (non-alpha you'll need keep a reference to all the colliders you intend to raycast against) #2410

I'll have some time later to try working out a sample 👍

[eonarheim]

Another idea might be to put an invisible collider above the platform to act like a sensor, if the player and the sensor are intersecting then the platform is solid?

[ewal]

Thank you for the reply. I will definitely look into raycasting and would very much appreciate an example. I've read about the concept but have real no experience working with it.

I actually use an invisible collider, about 1px in height.

[ewal]

I just did some more testing and noticed that the problem I experience also occurs on solid tile layers... I also noticed that I ran my logic in the onPreUpdate hook so I changed it to onPostUpdate but no change, maybe a bit worse actually. I'm reading about the hooks now but haven't really figured them out yet :)

[eonarheim]

@ewal I have something that works using a child actor as a sensor, it does take a little tuning depending on the size of your characters. I've highlighted the invisible sensor in purple.

We've been working on tuning up the platformer sample, I've added this example to that branch https://github.com/excaliburjs/sample-platformer/blob/presentation/src/one-way-platform.ts

I'll play around and see if I can get something with raycasting working soon.

import { Actor, ColliderComponent, CollisionType, Color, Engine, Entity, Shape, vec } from "excalibur";

export class OneWayPlatform extends Actor {
    private _sensor!: Entity;
    constructor(x: number, y: number, width: number, height: number) {
        super({
            x,
            y,
            width,
            height,
            color: Color.Red,
            collisionType: CollisionType.Passive
        });
    }

    onInitialize(_engine: Engine): void {
        this._sensor = new Actor({
            y: -20,
            collider: Shape.Box(this.width, 10, vec(0.5, 1))
        });

        const collider = this._sensor.get(ColliderComponent)!;
        this.addChild(this._sensor);
        collider.events.on('collisionstart', () => {
            this.body.collisionType = CollisionType.Fixed;
        });
        collider.events.on('collisionend', () => {
            this.body.collisionType = CollisionType.Passive;
        });
    }
}

[ewal]

Much appreciated! I will test working with a child actor.

I do however starting to suspect that the real problem is related to the movement controls. I will rethink them and perhaps create a new post about that subject.

[ewal]

@eonarheim, I'm starting to suspect that my problem is related to collision handling in the Tiled map. I stripped down a project to it's bare essentials in my hunt to locate the issue but I still experience it. The project is found here https://github.com/ewal/collision-demo if you would like to take a look. I added instructions in the Readme on how to recreate the collision issue.

[eonarheim]

Apologies, that's definitely unexpected. I'll take a closer look at the collision logic when I get a chance. I've been a bit busier than usual so I'll try to dig in this week.

Tinkering velocityIterations will improve resolution reactions theoretically, it might help? positionIterations will improve overlap resolution quality (useful for object stacking).

It's possible that with the discrete nature of the physics simulation we'll need to do raycasting to counter this. I should be able to reproduce with your example and come up with some raycasting sample code.

[ewal]

No stress at all, just thankful for the help 🙌

[ewal]

Noticed something interesting now. In certain x-coordinates the collision detection (right?) gets a weird flickering state. Could this explain the randomness that I'm experiencing?

Screencast.from.2023-03-03.09-07-55.webm

[eonarheim]

Hi @ewal

I think I have 3 possible solutions for you! I've tested these on your example and they seem to work okay (with some fiddling).

1. Turn up the number of physic steps every frame (I found that I couldn't reproduce the issue at 80 fps physics) the downside to this is that you'll be running more physics simulations every frame, but the collision fidelity should be much better.

   class Game extends Engine {
     constructor() {
       super({
         displayMode: DisplayMode.FitScreen,
         width: 40 * GameConfig.tileSize,
         height: 30 * GameConfig.tileSize,
         antialiasing: false,
         snapToPixel: false,
         canvasElementId: 'game',
         suppressConsoleBootMessage: true,
         suppressPlayButton: true,
         fixedUpdateFps: 80, // 80 fps physics 
       });
     }
     ...
   }

2. Clamp the player velocity to some maximum value, this seems to work pretty well? I'm actually thinking of making this type of thing a built feature of Excalibur, an optional speed limit on Actors. This needs some tuning to get right, but in this case it seems that a max of 450 pixels/sec made this issue hard to reproduce.

     override onPreUpdate(_engine: Engine, delta: number): void {
       ...
       // Clamp the magnitude of the velocity to prevent clipping
       this.vel.size = clamp(this.vel.size, 0, 450);
     }

3. Continuous collision with raycasting! Excalibur should probably have a setting to do this, but this seems like the most robust solution. This takes advantage of the latest alpha feature of arbitrary scene raycasting, so not available in v0.27 unfortunately. The gist is when the player starts moving fast enough to start causing problems for the discrete physics system we start raycasting into the scene to detect a point of impact, then move the player there.

     private snapPlayerPositionByRayCast(seconds: number) {
       // Pixel delta that we'll move this frame plus some extra
       const nextFramePositionDelta = this.vel.scale(seconds * 1.5).add(Physics.acc.scale(.5 * seconds * seconds));
   
       // this._dir = nextFramePositionDelta;
   
       // If we'll move more than half the hight of the collider we are at risk of clipping
       if (nextFramePositionDelta.size >= this.height / 2) {
   
         const dir = this.vel.normalize();
         const ray = new Ray(this.pos, dir);
   
         // Raycast to find any walls that we'll clip
         const hits = this.scene.physics.rayCast(ray, {
           maxDistance: nextFramePositionDelta.size,
           searchAllColliders: true
         });
   
         // Since we are casting from the center this will hit the player collider
         const otherColliders = hits.filter(hit => hit.collider != this.collider.get());
   
         // Any hit?
         if (otherColliders.length) {
           console.log('acc', this.acc);
           console.log('vel', this.vel);
           console.log('pos', this.pos);
           console.log('time', nextFramePositionDelta.size);
           console.log('hit', otherColliders[0].point);
   
           // snap the actor to the surface platform
           this.pos.y = otherColliders[0].point.y - this.height / 2;
           // negate acceleration
           this.vel.y = -Physics.acc.scale(.5 * seconds * seconds).y;
           return true;
         }
       }
       return false;
     }
   
     override onPreUpdate(_engine: Engine, delta: number): void {
       ...
       // if we don't snap player do the normal position update
       if (!this.snapPlayerPositionByRayCast(deltaTime)) {
         // Position
         this.pos.x += this.vel.x * deltaTime;
         this.pos.y += this.vel.y * deltaTime;
       }
   
       // "Jumping" (not really. Just moving up for demo purpose)
       if (InputState.getInstance().isHoldingJump) {
         this.vel.y = -(250 + Math.abs(this.vel.x) * 0.5);
       }
     }

Let me know if this helps, I can push up a fork of your repo too if that helps 👍

[ewal]

Just wow! Thank you so much @eonarheim 🙌 I will try the raycast example as soon as I can make time.