Moving from A to B deceleration (Maths) XNA

Question

What is the best way to decelerate at a speed of any given value (e.g. accelerationDropOff = 1.5f) before it reaches the end destination?

public bool MoveFromCurrentToPosition(float x, float y, float velocity, float acceleration, float deltaTime)
    {
        float startX = positionX, startY = positionY;
        float endX = x, endY = y;
        float deltaX = endX - startX;
        float deltaY = endY - startY;
        float speed = velocity;
        float elapsed = 0.01f;

        // On starting movement
        float distance = (float)Math.Sqrt(Math.Pow(deltaX, 2) + Math.Pow(deltaY, 2));
        float directionX = deltaX / distance;
        float directionY = deltaY / distance;
        isMoving = true;

        // On update
        if (isMoving == true)
        {
            positionX += directionX * speed * elapsed;
            positionY += directionY * speed * elapsed;

            if (currentAcceleration == 0)
            {
                currentAcceleration = acceleration;
            }
            else if (currentAcceleration >= maxAcceleration) // <- Don't accelerate anymore
            {
                speed *= currentAcceleration;
                positionX += (directionX * speed) * deltaTime; positionY += (directionY * speed) * deltaTime;
                bounds.X = (int)positionX; bounds.Y = (int)positionY;
            }
            else
            {
                currentAcceleration += acceleration;
                speed *= currentAcceleration;
                positionX += (directionX * speed) * deltaTime; positionY += (directionY * speed) * deltaTime;
                bounds.X = (int)positionX; bounds.Y = (int)positionY;
            }

            float a = x, o = y;
            double angle = Math.Atan2(o, a);
            angle = angle * 180 / Math.PI;
            movementDirection = (float)(180 - angle);


            // Decelerate before reaching the end point



            if (Math.Sqrt(Math.Pow(positionX - startX, 2) + Math.Pow(positionY - startY, 2)) >= distance)
            {
                positionX = endX;
                positionY = endY;
                isMoving = false;

                return true;
            } 
        }

        return false;
    }

I have been stuck on this problem for a hour or two and Math.exe is not responding. Can anyone point me in the correct direction please?

Answer 1

It seems as if you are mixing up speed (velocity) and acceleration. Speed is the change of position with respect to a given time frame. Acceleration is the change of speed with respect to a given time frame. For a constant acceleration, position and velocity change as follows:

v1 = v0 + a * t
x1 = x0 + v0 * t + 1/2 * a * t^2

v0, v1 and x0, x1 are the velocities and positions at the beginning and end of the time frame, respectively, a is the acceleration, t is the time frame length. This is the exact formula if you assume constant acceleration over the period of the time frame. Often, you find approximations like the following, which introduce some integration errors:

v1 = v0 + a * t
x1 = x0 + v1 * t

I would suggest to use the exact formulas.

As far as I understand your question, you want to find an acceleration, such that a body moving at initial velocity v0 stops after travelling d length units.

This gives you the following equations:

0 = v0 + a * t                    //target velocity of 0
d =  0 + v0 * t + 1/2 * a * t^2   //travel distance of d

The solution is:

a = -1/2 * v0^2 / d

The time needed for this motion is:

t = 2 * d / v0

So calculate the acceleration once at the beginning of the deccelerating movement and then update current position and velocity with the formulas above.

Some additional hints for your code:

If you want to square a variable x, use x * x instead of Math.pow(x, 2). It is easier to read and has a better performance.

If you already use XNA, then use its Vector2 structure. This makes a lot of things much easier. You can just add two vectors and don't need to care about each component separately. There are methods to get the length of a vector, and so on.