using System;

using System.Diagnostics;

​

// Ex postfacto description: This is where I worked out and benchmarked the 

// heuristic I would use to calculate launch inputs (drag and velocity).

public class Program

{

    private const float deltaTime = 0.02f;

    private const float tolerance = 0.01f;

    public static void Main()

    {

        Stopwatch stopwatch = new Stopwatch();

​

        DoDecelerationTest( 0.1f, stopwatch );

        DoDecelerationTest( 0.25f, stopwatch );

        DoDecelerationTest( 0.5f, stopwatch );

        DoDecelerationTest( 1f, stopwatch );

        DoDecelerationTest( 5f, stopwatch );

        DoDecelerationTest( 10f, stopwatch );

        DoDecelerationTest( 25f, stopwatch );

        DoDecelerationTest( 50f, stopwatch );

        DoDecelerationTest( 100f, stopwatch );

        DoDecelerationTest( 500f, stopwatch );

        DoDecelerationTest( 750f, stopwatch );

        DoDecelerationTest( 1000f, stopwatch );

        DoDecelerationTest( 2000f, stopwatch );

    }

    public static void DoDecelerationTest( float initialVelocity, Stopwatch stopwatch )

    {

        const float desiredDistance = 10f;

​

        float deceleration = initialVelocity;

        float delta = deceleration * 2f;

        bool isRevisingDownward = false;

​

        int i = 0, j = 0;

        int maxIterations = 1000;

​

        // I have this in method scope only for diagonistics.

        float distance = 0, velocity = initialVelocity;

​

        stopwatch.Reset();

        stopwatch.Start();

​

        while( i < maxIterations )

        {

            distance = 0;

            velocity = initialVelocity;

​

            if( deceleration > 0 )

            {

                while( velocity > 0f && distance < desiredDistance )

                {

                    distance += velocity * deltaTime;

                    velocity -= deceleration * deltaTime;

                    ++j;

                }

            }

            else

                // If deceleration is 0, the simulated object will travel 

                // forever, so the distance should be assumed to be too great.

                distance = desiredDistance + 1;

            if( Math.Abs( distance - desiredDistance ) < tolerance )

            {

                stopwatch.Stop();

                Console.WriteLine( string.Format(

                    "For velocity of {0}, a deceleration rate of {1} is required ({2} simulated frames performed over {3} ticks).",

                    initialVelocity, deceleration, j, stopwatch.ElapsedTicks ) );

                return;

            }

            else

            {

                if( distance < desiredDistance )        // Deceleration is too high

                {

                    if( !isRevisingDownward )

                    {

                        delta /= 2f;

                        isRevisingDownward = true;

                    }

                    deceleration -= delta;

                }

                else                                    // Deceleration is too low

                {

                    if( isRevisingDownward )

                    {

                        delta /= 2f;

                        isRevisingDownward = false;

                    }

                    deceleration += delta;

                }

            }

            ++i;

        }

        stopwatch.Stop();

        Console.WriteLine( string.Format(

            "TIMEOUT — Velocity: {0}. After {1} simulations over {2} simulated frames, final distance was {3}, velocity was {4}. It took {5} ticks.", 

            initialVelocity, i, j, distance.ToString(), velocity.ToString(), stopwatch.ElapsedTicks ) );

    }

}