C#小球碰撞模拟问题求助：碰撞后消失及Verlet Integration咨询

问题回顾 #

我正在学习C#，制作类似Windows气泡屏保的小球弹跳模拟。目前实现了两个小球在屏幕内弹跳，但碰撞后小球会消失，调试发现碰撞后多数值变为无穷大，已废弃原有代码，需要更优的小球碰撞解决方案。后续计划扩展更多小球，同时希望了解Verlet Integration相关技术。

一、优化的小球碰撞解决方案 #

核心问题分析 #

之前的代码存在两个关键问题：

• 未封装小球数据，变量零散难以维护，扩展多球时极易出错
• 碰撞仅计算角度但未更新速度，且未处理小球重叠（重叠会导致距离为0，引发除法运算错误，进而产生无穷大数值）

解决方案步骤 #

1. 封装小球类

将小球的位置、速度、半径等属性封装为独立类，便于管理和扩展：

public class Ball
{
    public float X { get; set; }
    public float Y { get; set; }
    public float Vx { get; set; }
    public float Vy { get; set; }
    public float Radius { get; }
    public float Mass { get; }
    public Color Color { get; }

    public Ball(float x, float y, float vx, float vy, float radius, float mass, Color color)
    {
        X = x;
        Y = y;
        Vx = vx;
        Vy = vy;
        Radius = radius;
        Mass = mass;
        Color = color;
    }
}

2. 碰撞处理逻辑

实现弹性碰撞的完整物理计算，包含小球分离与速度更新：

private void HandleBallCollision(Ball a, Ball b)
{
    // 计算中心距离
    float dx = b.X - a.X;
    float dy = b.Y - a.Y;
    float distance = (float)Math.Sqrt(dx * dx + dy * dy);
    float minDistance = a.Radius + b.Radius;

    if (distance < minDistance)
    {
        // 1. 分离小球，避免重叠
        float overlap = minDistance - distance;
        float separationX = (dx / distance) * overlap * 0.5f;
        float separationY = (dy / distance) * overlap * 0.5f;

        a.X -= separationX;
        a.Y -= separationY;
        b.X += separationX;
        b.Y += separationY;

        // 重新计算分离后的距离
        dx = b.X - a.X;
        dy = b.Y - a.Y;
        distance = (float)Math.Sqrt(dx * dx + dy * dy);

        // 2. 计算法向量与切向量
        float nx = dx / distance;
        float ny = dy / distance;
        float tx = -ny;
        float ty = nx;

        // 3. 分解速度到法向和切向
        float v1n = a.Vx * nx + a.Vy * ny;
        float v1t = a.Vx * tx + a.Vy * ty;
        float v2n = b.Vx * nx + b.Vy * ny;
        float v2t = b.Vx * tx + b.Vy * ty;

        // 4. 弹性碰撞公式更新法向速度（假设恢复系数为1，完全弹性）
        float newV1n = ((a.Mass - b.Mass) * v1n + 2 * b.Mass * v2n) / (a.Mass + b.Mass);
        float newV2n = ((b.Mass - a.Mass) * v2n + 2 * a.Mass * v1n) / (a.Mass + b.Mass);

        // 5. 转换回原坐标系
        a.Vx = newV1n * nx + v1t * tx;
        a.Vy = newV1n * ny + v1t * ty;
        b.Vx = newV2n * nx + v2t * tx;
        b.Vy = newV2n * ny + v2t * ty;
    }
}

3. 墙壁碰撞处理

private void HandleWallCollision(Ball ball)
{
    // 左右墙壁
    if (ball.X - ball.Radius < 0)
    {
        ball.X = ball.Radius;
        ball.Vx = Math.Abs(ball.Vx);
    }
    else if (ball.X + ball.Radius > ClientSize.Width)
    {
        ball.X = ClientSize.Width - ball.Radius;
        ball.Vx = -Math.Abs(ball.Vx);
    }

    // 上下墙壁
    if (ball.Y - ball.Radius < 0)
    {
        ball.Y = ball.Radius;
        ball.Vy = Math.Abs(ball.Vy);
    }
    else if (ball.Y + ball.Radius > ClientSize.Height)
    {
        ball.Y = ClientSize.Height - ball.Radius;
        ball.Vy = -Math.Abs(ball.Vy);
    }
}

4. 完整主窗体代码

using System;
using System.Drawing;
using System.Windows.Forms;

public class Form1 : Form
{
    private Timer _refreshTimer;
    private Ball _ballA;
    private Ball _ballB;

    public Form1()
    {
        ClientSize = new Size(800, 600);
        Text = "小球弹跳模拟";

        // 初始化小球
        float radius = 25;
        _ballA = new Ball(radius, radius, 2, 2, radius, 1, Color.Blue);
        _ballB = new Ball(ClientSize.Width - radius, ClientSize.Height - radius, -2, -2, radius, 1, Color.Red);

        // 设置刷新定时器
        _refreshTimer = new Timer
        {
            Interval = 16 // ~60帧每秒
        };
        _refreshTimer.Tick += RefreshTimer_Tick;
        _refreshTimer.Start();
    }

    private void RefreshTimer_Tick(object sender, EventArgs e)
    {
        // 更新小球位置
        _ballA.X += _ballA.Vx;
        _ballA.Y += _ballA.Vy;
        _ballB.X += _ballB.Vx;
        _ballB.Y += _ballB.Vy;

        // 处理碰撞
        HandleWallCollision(_ballA);
        HandleWallCollision(_ballB);
        HandleBallCollision(_ballA, _ballB);

        Invalidate();
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
        Graphics g = e.Graphics;

        // 绘制小球
        using (Brush brush = new SolidBrush(_ballA.Color))
        {
            g.FillEllipse(brush, _ballA.X - _ballA.Radius, _ballA.Y - _ballA.Radius, _ballA.Radius * 2, _ballA.Radius * 2);
        }

        using (Brush brush = new SolidBrush(_ballB.Color))
        {
            g.FillEllipse(brush, _ballB.X - _ballB.Radius, _ballB.Y - _ballB.Radius, _ballB.Radius * 2, _ballB.Radius * 2);
        }
    }

    private void HandleBallCollision(Ball a, Ball b)
    {
        // 实现如上
    }

    private void HandleWallCollision(Ball ball)
    {
        // 实现如上
    }

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

public class Ball
{
    public float X { get; set; }
    public float Y { get; set; }
    public float Vx { get; set; }
    public float Vy { get; set; }
    public float Radius { get; }
    public float Mass { get; }
    public Color Color { get; }

    public Ball(float x, float y, float vx, float vy, float radius, float mass, Color color)
    {
        X = x;
        Y = y;
        Vx = vx;
        Vy = vy;
        Radius = radius;
        Mass = mass;
        Color = color;
    }
}

二、Verlet Integration 入门 #

什么是Verlet积分 #

Verlet积分是一种用于模拟物理运动的数值方法，相比传统的欧拉积分，它具有更高的稳定性，尤其适合多物体碰撞场景。核心特点是不需要显式存储速度，而是通过当前位置和上一帧位置来计算下一帧位置。

核心公式 #

x(t+Δt) = 2*x(t) - x(t-Δt) + a(t)*Δt²

其中：

• x(t)：当前帧位置
• x(t-Δt)：上一帧位置
• a(t)：当前加速度（重力、摩擦力等）
• Δt：时间步长

Verlet版本的小球类 #

public class VerletBall
{
    public float X { get; set; }
    public float Y { get; set; }
    public float OldX { get; set; }
    public float OldY { get; set; }
    public float Radius { get; }
    public float Mass { get; }
    public Color Color { get; }
    private readonly float _gravity = 0.1f; // 可选重力

    public VerletBall(float x, float y, float radius, float mass, Color color)
    {
        X = x;
        Y = y;
        OldX = x;
        OldY = y;
        Radius = radius;
        Mass = mass;
        Color = color;
    }

    public void Update(float deltaTime)
    {
        // 计算速度（位置差）
        float vx = X - OldX;
        float vy = Y - OldY;

        // 保存当前位置为旧位置
        OldX = X;
        OldY = Y;

        // 应用加速度（重力）
        vy += _gravity;

        // 更新位置
        X += vx;
        Y += vy;
    }
}

Verlet碰撞处理要点 #

Verlet的碰撞处理主要调整位置而非速度：

1. 检测碰撞后，计算分离位移
2. 调整两球的当前位置和旧位置，模拟碰撞后的反弹效果
3. 相比速度更新，Verlet的碰撞处理更直观，稳定性更强，适合大量小球的场景

扩展建议 #

• 用List<Ball>替代单个小球变量，轻松扩展多球模拟
• 添加恢复系数（0~1），控制碰撞的弹性程度
• 引入摩擦力、重力等额外物理效果
• 对于大量小球，使用空间分区算法（如网格划分）减少碰撞检测次数，提升性能

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