Bouncing ball isssue

Question

I am currently working on the 2D Bouncing ball physics that bounces the ball up and down. The physics behaviour works fine but at the end the velocity keep +3 then 0 non-stop even the ball has stopped bouncing. How should I modify the code to fix this issue?

Here is the video shows how it works. Note: Bandicam cannot record the velocity transition between -3 and 0. So, it just shows -3 when the ball stops bouncing.
http://www.youtube.com/watch?v=SEH5V6FBbYA&feature=youtu.be

Here is the generated report: https://www.dropbox.com/s/4dkt0sgmrgw8pqi/report.txt

    ballPos         = D3DXVECTOR2( 50, 100 );
    velocity        = 0;
    acceleration    = 3.0f;

void GameClass::Update()
{
    // v = u + at
    velocity += acceleration;

    // update ball position
    ballPos.y += velocity;

    // If the ball touches the ground
    if ( ballPos.y >= 590 )
    {
        // Bounce the ball
        ballPos.y = 590;
        velocity *= -1;
    }

    // Graphics Rendering
    m_Graphics.BeginFrame();
    ComposeFrame();
    m_Graphics.EndFrame();
}

Answer 1

The main problem you are encountering is due to the fact that you are using Euler integration. It is very innacurate and assumes a constant acceleration over the whole timestep (in your case an implicit dt = 1), which is wrong in general, but in the case of a bounce, very very wrong indeed.

Also, there is no damping. In the real world, energy is always lost due to friction and collisions. In fact, your code is actually giving free energy to the ball: at the moment of impact, you teleport the ball upwards a short distance, while giving it an impossibly perfect eleastic collision, thereby giving the ball free potential energy. The only reason your ball's bouncing becomes smaller is because of the innacurate Euler integration, not something you want to rely on.

To make your code better, I would first introduce an explicit timestep, then you can call your integration function multiple times per frame with smaller timesteps to get better accuracy, or have an adaptive timestep.

You could also look into higher order integration functions. 4th Order Runge-Kutta is very accurate, but overkill for what you want, but perhaps a second order leapfrog method.

You could also look into Verlet integration. While it is still not very accurate, it is easy to control and very stable.

You should also add some damping. The easiest way is to multiply the velocity by a number slightly smaller than 1 (which is equivalent to adding a small force proportional to velocity, in the opposite direction):

vel *= 0.9999; <- energy loss every frame, air resistance
if ( ballPos.y >= 590 )
{
    ballPos.y = 590;
    vel *= -0.95; <-larger energy loss in collision
}

So, to sum up, here is a list of keywords to research to improve your simulation:

leapfrog integration, runge-kutta integration, verlet integration, adaptive timestep, collision detection/resolution, rigid body stacking, resting contact, impulse collisions,

You can easily find lots of easy to understand tutorials, samples and papers relating to this. That's probably a lot deeper than you need/desire to go. But writing a simple, but solid, physics simulation is a great learning experience and a whole lot of fun.

Answer 2

Your acceleration will negate any upward velocity at the point that speed <= 3.

Answer 3

Put a isBounce flag to make the velocity to zero when the ball stops bouncing.

 void GameClass::Update()
{
    if ( isBounce )
    {
        // v = u + at
        velocity += acceleration;

        // update ball position
        ballPos.y += velocity;
    }
    else
    {
        velocity = 0;
    }

    // If the ball touches the ground
    if ( ballPos.y >= 590 )
    {
        if ( isBounce )
        {
            // Bounce the ball
            ballPos.y = 590;
           velocity *= -1;
        }


        if ( velocity == 0 )
        {
            isBounce = false;
        }
}