2D Platformer Multiple Body Collision Response

Question

I've been stuck for the past few days on implementing multiple body collision response, and I can't seem to find any good resource to help me advance.

Colliding between two objects is simple enough. What I have so far is this:

    public static void ResolveCollision(ref Vector3 aVelocity, float aMass,
                                        ref Vector3 bVelocity, float bMass)
    {
        var totalMass = aMass + bMass;
        var temp = (aMass / totalMass * aVelocity) + (bMass / totalMass * bVelocity);
        bVelocity = (bMass / totalMass * bVelocity) + (aMass / totalMass * aVelocity);
        aVelocity = temp;
    }

This works fine in resolving collisions individually between objects. The issue that I need to resolve is when two or more bodies are involved in the calculation. For example, pushing an object against a wall or pushing two objects next to each other in the same direction. The component missing in my code is summing up the masses of the objects involved so that the final displacement is believable.

I am hesitant to implement a solution that once resolving the collision between A and B, that B will go and test its movement and resolve collisions between B and C, and return a response back to A to adjust itself to account for any findings, because that could become messy and recursive.

I have also considered an "island" approach, where connecting bodies form an "island" that has a total mass which would be used when resolving collisions. However, this does not solve for the case of pushing an object against a wall, as I would omit walls and floors from being part of islands as their infinite mass would affect calculations of pushing objects vertially or horizontally respectively, if they are contributing their mass to the island.

Are either of my suggestions close to the mark, or what kind of pattern could I use to efficiently resolve collisions between multiple bodies?

Answer 1

I'm writing the answer for anyone interested, or who stumbles down the same path as me. Credit goes to DMGregory and Bennett Foddy.

The common solution present in many physics middlewares, is to just iterate the same list of collision pairs multiple times and only individually resolve collisions. The expected result is something that can be deemed as "good enough" in a performance critical environment.

Specifically to my question above, given objects sitting in a row: A -> B -> C, and applying a force to A

• A will resolve with B (and yes, only accounts for the mass of the two)
• B will resolve with C. B gets given a new velocity
• In a second iteration, A will resolve with B again which has a new velocity, pushing backwards on A

A pseudo-code example might look as follows:

while numIterations < desiredIterationCount
{
    foreach collisionPair in collisionList
    {
        resolve collision
        update position of each item in pair
    }
}