重力粒子模拟中粒子碰撞速度交换错误、出现聚集该如何解决？

错误原因 #

你当前的代码存在4个核心问题，直接导致粒子碰撞后聚集：

• 碰撞处理逻辑完全不符合物理规则：resolve_collision函数检测到碰撞后，仅将粒子2的速度赋值给粒子1，完全没有修改粒子2的速度，最终两个粒子会获得相同的速度同向运动，自然粘连在一起。哪怕是同质量弹性碰撞需要交换速度，也需要同步修改两个粒子的速度属性。
• 代码缩进错误导致碰撞检测执行时机异常：你写的遍历其他粒子的for循环不在update方法内部，碰撞逻辑不会随每帧粒子更新执行，甚至会出现不可预期的执行结果。
• 没有处理粒子重叠问题：如果两帧间隔内粒子已经穿入对方内部，仅交换速度会导致下一帧仍然检测到碰撞，反复交换速度最终会让粒子卡住无法分离。
• 直接交换全量速度不符合二维碰撞规则：同质量二维弹性碰撞仅需要交换碰撞法线方向的速度分量，切向速度分量保持不变，直接交换xy方向的全部速度，斜向碰撞时会出现完全不符合物理规律的运动表现。

修复方案 #

1. 重写碰撞处理函数 #

实现同质量二维弹性碰撞逻辑，同时增加重叠修正避免粒子穿模卡死：

def resolve_collision(p1, p2):
    # 计算两粒子中心连线的向量
    dx = p2.x - p1.x
    dy = p2.y - p1.y
    distance = (dx ** 2 + dy ** 2) ** 0.5
    # 未发生碰撞直接返回
    if distance >= p1.radius + p2.radius:
        return
    # 计算重叠长度，沿法线方向推开两个粒子避免重叠
    overlap = (p1.radius + p2.radius - distance) / 2
    # 法线方向单位向量
    nx = dx / distance
    ny = dy / distance
    p1.x -= overlap * nx
    p1.y -= overlap * ny
    p2.x += overlap * nx
    p2.y += overlap * ny
    # 计算两个粒子在法线方向的速度分量
    v1_normal = p1.velocity[0] * nx + p1.velocity[1] * ny
    v2_normal = p2.velocity[0] * nx + p2.velocity[1] * ny
    # 同质量弹性碰撞直接交换法线方向速度分量，切向分量保持不变
    p1.velocity[0] += (v2_normal - v1_normal) * nx
    p1.velocity[1] += (v2_normal - v1_normal) * ny
    p2.velocity[0] += (v1_normal - v2_normal) * nx
    p2.velocity[1] += (v1_normal - v2_normal) * ny

2. 修正Particle类的代码结构 #

调整缩进把碰撞逻辑放到update方法内，调整执行顺序先处理碰撞再更新位置，同时墙面碰撞也增加位置修正避免卡死：

class Particle():
    def __init__(self, x, y, dx, dy, radius, color):
        self.x = x
        self.y = y
        self.velocity = [dx, dy]
        self.radius = radius
        self.color = color
    def update(self, particles, width, height):
        # 处理墙面碰撞，同时修正位置避免穿入边界
        if self.y - self.radius < 0:
            self.y = self.radius
            self.velocity[1] = -abs(self.velocity[1])
        if self.y + self.radius > height:
            self.y = height - self.radius
            self.velocity[1] = -abs(self.velocity[1])
        if self.x - self.radius < 0:
            self.x = self.radius
            self.velocity[0] = -abs(self.velocity[0])
        if self.x + self.radius > width:
            self.x = width - self.radius
            self.velocity[0] = -abs(self.velocity[0])
        # 处理粒子间碰撞
        for p in particles:
            if p is not self:
                resolve_collision(self, p)
        # 最后更新粒子位置
        self.x += self.velocity[0]
        self.y += self.velocity[1]

3. 可选性能优化 #

如果粒子数量较多，可以把粒子碰撞的遍历逻辑放到全局，双层循环只遍历每对粒子一次，避免重复处理同一对粒子，性能提升明显：

# 全局每帧更新逻辑示例
def update_all_particles(particles, width, height):
    # 先处理所有粒子碰撞
    for i in range(len(particles)):
        p1 = particles[i]
        for j in range(i+1, len(particles)):
            p2 = particles[j]
            resolve_collision(p1, p2)
    # 再处理每个粒子的边界碰撞和位置更新
    for p in particles:
        if p.y - p.radius < 0:
            p.y = p.radius
            p.velocity[1] = -abs(p.velocity[1])
        if p.y + p.radius > height:
            p.y = height - p.radius
            p.velocity[1] = -abs(p.velocity[1])
        if p.x - p.radius < 0:
            p.x = p.radius
            p.velocity[0] = -abs(p.velocity[0])
        if p.x + p.radius > width:
            p.x = width - p.radius
            p.velocity[0] = -abs(p.velocity[0])
        p.x += p.velocity[0]
        p.y += p.velocity[1]

内容的提问来源于stack exchange，提问作者bhatck