为何Pygame球体物理模拟中存在不稳定抖动问题？

抖动的核心原因有三个：角度与弧度混用导致碰撞修正方向错误、碰撞仅修正位置未调整速度、碰撞检测循环逻辑缺陷。以下是针对性修复：

1. 修复角度/弧度混淆 #

原pointat函数混用角度值（如-90、90）和弧度值（math.atan返回结果），而math.sin/math.cos仅接受弧度参数，导致碰撞修正方向完全错误，引发抖动。替换为更可靠的方向计算方式：

# 移除原pointat函数，改用math.atan2直接计算碰撞法线方向

2. 碰撞响应：同时修正位置与速度 #

当前仅调整物体位置，未更新速度，导致物体下一帧仍以原速度撞回碰撞区域，反复触发修正形成抖动。需要在碰撞后调整速度：

球体间碰撞修正 #

if dist < r*2 and dist > 0:  # 避免除以0
    # 计算碰撞法线方向
    nx = (x[a] - x[i]) / dist
    ny = (y[a] - y[i]) / dist
    # 计算重叠量并修正位置
    overlap = r*2 - dist
    x[i] -= nx * overlap * 0.5
    y[i] -= ny * overlap * 0.5
    x[a] += nx * overlap * 0.5
    y[a] += ny * overlap * 0.5
    
    # 交换速度的法线分量（模拟弹性碰撞）
    dot_i = xv[i] * nx + yv[i] * ny
    dot_a = xv[a] * nx + yv[a] * ny
    
    xv[i] += (dot_a - dot_i) * nx
    yv[i] += (dot_a - dot_i) * ny
    xv[a] += (dot_i - dot_a) * nx
    yv[a] += (dot_i - dot_a) * ny

边界碰撞修正 #

dist = math.hypot(x[i], y[i])
if dist > size - r:
    # 计算边界法线方向
    nx = x[i] / dist
    ny = y[i] / dist
    # 修正位置到边界内
    x[i] = nx * (size - r)
    y[i] = ny * (size - r)
    # 反转径向速度（弹性碰撞）
    dot_product = xv[i] * nx + yv[i] * ny
    xv[i] -= 2 * dot_product * nx
    yv[i] -= 2 * dot_product * ny

3. 修复碰撞检测循环逻辑 #

原代码中for k in range(len(x)-1)+a +=1的逻辑会跳过最后一个球体，且容易出错。改为只处理当前球体之后的对象，避免重复计算：

# 替换原碰撞循环
for a in range(i+1, len(x)):
    dist = math.hypot(x[i]-x[a], y[i]-y[a])
    # 球体间碰撞处理代码...

4. 优化子步与速度更新逻辑 #

原代码在子步结束后直接用位置差计算速度，忽略了子步内碰撞对位置的修正，导致速度计算不准确。改为子步内先更新速度再处理位置：

for j in range(sub):
    # 重力更新
    yv[i] -= 1 / sub
    # 位置更新
    x[i] += xv[i] / sub
    y[i] += yv[i] / sub
    
    # 边界碰撞处理
    # ...（上述边界碰撞代码）
    
    # 球体间碰撞处理
    # ...（上述球体间碰撞代码）

完整修复代码 #

import pygame
import math
import random

screen = pygame.display.set_mode((16*120,9*120))
pygame.display.set_caption('')
clock = pygame.time.Clock()

mx = 16*60
my = 9*60

x = []
y = []
xv = []
yv = []

for i in range(20):
    x.append(random.randint(-200,200))
    y.append(random.randint(-200,200))
    xv.append(random.uniform(-5,5))  # 初始小速度，避免初始碰撞扎堆
    yv.append(random.uniform(-5,5))

r = 25
size = 300

sub = 20
maxvel = 20

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()
    screen.fill((10,10,10))
    pygame.draw.circle(screen,(100,100,100),(mx,my),size)
    for i in range(len(x)):
        pygame.draw.circle(screen,(255,255,255),(mx+x[i],my-y[i]),r)  # 保持原y轴反转逻辑

    for i in range(len(x)):
        for j in range(sub):
            # 重力更新
            yv[i] -= 1 / sub
            # 位置更新
            x[i] += xv[i] / sub
            y[i] += yv[i] / sub
            
            # 边界碰撞处理
            dist = math.hypot(x[i], y[i])
            if dist > size - r:
                nx = x[i] / dist
                ny = y[i] / dist
                x[i] = nx * (size - r)
                y[i] = ny * (size - r)
                dot_product = xv[i] * nx + yv[i] * ny
                xv[i] -= 2 * dot_product * nx
                yv[i] -= 2 * dot_product * ny
            
            # 球体间碰撞处理
            for a in range(i+1, len(x)):
                dist = math.hypot(x[i]-x[a], y[i]-y[a])
                if dist < r*2 and dist > 0:
                    nx = (x[a] - x[i]) / dist
                    ny = (y[a] - y[i]) / dist
                    overlap = r*2 - dist
                    x[i] -= nx * overlap * 0.5
                    y[i] -= ny * overlap * 0.5
                    x[a] += nx * overlap * 0.5
                    y[a] += ny * overlap * 0.5
                    
                    dot_i = xv[i] * nx + yv[i] * ny
                    dot_a = xv[a] * nx + yv[a] * ny
                    
                    xv[i] += (dot_a - dot_i) * nx
                    yv[i] += (dot_a - dot_i) * ny
                    xv[a] += (dot_i - dot_a) * nx
                    yv[a] += (dot_i - dot_a) * ny
        
        # 速度限制（用矢量缩放更合理）
        speed = math.hypot(xv[i], yv[i])
        if speed > maxvel:
            scale = maxvel / speed
            xv[i] *= scale
            yv[i] *= scale

    pygame.display.update()
    clock.tick(60)

关键修复点总结 #

• 用math.hypot和math.atan2替代手动角度计算，彻底解决方向错误
• 碰撞时同时修正位置和速度，避免物体反复撞入碰撞区域
• 优化碰撞循环，避免重复处理和索引错误
• 子步内先更新速度再处理位置，逻辑更符合物理规律

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