1

我有一个模拟，多个圆圈在 2D 空间中移动，它们之间有弹性碰撞。

我想在粒子之间添加吸引力，以便粒子根据质量等向其他粒子移动。我该怎么做？

我的碰撞管理功能如下所示：

void manageCollision(Particle particleA, Particle particleB)
{
    float distanceX = particleA.Position.X - particleB.Position.X;
    float distanceY = particleA.Position.Y - particleB.Position.Y;
    double collisionAngle = Math.Atan2(distanceY, distanceX);
    double pA_magnitude = Math.Sqrt(particleA.Velocity.X * particleA.Velocity.X + particleA.Velocity.Y * particleA.Velocity.Y);
    double pB_magnitude = Math.Sqrt(particleB.Velocity.X * particleB.Velocity.X + particleB.Velocity.Y * particleB.Velocity.Y);
    double pA_direction = Math.Atan2(particleA.Velocity.Y, particleA.Velocity.X);
    double pB_direction = Math.Atan2(particleB.Velocity.Y, particleB.Velocity.X);
    double pA_newVelocityX = pA_magnitude * Math.Cos(pA_direction - collisionAngle);
    double pA_newVelocityY = pA_magnitude * Math.Sin(pA_direction - collisionAngle);
    double pB_newVelocityX = pB_magnitude * Math.Cos(pB_direction - collisionAngle);
    double pB_newVelocityY = pB_magnitude * Math.Sin(pB_direction - collisionAngle);
    double pA_finalVelocityX = ((particleA.Mass - particleB.Mass) * pA_newVelocityX + (particleB.Mass + particleB.Mass) * pB_newVelocityX) / (particleA.Mass + particleB.Mass);
    double pB_finalVelocityX = ((particleA.Mass + particleA.Mass) * pA_newVelocityX + (particleB.Mass - particleA.Mass) * pB_newVelocityX) / (particleA.Mass + particleB.Mass);
    double pA_finalVelocityY = pA_newVelocityY;
    double pB_finalVelocityY = pB_newVelocityY;
    particleA.Velocity = new Vector2((float)(Math.Cos(collisionAngle) * pA_finalVelocityX + Math.Cos(collisionAngle + Math.PI / 2) * pA_finalVelocityY), (float)(Math.Sin(collisionAngle) * pA_finalVelocityX + Math.Sin(collisionAngle + Math.PI / 2) * pA_finalVelocityY));
    particleB.Velocity = new Vector2((float)(Math.Cos(collisionAngle) * pB_finalVelocityX + Math.Cos(collisionAngle + Math.PI / 2) * pB_finalVelocityY), (float)(Math.Sin(collisionAngle) * pB_finalVelocityX + Math.Sin(collisionAngle + Math.PI / 2) * pB_finalVelocityY));
}

每个球或粒子以随机的质量和半径生成。

该函数在更新类型的方法中调用，如下所示：

Vector2 globalGravity = new Vector2(0f, gravityScale / 6000);

    for (int i = 0; i < particles.Count(); i++)
{
    particles[i].Update((float)updateTimer.Interval, globalGravity);
    Vector2 position = particles[i].Position;
    Vector2 velocity = particles[i].Velocity;
    collisionWallCheck(ref position, ref velocity, particles[i].Radius);
    particles[i].Position = position;
    particles[i].Velocity = velocity;


    Particle pA = particles[i];
    for (int k = i + 1; k < particles.Count(); k++)
    {
        Particle pB = particles[k];
        Vector2 delta = pA.Position - pB.Position;
        float dist = delta.Length();

        if (dist < particles[i].Radius + particles[k].Radius && !particles[i].Colliding && !particles[k].Colliding)
        {
            particles[i].Colliding = true;
            particles[k].Colliding = true;
            manageCollision(particles[i], particles[k]);
            particles[i].initColorTable(); // Upon collision, change the color
            particles[k].initColorTable();
            totalCollisions++;
        }
        else
        {
            particles[i].Colliding = false;
            particles[k].Colliding = false;
        }
    }
}

我正在存储每个球的初始位置、速度和质量。

我显然需要做但不知道如何实施的是：

  • 计算重力的大小和方向。
  • 知道了力，就可以计算出每个物体的加速度。
  • 知道加速度，您可以计算出新的速度。
  • 知道速度，您可以计算新位置。

我基本上对它的方程式感到不安，我想从只在两个球之间产生吸引力开始。

使用 Steven 的建议，这是新的集成代码。

void updateTimer_Tick(object sender, EventArgs e)
{
    const double G = 6.67398 * 0.00000000001;

    for (int i = 0; i < particles.Count(); i++)
    {
        double sumX = 0;
        double sumY = 0;

        Particle pA = particles[i];
        for (int k = i + 1; k < particles.Count(); k++)
        {
            Particle pB = particles[k];
            Vector2 delta = pA.Position - pB.Position;
            float dist = delta.Length();

            if (dist < particles[i].Radius + particles[k].Radius && !particles[i].Colliding && !particles[k].Colliding)
            {
                particles[i].Colliding = true;
                particles[k].Colliding = true;
                manageCollision(particles[i], particles[k]);
                particles[i].initColorTable();
                particles[k].initColorTable();
                totalCollisions++;
                particles[i].Colliding = false;
                particles[k].Colliding = false;
            }
            else
            {
                double distanceX = particles[i].Position.X - particles[k].Position.X;
                double distanceY = particles[i].Position.Y - particles[k].Position.Y;
                double r = Math.Sqrt(Math.Pow(distanceX, 2) + Math.Pow(distanceY, 2));
                double force = G * particles[i].Mass * particles[k].Mass / (r * r);
                double theta = Math.Tan(distanceY / distanceX);
                sumX += force * Math.Cos(theta);
                sumY += force * Math.Sin(theta);
                particles[i].Colliding = false;
                particles[k].Colliding = false;
            }
        }
        double netForce = Math.Sqrt(Math.Pow(sumX, 2) + Math.Pow(sumY, 2));
        double a = netForce / particles[i].Mass;
        double aTheta = Math.Tan(sumY / sumX);

        // Here we get accelerations for X and Y.  You can probably figure out velocities from here.
        double aX = a * Math.Cos(aTheta);
        double aY = a * Math.Sin(aTheta);
        Vector2 accel = new Vector2((float)aX, (float)aY);

        particles[i].Update((float)updateTimer.Interval, accel);
        //particles[i].Update((float)updateTimer.Interval, globalGravity);
        Vector2 position = particles[i].Position;
        Vector2 velocity = particles[i].Velocity;
        collisionWallCheck(ref position, ref velocity, particles[i].Radius);
        particles[i].Position = position;
        particles[i].Velocity = velocity + accel;
    }
    Draw();
}

粒子的更新函数很简单，之前它使用的是 0,0 的全局重力向量。

        public void Update(float timeStep, Vector2 gravity)
        {
            velocity = velocity + timeStep * gravity;
            position = position + timeStep * velocity;
        }

我现在不确定如何处理 0 的情况。

4

2 回答 2

5

首先计算作用在每个物体上的重力。这是由

F = Gm1m2/r*r

其中 m1 和 m2 是两个物体的质量，G 是引力常数，r 是两个物体之间的距离。

现在，r 是一个向量，因此您可能希望将其拆分为单独的组件 - Fx 和 Fy。您可以按如下方式执行此操作：

Fx = F * cos(theta)
Fy = F * sin(theta)

对于每个质量，计算作用在它和所有其他物体上的重力。 对向量求和以获得净重力。（注意 - 该链接可供您感兴趣，但需要很长时间才能达到目的）。此时，您将对每个对象产生一个净力，您可以从中计算加速度。这是到达这一点的代码：

const double G = 6.67398 * 0.00000000001;

for (int i = 0; i < particles.Count(); i++)
{
    double sumX = 0;
    double sumY = 0;

    for (int j = 0; j < particles.Count(); j++)
    {
        // Don't add attraction to self
        if (i == j)
            continue;

        double distanceX = particles[i].Position.X - particles[j].Position.X;
        double distanceY = particles[i].Position.Y - particles[j].Position.Y;
        double r = Math.Sqrt(Math.Pow(distanceX, 2) + Math.Pow(distanceY, 2));
        double force = G * particles[i].Mass * particles[j].Mass / (r * r);
        double theta = Math.Tan(distanceY / distanceX);
        sumX += force * Math.Cos(theta);
        sumY += force * Math.Sin(theta);
    }

    double netForce = Math.Sqrt(Math.Pow(sumX, 2) + Math.Pow(sumY, 2));
    double a = netForce / particles[i].Mass;
    double aTheta = Math.Tan(sumY / sumX);

    // Here we get accelerations for X and Y.  You can probably figure out velocities from here.
    double aX = a * Math.Cos(aTheta);
    double aY = a * Math.Sin(aTheta);
}

笔记

这不考虑 0 值之类的东西 - 您必须清理此代码以处理特殊情况，然后它才能运行而不会崩溃。

在计算完所有力之前不要更新任何位置，否则您将离开列表中的后续元素。

另一件值得注意的事情：这个算法是 O(n^2)，所以如果你有多个身体，它将需要大量的运算。不幸的是，事情就是这样。如果你找到一种快速计算大量物体引力的方法，你应该打电话给 NASA。

根据您的坐标系，您可能会发现 y 向量正在反转。这是因为欧几里得几何将 y 的正值视为“向上”，而程序员倾向于以正单位从屏幕顶部“向下”测量 y。这会对你的角度和事物造成严重破坏。

于 2013-03-21T01:59:35.143 回答
0

知道所有球的位置和它们的质量，你就可以计算出任意两个物体之间的力矢量。找到从球“A”到所有其他球的向量——“A”到“B”球、“A”到“C”、“A”到“D”等。然后，简单地将所有 A 的向量相加到获得作用在 A 上的最终力矢量。对 B -> A、B -> C 等重复以找到 B 的矢量。对所有人都这样做，计算新的速度，并根据步骤之间的时间调整位置。

于 2013-03-21T01:59:12.163 回答