球与球之间的碰撞-检测和处理

我使用HTML Canvas元素在JavaScript中实现了这段代码，并以每秒60帧的速度产生了精美的模拟效果。我开始模拟时，随机放置了一打小球，并给它们赋予了随机速度。我发现，在更高的速度下，一个小球与一个大得多的球之间的擦碰会导致小球似乎“粘”在大球的边缘上，并沿着大球移动约90度后才分离。（我想知道是否还有其他人观察到了这种行为。）
一些计算的日志显示，在这些情况下，最小平移距离不足以防止相同的球在下一个时间步骤中发生碰撞。我进行了一些尝试，并发现可以通过根据相对速度来缩放MTD来解决这个问题：

dot_velocity = ball_1.velocity.dot(ball_2.velocity);
mtd_factor = 1. + 0.5 * Math.abs(dot_velocity * Math.sin(collision_angle));
mtd.multplyScalar(mtd_factor);

我核实了，在这个修复之前和之后，每次碰撞的总动能都得到了保留。在mtd_factor中的0.5值是经过多次测试后发现的最小值，可以确保球在碰撞后分离。

尽管这种修复引入了一定量的误差到系统的精确物理运算中，但它的优势在于现在非常快速的球可以在浏览器中模拟，而不需要降低时间步长。

改进检测圆与圆碰撞的解决方案，该方案在问题中给出：

float dx = circle1.x - circle2.x,
      dy = circle1.y - circle2.y,
       r = circle1.r + circle2.r;
return (dx * dx + dy * dy <= r * r);

它避免了不必要的“if和两个返回”，以及使用比必要更多的变量。

经过一些尝试，我使用了这篇文档中的方法来进行2D碰撞: https://www.vobarian.com/collisions/2dcollisions2.pdf (OP提供的链接)。
我在JavaScript程序中应用了这个方法，使用p5js，它完美地运行。我之前尝试过使用三角函数方程，虽然它们对于特定的碰撞是有效的，但我找不到一个适用于每种碰撞的解决方案，无论发生碰撞的角度如何。
这个文档中解释的方法根本不使用三角函数，只是普通的向量操作，我建议任何试图实现球与球碰撞的人使用这个方法，因为我个人的经验是三角函数很难概括。我曾经问过我学校的物理学家如何做到这一点，他告诉我不要费心去想三角函数，并向我展示了一种类似于文档中链接的方法。
注：我的质量都相等，但可以使用文档中提供的公式将其推广到不同的质量。
这是计算碰撞后速度向量的代码：

    //you just need a ball object with a speed and position vector.
    class TBall {
        constructor(x, y, vx, vy) {
            this.r = [x, y];
            this.v = [0, 0];
        }
    }

    //throw two balls into this function and it'll update their speed vectors
    //if they collide, you need to call this in your main loop for every pair of 
    //balls.
    function collision(ball1, ball2) {
        n = [ (ball1.r)[0] - (ball2.r)[0], (ball1.r)[1] - (ball2.r)[1] ];
        un = [n[0] /  vecNorm(n), n[1] / vecNorm(n) ] ;
        ut = [ -un[1], un[0] ];   
        v1n = dotProd(un, (ball1.v));
        v1t = dotProd(ut, (ball1.v) );
        v2n = dotProd(un, (ball2.v) );
        v2t = dotProd(ut, (ball2.v) );
        v1t_p = v1t; v2t_p = v2t;
        v1n_p = v2n; v2n_p = v1n;
        v1n_pvec = [v1n_p * un[0], v1n_p * un[1] ]; 
        v1t_pvec = [v1t_p * ut[0], v1t_p * ut[1] ]; 
        v2n_pvec = [v2n_p * un[0], v2n_p * un[1] ]; 
        v2t_pvec = [v2t_p * ut[0], v2t_p * ut[1] ];
        ball1.v = vecSum(v1n_pvec, v1t_pvec); ball2.v = vecSum(v2n_pvec, v2t_pvec);
    }

如果您有大量的球，我建议使用四叉树。为了决定反弹方向，只需根据碰撞法线使用简单的能量守恒公式即可。弹性、重量和速度会使其更加真实。

这里有一个简单的示例，支持大规模操作。

private void CollideBalls(Transform ball1, Transform ball2, ref Vector3 vel1, ref Vector3 vel2, float radius1, float radius2)
{
    var vec = ball1.position - ball2.position;
    float dis = vec.magnitude;
    if (dis < radius1 + radius2)
    {
        var n = vec.normalized;
        ReflectVelocity(ref vel1, ref vel2, ballMass1, ballMass2, n);

        var c = Vector3.Lerp(ball1.position, ball2.position, radius1 / (radius1 + radius2));
        ball1.position = c + (n * radius1);
        ball2.position = c - (n * radius2);
    }
}

public static void ReflectVelocity(ref Vector3 vel1, ref Vector3 vel2, float mass1, float mass2, Vector3 intersectionNormal)
{
    float velImpact1 = Vector3.Dot(vel1, intersectionNormal);
    float velImpact2 = Vector3.Dot(vel2, intersectionNormal);

    float totalMass = mass1 + mass2;
    float massTransfure1 = mass1 / totalMass;
    float massTransfure2 = mass2 / totalMass;

    vel1 += ((velImpact2 * massTransfure2) - (velImpact1 * massTransfure2)) * intersectionNormal;
    vel2 += ((velImpact1 * massTransfure1) - (velImpact2 * massTransfure1)) * intersectionNormal;
}