ProcessingJS重力模拟中自由球体法向力计算方法咨询

嘿，这个球体穿透的问题在2D物理模拟里真的是个高频坑，我来给你捋捋靠谱的解决办法，不管是两个球还是一堆球的情况都能用：

不管是两个还是多个球体，核心思路都是先修正速度阻止继续穿透，再把已经重叠的球分开，用瞬间冲量而不是持续力，这样能避免你之前遇到的振荡或无效问题。

第一步：两个球体的碰撞/穿透处理 #

先从最简单的两球情况入手，这是多球处理的基础：

1. 检测穿透：计算两球中心距离，对比半径之和。如果距离小于半径和，说明已经穿透了：

   PVector delta = PVector.sub(ball2.pos, ball1.pos);
   float dist = delta.mag();
   float minDist = ball1.radius + ball2.radius;
   if (dist < minDist) {
       // 进入修正逻辑
   }
   

2. 计算分离法向量：得到从一个球指向另一个球的单位方向向量，这是修正的基准方向：

   PVector normal = delta.copy();
   normal.normalize();
   

3. 用冲量修正速度：冲量是瞬间改变速度的量，能直接阻止球体继续向对方移动。这里要考虑质量和恢复系数（控制碰撞弹性）：

   • 先计算相对速度在法向量上的分量：如果这个分量是正的，说明两球已经在分开，不用处理
   • 再计算冲量大小，最后把冲量分配给两个球（质量小的球速度变化更大）

   PVector relVel = PVector.sub(ball2.vel, ball1.vel);
   float velAlongNormal = PVector.dot(relVel, normal);
   
   // 已经在分离，跳过
   if (velAlongNormal > 0) continue;
   
   // 恢复系数：0=完全非弹性碰撞，1=完全弹性，可调成0.5-0.8体验好
   float restitution = 0.7;
   // 计算冲量大小
   float j = -(1 + restitution) * velAlongNormal;
   j /= (1/ball1.mass + 1/ball2.mass);
   
   // 把冲量应用到速度上
   PVector impulse = PVector.mult(normal, j);
   ball1.vel.add(PVector.div(impulse, ball1.mass));
   ball2.vel.sub(PVector.div(impulse, ball2.mass));
   

4. 位置修正（关键！）：光改速度不够，因为已经穿透的部分得立刻分开。这里按质量反比分配重叠量，避免大球把小球“推着走”：

   float overlap = minDist - dist;
   float massRatio1 = ball2.mass / (ball1.mass + ball2.mass);
   float massRatio2 = ball1.mass / (ball1.mass + ball2.mass);
   
   // 把两个球沿法向量方向推开
   ball1.pos.sub(PVector.mult(normal, overlap * massRatio1));
   ball2.pos.add(PVector.mult(normal, overlap * massRatio2));
   

第二步：多球体的批量处理 #

多个球的情况其实就是两两遍历检测，对每一对穿透的球都执行上面的修正逻辑：

• 用双重循环遍历所有球对，注意i从0到n-1，j从i+1到n-1，这样每对球只处理一次，避免重复计算
• 如果球体数量很多（比如几十上百个），可以加个网格空间划分，只检测同一网格或相邻网格的球，减少计算量，但先保证正确性再优化效率

为什么你之前的方法没奏效？ #

• 用持续力修正穿透：力是逐帧施加的，很容易导致过冲或振荡（比如刚推开一点，下一帧引力又拉回来，反复横跳），而冲量是瞬间修正，更适合解决已经发生的穿透
• 按相对速度缩放的力无效：大概率是没考虑质量的影响，或者没同步修正位置——速度改了但球还卡在一起，下一帧继续触发穿透，进入恶性循环

把这些逻辑放进你的draw()循环里，替换你原来的碰撞处理：

ArrayList<Ball> balls = new ArrayList<Ball>();

void draw() {
  background(0);
  
  // 先更新所有球的引力运动（你的原有逻辑）
  for (Ball b : balls) {
    b.applyGravity(balls);
    b.update();
    b.display();
  }
  
  // 处理碰撞/穿透修正
  for (int i = 0; i < balls.size(); i++) {
    Ball b1 = balls.get(i);
    for (int j = i + 1; j < balls.size(); j++) {
      Ball b2 = balls.get(j);
      PVector delta = PVector.sub(b2.pos, b1.pos);
      float dist = delta.mag();
      float minDist = b1.r + b2.r;
      
      if (dist < minDist) {
        // 计算法向量
        PVector normal = delta.copy();
        normal.normalize();
        
        // 计算相对速度
        PVector relVel = PVector.sub(b2.vel, b1.vel);
        float velAlongNormal = PVector.dot(relVel, normal);
        
        // 已经在分离，跳过
        if (velAlongNormal > 0) continue;
        
        // 恢复系数
        float restitution = 0.7;
        // 冲量计算
        float jImpulse = -(1 + restitution) * velAlongNormal;
        jImpulse /= (1/b1.mass + 1/b2.mass);
        
        // 应用冲量到速度
        PVector impulse = PVector.mult(normal, jImpulse);
        b1.vel.add(PVector.div(impulse, b1.mass));
        b2.vel.sub(PVector.div(impulse, b2.mass));
        
        // 位置修正
        float overlap = minDist - dist;
        float massRatio1 = b2.mass / (b1.mass + b2.mass);
        float massRatio2 = b1.mass / (b1.mass + b2.mass);
        b1.pos.sub(PVector.mult(normal, overlap * massRatio1));
        b2.pos.add(PVector.mult(normal, overlap * massRatio2));
      }
    }
  }
}

// 你的Ball类示例
class Ball {
  PVector pos, vel, acc;
  float r, mass;
  
  Ball(float x, float y, float r, float mass) {
    pos = new PVector(x, y);
    vel = new PVector(0, 0);
    acc = new PVector(0, 0);
    this.r = r;
    this.mass = mass;
  }
  
  void applyGravity(ArrayList<Ball> others) {
    // 你的引力计算逻辑
    for (Ball other : others) {
      if (other != this) {
        PVector force = PVector.sub(other.pos, pos);
        float dist = force.mag();
        dist = constrain(dist, 5, 25);
        float strength = (mass * other.mass) / (dist * dist);
        force.setMag(strength);
        acc.add(force);
      }
    }
  }
  
  void update() {
    vel.add(acc);
    pos.add(vel);
    acc.mult(0);
    // 边界检测（可选）
    if (pos.x < r) pos.x = r;
    if (pos.x > width - r) pos.x = width - r;
    if (pos.y < r) pos.y = r;
    if (pos.y > height - r) pos.y = height - r;
  }
  
  void display() {
    fill(255, 100);
    stroke(255);
    ellipse(pos.x, pos.y, r*2, r*2);
  }
}

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