How can I solve this SAT direct corner intersection edge case?

Question

I have a working SAT implementation, but I am running into a problem where direct collisions at a corner do not work for tiled surfaces. That is, it clips on the surface when going in a certain direction because it gets hung up on one of the tiles, and so, for example, if I walk across a floor while holding both down and left, the player will stop when meeting the next shape because the player will be colliding with the right side rather than with the top of the floor tile.

This illustration shows what I mean:

The top block will translate right first and then up.

I have checked here and here which are helpful, but this does not address what I should do in a situation where I don't have a tile-based world. My usage of the term "tile" before isn't really accurate since what I'm doing here is manually placing square obstacles next to each other, not assigning them spots on a grid.

What can I do to fix this?

Answer 1

OK, I've found an answer to my own question, however I'm not sure that it's the best answer. Basically the problem was in the order that the axes were checked which resulted in the hangup happening in some directions but not others.

So to resolve this I simply do the check one more time in reverse order. I was previously doing this recursively but not reversing the list. Here's the "working" code:

private void ResolvePlayer()
{
    List<ICollidable> reverse = obstacles;
    reverse.Reverse();

    foreach (CollidableRectangle obstacle in obstacles)
    {
        if (obstacle.ResolveCollision(player.Bounds) && obstacle.GetMTV() != Vector2.Zero)
        {
            player.Move(-obstacle.GetMTV());
            //ResolvePlayer();
            break;
        }
    }

    foreach (CollidableRectangle obstacle in reverse)
    {
        if (obstacle.ResolveCollision(player.Bounds) && obstacle.GetMTV() != Vector2.Zero)
        {
            player.Move(-obstacle.GetMTV());
            //ResolvePlayer();
            break;
        }
    }
}

Answer 2

After tinkering with this for a while, I've found a solution that works. Or rather, it works to solve this particular problem, and I don't know yet what other issues it causes. But at least for now it works perfectly.

To solve it I just iterated through each of the possible collisions, checked the translation against the others, and kept the vector with the greatest magnitude, or the successful resolution that resulted in the greatest distance.

private void ResolvePlayer()
{
    List<Vector2> possibleResolutions = new List<Vector2>();

    foreach (CollidableRectangle obstacle in obstacles)
    {
        if (obstacle.IsColliding(player.Bounds) && obstacle.GetMTV() != Vector2.Zero)
        {
            //player.Move(-obstacle.GetMTV());
            possibleResolutions.Add(-obstacle.GetMTV());
        }
    }

    Vector2 finalOffset = Vector2.Zero;
    float maxDistance = 0;
    foreach (Vector2 offset in possibleResolutions)
    {
        float thisDistance = Vector2.Distance(player.Position, player.Position + offset);
        if (thisDistance > maxDistance)
        {
            maxDistance = thisDistance;
            finalOffset = offset;
        }
    }

    player.Move(finalOffset);
}

This is what my resolution method looks like at the moment. I had a recursive call to handle jittering in corners but that gave me a stack overflow when testing against certain rotations, so for now I'm just resolving it twice. Fixing that bug shouldn't be too hard, though, and it can be possible to make it into one elegant method that handles everything.