Darkcanuck/VelocityTest

Some code to test 1.7.1.3's updated getNewVelocity() method vs a few wiki-contributed versions.

The main class:

import robocode.Rules;


public class VelocityTest {
    
    private static Commands currentCommands = new Commands();
    private static boolean doPrint = false;
    
    public static void main(String[] args) {
        
        // init
        System.out.println("\nDarkcanuck's VelocityTest\n");
        
        if (!args[0].equals("all") && !args[0].equals("print")) {
            doPrint = true;
            double velocity = (args.length>0) ? Double.valueOf(args[0]) : 0.0;
            double distance = (args.length>1) ? Double.valueOf(args[1]) : 0.0;
            double maxvel   = (args.length>2) ? Double.valueOf(args[2]) : -1.0;
            int    exptime  = (args.length>3) ? Integer.valueOf(args[3]) : 0;
            testCase(velocity, distance, maxvel, exptime);
        } else {
            if (args[0].equals("print"))
                doPrint = true;
            
            testCase( 8.0,   22.8,  -1, 5);     // Simonton's caveat #1
            testCase( 8.0,   22.5,  -1, 5);     // Simonton's caveat #2
            testCase( 8.0, -200.0, 7.0, 39);    // Simonton's caveat #3
            
            testCase( 0.0,    6.0,  -1, 4);     // overshoot
            testCase( 0.0,   10.0,  -1, 6);     // overshoots twice
            testCase( 4.0,    0.0,  -1, 4);     // second, unnecessary overshoot
            testCase(-1.9,   10.0,  -1, 6);     // impossible decel/accel!
        }
    }
    
    public static void testCase(double velocity, double distance, double maxvel, int exptick) {
        
        StringBuffer b = new StringBuffer();
        boolean passed = true;
        
        double newvel  = velocity;
        double newdist = distance;
        double maximum = (maxvel>=0) ? maxvel : Rules.MAX_VELOCITY;
        
        int tick = 0;
        int maxtick = (exptick>0) ? exptick : (int) Math.max(Math.abs(distance), 100);
        
        b.append("Starting velocity=" + velocity + " distance=" + distance + 
                            ((maxvel>=0)? " max=" + maxvel : "") + "\n");
        
        currentCommands.setMaxVelocity(maximum);
        while ((Math.abs(newvel)>0.00001) || (Math.abs(newdist)>0.00001)) {
            // test next velocity change
            //double nextvel = orig_getNewVelocity(newvel, newdist);
            //double nextvel = void_getNewVelocity(newvel, newdist);
            //double nextvel = skil_getNewVelocity(newvel, newdist);
            //double nextvel = posi_getNewVelocity(newvel, newdist);
            double nextvel = vopo_getNewVelocity(newvel, newdist);
            passed &= checkAccel(nextvel, newvel) && checkMax(nextvel, maximum);
            
            // apply changes
            newvel = nextvel;
            newdist -= nextvel;
            tick++;
            b.append("  " + tick + " velocity=" + newvel + " remain=" + newdist + "\n");
            
            // check for infinite loops
            if (tick > 2*maxtick)
                break;
        }
        
        // check time taken
        passed &= (tick-1 <= maxtick);
        
        if (!passed)
            b.append("  FAIL\n");
        
        if (!passed || doPrint)
            System.out.println(b.toString() + "\n");
    }
    
    private static boolean checkAccel(double newvel, double oldvel) {
        double reverse = (oldvel<0) ? -1.0 : 1.0;
        double min = oldvel - reverse*Rules.DECELERATION;
        double max = oldvel + reverse*Rules.ACCELERATION;
        if (oldvel==0)
            min = oldvel - reverse*Rules.ACCELERATION;
        
        if (oldvel<0)
            return (newvel>=max) && (newvel<=min);
        else
            return (newvel<=max) && (newvel>=min);
    }
    private static boolean checkMax(double newvel, double maxvel) {
        return (Math.abs(newvel) <= Math.abs(maxvel));
    }
    
    
    /****************** ORIGINAL FROM ROBOCODE 1.7.1.3 *********************/
	private static double orig_getNewVelocity(double velocity, double distance) {
		// If the distance is negative, then change it to be positive and change the sign of the input velocity and the result
		if (distance < 0) {
			return -orig_getNewVelocity(-velocity, -distance);
		}

		double newVelocity;

		// Get the speed, which is always positive (because it is a scalar)
		final double speed = Math.abs(velocity); 

		// Check if we are decelerating, i.e. if the velocity is negative.
		// Note that if the speed is too high due to a new max. velocity, we must also decelerate.
		if (velocity < 0 || speed > currentCommands.getMaxVelocity()) {
			// If the velocity is negative, we are decelerating
			newVelocity = speed - Rules.DECELERATION;

			// Check if we are going from deceleration into acceleration
			if (newVelocity < 0) {
				// If we have decelerated to velocity = 0, then the remaining time must be used for acceleration
				double decelTime = speed / Rules.DECELERATION;
				double accelTime = (1 - decelTime);

				// New velocity (v) = d / t, where time = 1 (i.e. 1 turn). Hence, v = d / 1 => v = d
				// However, the new velocity must be limited by the max. velocity
				newVelocity = Math.min(currentCommands.getMaxVelocity(),
						Math.min(Rules.DECELERATION * decelTime * decelTime + Rules.ACCELERATION * accelTime * accelTime,
						distance));

				// Note: We change the sign here due to the sign check later when returning the result
				velocity *= -1;
			}
		} else {
			// Else, we are not decelerating, but might need to start doing so due to the remaining distance

			// Deceleration time (t) is calculated by: v = a * t => t = v / a
			final double decelTime = speed / Rules.DECELERATION;

			// Deceleration time (d) is calculated by: d = 1/2 a * t^2 + v0 * t + t
			// Adding the extra 't' (in the end) is special for Robocode, and v0 is the starting velocity = 0
			final double decelDist = 0.5 * Rules.DECELERATION * decelTime * decelTime + decelTime;

			// Check if we should start decelerating
			if (distance <= decelDist) {
				// If the distance < max. deceleration distance, we must decelerate so we hit a distance = 0

				// Calculate time left for deceleration to distance = 0
				double time = distance / (decelTime + 1); // 1 is added here due to the extra 't' for Robocode

				// New velocity (v) = a * t, i.e. deceleration * time, but not greater than the current speed

				if (time <= 1) {
					// When there is only one turn left (t <= 1), we set the speed to match the remaining distance
					newVelocity = Math.max(speed - Rules.DECELERATION, distance);
				} else {
					// New velocity (v) = a * t, i.e. deceleration * time
					newVelocity = time * Rules.DECELERATION;

					if (speed < newVelocity) {
						// If the speed is less that the new velocity we just calculated, then use the old speed instead
						newVelocity = speed;
					} else if (speed - newVelocity > Rules.DECELERATION) {
						// The deceleration must not exceed the max. deceleration.
						// Hence, we limit the velocity to the speed minus the max. deceleration.
						newVelocity = speed - Rules.DECELERATION;
					}
				}
			} else {
				// Else, we need to accelerate, but only to max. velocity
				newVelocity = Math.min(speed + Rules.ACCELERATION, currentCommands.getMaxVelocity());
			}
		}

		// Return the new velocity with the correct sign. We have been working with the speed, which is always positive
		return (velocity < 0) ? -newVelocity : newVelocity;
	}
	
	
	/************************* FROM Voidious *******************************/
	private static double void_getNewVelocity(double velocity, double distance) {
            // If the distance is negative, then change it to be positive and change the sign of the input velocity and the result
            if (distance < 0) {
                return -void_getNewVelocity(-velocity, -distance);
            }

            double newVelocity;

            // Get the speed, which is always positive (because it is a scalar)
            final double speed = Math.abs(velocity);

            if (velocity < 0) {
                // Check if we are decelerating, i.e. if the velocity is negative.
                newVelocity = speed - Rules.DECELERATION;

                // Check if we are going from deceleration into acceleration
                if (newVelocity < 0) {
                    // If we have decelerated to velocity = 0, then the remaining time must be used for acceleration
                    double decelTime = speed / Rules.DECELERATION;
                    double accelTime = (1 - decelTime);

                    // New velocity (v) = d / t, where time = 1 (i.e. 1 turn). Hence, v = d / 1 => v = d
                    // However, the new velocity must be limited by the max. velocity
                    newVelocity = Math.min(Rules.ACCELERATION * accelTime, distance);

                    // Note: We change the sign here due to the sign check later when returning the result
                    velocity *= -1;
                }
            } else {
                // Deceleration distance (d) is calculated iteratively due to Robocode's
                // discrete time system.
                final double decelDist = void_decelDistance(speed);

                // Deceleration ticks is the number of ticks it will take to get to
                // zero velocity.
                final long decelTime = Math.round( // VOIDIOUS: for rounding errors? maybe unnecessary
                    Math.ceil((speed - Rules.DECELERATION) / Rules.DECELERATION));

                // The maximum distance coverable with an equivalent decelTime
                final double decelTimeMaxDist = ((decelTime + 1) / 2.0) * decelTime // sum of 1..decelTime
                    * Rules.DECELERATION;

                if (distance <= Rules.DECELERATION) {
                    // If we can cover remaining distance and then completely stop,
                    // set speed = distance
                    newVelocity = Math.max(speed - Rules.DECELERATION, distance);
                } else if (distance <= decelTimeMaxDist) {
                    // If we can cover distance in decelTime, split any extra
                    // distance (between decelDist and distance) over decelTime
                    // ticks
                    newVelocity = speed - Rules.DECELERATION +
                        ((distance - decelDist) / decelTime);
                } else {
                    // If we need more than decelTime ticks, try to spread the
                    // extra distance over (decelTime + 1) ticks. This will just max
                    // the acceleration if it needs to (ie, if we need more ticks).
                    // VOIDIOUS: I think this part would break if Rules.ACCELERATION
                    //           were set above Rules.DECELERATION; we might need an
                    //           extra case or something. Doh. =(
                    newVelocity = Math.min(speed + Rules.ACCELERATION,
                        (decelTime * Rules.DECELERATION) +
                            ((distance - decelTimeMaxDist) / Math.max(decelTime + 1, 2)));
                }
            }

            // VOIDIOUS: I think it makes more sense to do this here; no need to decelerate maximally
            //           if you don't need to to accomodate a new setMaxVelocity.
            newVelocity = Math.max(speed - Rules.DECELERATION,
                Math.min(speed + Rules.ACCELERATION,
                    Math.min(newVelocity, currentCommands.getMaxVelocity())));

            // Return the new velocity with the correct sign. We have been working with the speed, which is always positive
            return (velocity < 0) ? -newVelocity : newVelocity;
        }

        private static final double void_decelDistance(double speed){
            double distance = 0;
            while(speed > 0){
                speed = Math.max(0,speed - Rules.DECELERATION);
                distance += speed;
            }
            return distance;
        }
    
    /**************************** FROM Skilgannon *********************************/
    private static double skil_getNewVelocity(double velocity, double distance) {

             if (distance < 0) 
                return -skil_getNewVelocity(-velocity, -distance);
          	// If the distance is negative, then change it to be positive
          	// and change the sign of the input velocity and the result

             double maxVel = currentCommands.getMaxVelocity();
             if (velocity < 0)
                return Math.min(velocity + Rules.DECELERATION, maxVel);
             //we want to go in the opposite direction, so decelerate   

             else{ 
             //we are going in the direction we want, test what happens if we accelerate

                double accel = Math.min(Rules.ACCELERATION, maxVel - velocity);
                //speed up, but not more than max velocity. decel if maxVel is less than velocity.

                accel = Math.max(accel, -Rules.DECELERATION);
                 //prevent excess deceleration due to bot lowering the maxVel while velocity is high

                if (distance > skil_decelDistance(velocity + accel))
                   return velocity + accel;
                else if(accel != 0 && distance > skil_decelDistance(velocity))
                   return velocity;
                else{
                   if(distance < Rules.DECELERATION 
                   //we'll be able to cover remaining distance in 1 tick and then decel to stop

                   && velocity - distance <= Rules.DECELERATION 
                   //and our velocity is low enough for us to get to that required velocity
                   )
                      return Math.min(distance, maxVel);
                 //choose the velocity to cover all remaining distance        

                   return Math.max(-maxVel, velocity -  Rules.DECELERATION);
                //velocity > 0 and we are close enough, so decelerate. 
                }

             }

          }
        /**
        * Returns the linear distance it would take to decelerate from a given positive velocity
        *
        * @param velocity the positive velocity from which to test
        * @return the linear distance required to decelerate to a standstill
        */
           private static final double skil_decelDistance(double velocity){
             double distance = 0;
             while(velocity > 0){
                distance += velocity;
                velocity = Math.max(0,velocity - Rules.DECELERATION);
             }
             return distance;
          }  
    
    /******************** FROM Positive ********************/
    static double posi_getNewVelocity(double velocityArg, double distanceArg) 
    	{	
    		double velocity;
    		double distance;

    		// Make sure the remaining distance is always positive or zero
    		// (we switch this back later)
    		if(distanceArg<0)
    		{
    			velocity=-velocityArg;
    			distance=-distanceArg;
    		}
    		else
    		{
    			velocity=velocityArg;
    			distance=distanceArg;
    		}

    		// Get the next most positive velocity the robot can reach for next turn
    		double mostPositiveReachableVelocity = posi_VelocityToMostPositiveVelocity(velocity);
    		// Get the next most negative velocity the robot can reach for next turn
    		double mostNegativeReachableVelocity = posi_VelocityToMostNegativeVelocity(velocity);


    		double highestWantedVelocity = Math.min(currentCommands.getMaxVelocity(), posi_maxSpeedToStopInDisp(distance));

    		// The real next velocity is limited by what is actually reachable
    		double nextVelocity = Math.min(mostPositiveReachableVelocity,Math.max(mostNegativeReachableVelocity,highestWantedVelocity ));

    		// Switch return value back if needed
    		if(distanceArg<0)
    			nextVelocity = -nextVelocity;

    		return nextVelocity;
    	}


    	static public double posi_VelocityToMostPositiveVelocity(double velocity)
    	{
    		// Returns the most positive reachable velocity from the
    		// specified velocity in one turn
    		if(velocity>0)
    		{
    			double returnVelocity = velocity+Rules.ACCELERATION;
    			if(returnVelocity>Rules.MAX_VELOCITY)
    				return Rules.MAX_VELOCITY;
    			else
    				return returnVelocity;
    		}
    		else
    		{
    			double returnVelocity = velocity+Rules.DECELERATION;
    			if(returnVelocity>Rules.ACCELERATION)
    				return Rules.ACCELERATION;
    			else
    				return returnVelocity;
    		}
    	}
    	static public double posi_VelocityToMostNegativeVelocity(double velocity)
    	{
    		// Returns the most negative reachable velocity from the
    		// specified velocity in one turn
    		if(velocity<0)
    		{
    			double returnVelocity = velocity-Rules.ACCELERATION;
    			if(returnVelocity<-Rules.MAX_VELOCITY)
    				return -Rules.MAX_VELOCITY;
    			else
    				return returnVelocity;
    		}
    		else
    		{
    			double returnVelocity = velocity-Rules.DECELERATION;
    			if(returnVelocity<-Rules.ACCELERATION)
    				return -Rules.ACCELERATION;
    			else
    				return returnVelocity;
    		}
    	}

    	static private final double[] dispStopArray = 
    		{0.0000,1.0000,2.0000,2.5000,3.0000,
    		3.5000,4.0000,4.3333,4.6666,5.0000,
    		5.3333,5.6666,6.0000,6.2500,6.5000,
    		6.7500,7.0000,7.2500,7.5000,7.7500};
    	static public double posi_maxSpeedToStopInDisp(double displacement)
    	{
    		// Returns the biggest velocity the robot could go to this turn,
    		// still being able to stop without overshooting. (Or if 
    		// remaining displacement is less than 2, returns that)
                    // This routine could be improved to match up with robocode's
                    // older velocity selecting rules.
    		if(displacement>=0)
    		{
    			if(displacement>=20)
    				return 8.0;
    			else if(displacement<=2)
    				return displacement;
    			else
    				return dispStopArray[(int)Math.floor(displacement)];
    		}
    		else
    		{
    			return 0;
    		}
    	}
    
    
    /****************** FROM Voidious + Positive ***********************/
    public static double vopo_getNewVelocity(double velocity, double distance) {
        	 if(distance<0)
        	  return -vopo_getNewVelocity(-velocity,-distance);
        	  double highestVelocity = vopo_getMaxVelocity(distance); // highest velocity without overshooting
        	  double wantedVelocity = Math.min(highestVelocity,8.0);
        	      // the actually wanted velocity by the robot is the highest possible,
        	      // limited by what the robot set by the setMaxVelocity command
        	  return vopo_getClosestReachableVelocityToVelocity(velocity, wantedVelocity);
        	      // return whatever is closest to that velocity
    }
    
    public static double vopo_getClosestReachableVelocityToVelocity(double currentVelocity,double wantedVelocity)
    {
     // this function assumes wantedVelocity<=Rules.MAXVELOCITY
     // with this function you can basically assume setAhead(Infinity) or setAhead(-Infinity)
     // was called, and you determine the next velocity based on the max velocity
     // set by the robot. For example, if the current velocity is 0 and the max velocity
     // set was 4.0, it would return 1.0. If the current velocity was 8.0, it would return 6.0.
     if(wantedVelocity<0)
      return -vopo_getClosestReachableVelocityToVelocity(-currentVelocity,-wantedVelocity);
     if(currentVelocity<0)
     {
      double nextVelocity;
      // we are travelling the wrong way, decelerate
      nextVelocity = currentVelocity + Rules.DECELERATION;
      if(nextVelocity>Rules.ACCELERATION)
       // make sure we can't jump from -0.1 to 1.9 or something
       nextVelocity = Rules.ACCELERATION;
      if(nextVelocity>wantedVelocity)
       // if the wanted velocity is for example 0.5, limit the velocity to that.
       return wantedVelocity;
      else
       // else return the highest possible
       return nextVelocity;
     }
     else
     {
      if(currentVelocity>wantedVelocity)
      {
       // both velocities are positive, but we need to decelerate
       double nextVelocity = currentVelocity - Rules.DECELERATION;
       if(nextVelocity<wantedVelocity)
        // if we can decelerate more than what's wanted, return what's wanted
        return wantedVelocity;
       else
        // else return the closest to it
        return nextVelocity;
      }
      else
      {
       // the wantedVelocity is higher than current
       double nextVelocity = currentVelocity + Rules.ACCELERATION;
       if(nextVelocity>wantedVelocity)
        // if we can accelerate more than what's wanted, return what's wanted
        return wantedVelocity;
       else
        // else return the closest to it
        return nextVelocity;
      }
     }
    } 

    public static double vopo_getMaxVelocity(double distance)
    {
        long decelTime = vopo_decelTime(distance);
        double decelDist = (decelTime / 2.0) * (decelTime-1) // sum of 0..(decelTime-1)
            * Rules.DECELERATION;

        return ((decelTime - 1) * Rules.DECELERATION) +
            ((distance - decelDist) / decelTime);
    }

    public static long vopo_decelTime(double distance) {
        long x = 1;
        do {
            // (square(x) + x) / 2) = 1, 3, 6, 10, 15...
            if (distance <= ((square(x) + x) / 2) * Rules.DECELERATION) {
                return x;
            }
            x++;
        } while (true);
    }

    public static long square(long i) {
        return i * i;
    }

}

And a support class for setting the max velocity:

import robocode.Rules;

public class Commands {
    private static double maxVelocity = Rules.MAX_VELOCITY;

    public static double getMaxVelocity() { return maxVelocity; }
    public static void setMaxVelocity(double maxVel) { maxVelocity = maxVel; }
}