robocode
Class _AdvancedRadiansRobot

java.lang.Object
  extended by robocode._RobotBase
      extended by robocode._Robot
          extended by robocode.Robot
              extended by robocode._AdvancedRobot
                  extended by robocode._AdvancedRadiansRobot
All Implemented Interfaces:
Runnable, IBasicEvents, IBasicEvents2, IBasicRobot, IInteractiveEvents, IInteractiveRobot, IPaintEvents, IPaintRobot
Direct Known Subclasses:
AdvancedRobot

public class _AdvancedRadiansRobot
extends _AdvancedRobot

This class is used by the system as a placeholder for all *Radians calls in AdvancedRobot. You may refer to this class for documentation only.

You should create a AdvancedRobot instead.

There is no guarantee that this class will exist in future versions of Robocode.

(The Radians methods themselves will continue work, however).

Author:
Mathew A. Nelson (original), Flemming N. Larsen (contributor), Pavel Savara (contributor)
See Also:
AdvancedRobot

Field Summary
 
Fields inherited from class robocode._RobotBase
out
 
Constructor Summary
protected _AdvancedRadiansRobot()
           
 
Method Summary
 double getGunHeadingRadians()
          Returns the direction that the robot's gun is facing, in radians.
 double getGunTurnRemainingRadians()
          Returns the angle remaining in the gun's turn, in radians.
 double getHeadingRadians()
          Returns the direction that the robot's body is facing, in radians.
 double getRadarHeadingRadians()
          Returns the direction that the robot's radar is facing, in radians.
 double getRadarTurnRemainingRadians()
          Returns the angle remaining in the radar's turn, in radians.
 double getTurnRemainingRadians()
          Returns the angle remaining in the robot's turn, in radians.
 void setTurnGunLeftRadians(double radians)
          Sets the robot's gun to turn left by radians when the next execution takes place.
 void setTurnGunRightRadians(double radians)
          Sets the robot's gun to turn right by radians when the next execution takes place.
 void setTurnLeftRadians(double radians)
          Sets the robot's body to turn left by radians when the next execution takes place.
 void setTurnRadarLeftRadians(double radians)
          Sets the robot's radar to turn left by radians when the next execution takes place.
 void setTurnRadarRightRadians(double radians)
          Sets the robot's radar to turn right by radians when the next execution takes place.
 void setTurnRightRadians(double radians)
          Sets the robot's body to turn right by radians when the next execution takes place.
 void turnGunLeftRadians(double radians)
          Immediately turns the robot's gun to the left by radians.
 void turnGunRightRadians(double radians)
          Immediately turns the robot's gun to the right by radians.
 void turnLeftRadians(double radians)
          Immediately turns the robot's body to the left by radians.
 void turnRadarLeftRadians(double radians)
          Immediately turns the robot's radar to the left by radians.
 void turnRadarRightRadians(double radians)
          Immediately turns the robot's radar to the right by radians.
 void turnRightRadians(double radians)
          Immediately turns the robot's body to the right by radians.
 
Methods inherited from class robocode._AdvancedRobot
endTurn, getGunHeadingDegrees, getHeadingDegrees, getMaxWaitCount, getRadarHeadingDegrees, getWaitCount, setTurnGunLeftDegrees, setTurnGunRightDegrees, setTurnLeftDegrees, setTurnRadarLeftDegrees, setTurnRadarRightDegrees, setTurnRightDegrees, turnGunLeftDegrees, turnGunRightDegrees, turnLeftDegrees, turnRadarLeftDegrees, turnRadarRightDegrees, turnRightDegrees
 
Methods inherited from class robocode.Robot
ahead, back, doNothing, finalize, fire, fireBullet, getBasicEventListener, getBattleFieldHeight, getBattleFieldWidth, getEnergy, getGraphics, getGunCoolingRate, getGunHeading, getGunHeat, getHeading, getHeight, getInteractiveEventListener, getName, getNumRounds, getOthers, getPaintEventListener, getRadarHeading, getRobotRunnable, getRoundNum, getTime, getVelocity, getWidth, getX, getY, onBattleEnded, onBulletHit, onBulletHitBullet, onBulletMissed, onDeath, onHitByBullet, onHitRobot, onHitWall, onKeyPressed, onKeyReleased, onKeyTyped, onMouseClicked, onMouseDragged, onMouseEntered, onMouseExited, onMouseMoved, onMousePressed, onMouseReleased, onMouseWheelMoved, onPaint, onRobotDeath, onScannedRobot, onStatus, onWin, resume, run, scan, setAdjustGunForRobotTurn, setAdjustRadarForGunTurn, setAdjustRadarForRobotTurn, setAllColors, setBodyColor, setBulletColor, setColors, setColors, setGunColor, setRadarColor, setScanColor, stop, stop, turnGunLeft, turnGunRight, turnLeft, turnRadarLeft, turnRadarRight, turnRight
 
Methods inherited from class robocode._Robot
getBattleNum, getGunCharge, getGunImageName, getLife, getNumBattles, getRadarImageName, getRobotImageName, setGunImageName, setInterruptible, setRadarImageName, setRobotImageName
 
Methods inherited from class robocode._RobotBase
setOut, setPeer
 
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface robocode.robotinterfaces.IBasicRobot
setOut, setPeer
 
Methods inherited from interface robocode.robotinterfaces.IBasicRobot
setOut, setPeer
 

Constructor Detail

_AdvancedRadiansRobot

protected _AdvancedRadiansRobot()
Method Detail

getHeadingRadians

public double getHeadingRadians()
Returns the direction that the robot's body is facing, in radians. The value returned will be between 0 and 2 * PI (is excluded).

Note that the heading in Robocode is like a compass, where 0 means North, PI / 2 means East, PI means South, and 3 * PI / 4 means West.

Returns:
the direction that the robot's body is facing, in radians.
See Also:
_AdvancedRobot.getHeadingDegrees(), getGunHeadingRadians(), getRadarHeadingRadians()

setTurnLeftRadians

public void setTurnLeftRadians(double radians)
Sets the robot's body to turn left by radians when the next execution takes place.

This call returns immediately, and will not execute until you call execute() or take an action that executes.

Note that both positive and negative values can be given as input, where negative values means that the robot's body is set to turn right instead of left.

Example:

   // Set the robot to turn 180 degrees to the left
   setTurnLeftRadians(Math.PI);
 

// Set the robot to turn 90 degrees to the right instead of left // (overrides the previous order) setTurnLeftRadians(-Math.PI / 2);

... // Executes the last setTurnLeftRadians() execute();

Parameters:
radians - the amount of radians to turn the robot's body to the left. If radians > 0 the robot is set to turn left. If radians < 0 the robot is set to turn right. If radians = 0 the robot is set to stop turning.
See Also:
setTurnLeft(double), Robot.turnLeft(double), turnLeftRadians(double), Robot.turnRight(double), turnRightRadians(double), setTurnRight(double), setTurnRightRadians(double)

setTurnRightRadians

public void setTurnRightRadians(double radians)
Sets the robot's body to turn right by radians when the next execution takes place.

This call returns immediately, and will not execute until you call execute() or take an action that executes.

Note that both positive and negative values can be given as input, where negative values means that the robot's body is set to turn left instead of right.

Example:

   // Set the robot to turn 180 degrees to the right
   setTurnRightRadians(Math.PI);
 

// Set the robot to turn 90 degrees to the left instead of right // (overrides the previous order) setTurnRightRadians(-Math.PI / 2);

... // Executes the last setTurnRightRadians() execute();

Parameters:
radians - the amount of radians to turn the robot's body to the right. If radians > 0 the robot is set to turn right. If radians < 0 the robot is set to turn left. If radians = 0 the robot is set to stop turning.
See Also:
setTurnRight(double), Robot.turnRight(double), turnRightRadians(double), Robot.turnLeft(double), turnLeftRadians(double), setTurnLeft(double), setTurnLeftRadians(double)

turnLeftRadians

public void turnLeftRadians(double radians)
Immediately turns the robot's body to the left by radians.

This call executes immediately, and does not return until it is complete, i.e. when the angle remaining in the robot's turn is 0.

Note that both positive and negative values can be given as input, where negative values means that the robot's body is set to turn right instead of left.

Example:

   // Turn the robot 180 degrees to the left
   turnLeftRadians(Math.PI);
 

// Afterwards, turn the robot 90 degrees to the right turnLeftRadians(-Math.PI / 2);

Parameters:
radians - the amount of radians to turn the robot's body to the left. If radians > 0 the robot will turn right. If radians < 0 the robot will turn left. If radians = 0 the robot will not turn, but execute.
See Also:
Robot.turnLeft(double), Robot.turnRight(double), turnRightRadians(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), Robot.turnGunRight(double), turnGunRightRadians(double), Robot.turnRadarLeft(double), turnRadarLeftRadians(double), Robot.turnRadarRight(double), turnRadarRightRadians(double), Robot.setAdjustGunForRobotTurn(boolean)

turnRightRadians

public void turnRightRadians(double radians)
Immediately turns the robot's body to the right by radians. This call executes immediately, and does not return until it is complete, i.e. when the angle remaining in the robot's turn is 0.

Note that both positive and negative values can be given as input, where negative values means that the robot's body is set to turn left instead of right.

Example:

   // Turn the robot 180 degrees to the right
   turnRightRadians(Math.PI);
 

// Afterwards, turn the robot 90 degrees to the left turnRightRadians(-Math.PI / 2);

Parameters:
radians - the amount of radians to turn the robot's body to the right. If radians > 0 the robot will turn right. If radians < 0 the robot will turn left. If radians = 0 the robot will not turn, but execute.
See Also:
Robot.turnRight(double), Robot.turnLeft(double), turnLeftRadians(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), Robot.turnGunRight(double), turnGunRightRadians(double), Robot.turnRadarLeft(double), turnRadarLeftRadians(double), Robot.turnRadarRight(double), turnRadarRightRadians(double), Robot.setAdjustGunForRobotTurn(boolean)

getGunHeadingRadians

public double getGunHeadingRadians()
Returns the direction that the robot's gun is facing, in radians. The value returned will be between 0 and 2 * PI (is excluded).

Note that the heading in Robocode is like a compass, where 0 means North, PI / 2 means East, PI means South, and 3 * PI / 4 means West.

Returns:
the direction that the robot's gun is facing, in radians.
See Also:
_AdvancedRobot.getGunHeadingDegrees(), getHeadingRadians(), getRadarHeadingRadians()

getRadarHeadingRadians

public double getRadarHeadingRadians()
Returns the direction that the robot's radar is facing, in radians. The value returned will be between 0 and 2 * PI (is excluded).

Note that the heading in Robocode is like a compass, where 0 means North, PI / 2 means East, PI means South, and 3 * PI / 4 means West.

Returns:
the direction that the robot's radar is facing, in radians.
See Also:
_AdvancedRobot.getRadarHeadingDegrees(), getHeadingRadians(), getGunHeadingRadians()

setTurnGunLeftRadians

public void setTurnGunLeftRadians(double radians)
Sets the robot's gun to turn left by radians when the next execution takes place.

This call returns immediately, and will not execute until you call execute() or take an action that executes.

Note that both positive and negative values can be given as input, where negative values means that the robot's gun is set to turn right instead of left.

Example:

   // Set the gun to turn 180 degrees to the left
   setTurnGunLeftRadians(Math.PI);
 

// Set the gun to turn 90 degrees to the right instead of left // (overrides the previous order) setTurnGunLeftRadians(-Math.PI / 2);

... // Executes the last setTurnGunLeftRadians() execute();

Parameters:
radians - the amount of radians to turn the robot's gun to the left. If radians > 0 the robot's gun is set to turn left. If radians < 0 the robot's gun is set to turn right. If radians = 0 the robot's gun is set to stop turning.
See Also:
setTurnGunLeft(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), Robot.turnGunRight(double), turnGunRightRadians(double), setTurnGunRight(double), setTurnGunRightRadians(double), Robot.setAdjustGunForRobotTurn(boolean)

setTurnGunRightRadians

public void setTurnGunRightRadians(double radians)
Sets the robot's gun to turn right by radians when the next execution takes place.

This call returns immediately, and will not execute until you call execute() or take an action that executes.

Note that both positive and negative values can be given as input, where negative values means that the robot's gun is set to turn left instead of right.

Example:

   // Set the gun to turn 180 degrees to the right
   setTurnGunRightRadians(Math.PI);
 

// Set the gun to turn 90 degrees to the left instead of right // (overrides the previous order) setTurnGunRightRadians(-Math.PI / 2);

... // Executes the last setTurnGunRightRadians() execute();

Parameters:
radians - the amount of radians to turn the robot's gun to the right. If radians > 0 the robot's gun is set to turn left. If radians < 0 the robot's gun is set to turn right. If radians = 0 the robot's gun is set to stop turning.
See Also:
setTurnGunRight(double), Robot.turnGunRight(double), turnGunRightRadians(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), setTurnGunLeft(double), setTurnGunLeftRadians(double), Robot.setAdjustGunForRobotTurn(boolean)

setTurnRadarLeftRadians

public void setTurnRadarLeftRadians(double radians)
Sets the robot's radar to turn left by radians when the next execution takes place.

This call returns immediately, and will not execute until you call execute() or take an action that executes.

Note that both positive and negative values can be given as input, where negative values means that the robot's radar is set to turn right instead of left.

Example:

   // Set the radar to turn 180 degrees to the left
   setTurnRadarLeftRadians(Math.PI);
 

// Set the radar to turn 90 degrees to the right instead of left // (overrides the previous order) setTurnRadarLeftRadians(-Math.PI / 2);

... // Executes the last setTurnRadarLeftRadians() execute();

Parameters:
radians - the amount of radians to turn the robot's radar to the left. If radians > 0 the robot's radar is set to turn left. If radians < 0 the robot's radar is set to turn right. If radians = 0 the robot's radar is set to stop turning.
See Also:
setTurnRadarLeft(double), Robot.turnRadarLeft(double), turnRadarLeftRadians(double), Robot.turnRadarRight(double), turnRadarRightRadians(double), setTurnRadarRight(double), setTurnRadarRightRadians(double), Robot.setAdjustRadarForRobotTurn(boolean), Robot.setAdjustRadarForGunTurn(boolean)

setTurnRadarRightRadians

public void setTurnRadarRightRadians(double radians)
Sets the robot's radar to turn right by radians when the next execution takes place.

This call returns immediately, and will not execute until you call execute() or take an action that executes.

Note that both positive and negative values can be given as input, where negative values means that the robot's radar is set to turn left instead of right.

Example:

   // Set the radar to turn 180 degrees to the right
   setTurnRadarRightRadians(Math.PI);
 

// Set the radar to turn 90 degrees to the right instead of right // (overrides the previous order) setTurnRadarRightRadians(-Math.PI / 2);

... // Executes the last setTurnRadarRightRadians() execute();

Parameters:
radians - the amount of radians to turn the robot's radar to the right. If radians > 0 the robot's radar is set to turn left. If radians < 0 the robot's radar is set to turn right. If radians = 0 the robot's radar is set to stop turning.
See Also:
setTurnRadarRight(double), Robot.turnRadarRight(double), turnRadarRightRadians(double), Robot.turnRadarLeft(double), turnRadarLeftRadians(double), setTurnRadarLeft(double), setTurnRadarLeftRadians(double), Robot.setAdjustRadarForRobotTurn(boolean), Robot.setAdjustRadarForGunTurn(boolean)

turnGunLeftRadians

public void turnGunLeftRadians(double radians)
Immediately turns the robot's gun to the left by radians.

This call executes immediately, and does not return until it is complete, i.e. when the angle remaining in the gun's turn is 0.

Note that both positive and negative values can be given as input, where negative values means that the robot's gun is set to turn right instead of left.

Example:

   // Turn the robot's gun 180 degrees to the left
   turnGunLeftRadians(Math.PI);
 

// Afterwards, turn the robot's gun 90 degrees to the right turnGunLeftRadians(-Math.PI / 2);

Parameters:
radians - the amount of radians to turn the robot's gun to the left. If radians > 0 the robot's gun will turn left. If radians < 0 the robot's gun will turn right. If radians = 0 the robot's gun will not turn, but execute.
See Also:
Robot.turnGunLeft(double), Robot.turnGunRight(double), turnGunRightRadians(double), Robot.turnLeft(double), turnLeftRadians(double), Robot.turnRight(double), turnRightRadians(double), Robot.turnRadarLeft(double), turnRadarLeftRadians(double), Robot.turnRadarRight(double), turnRadarRightRadians(double), Robot.setAdjustGunForRobotTurn(boolean)

turnGunRightRadians

public void turnGunRightRadians(double radians)
Immediately turns the robot's gun to the right by radians. This call executes immediately, and does not return until it is complete, i.e. when the angle remaining in the gun's turn is 0.

Note that both positive and negative values can be given as input, where negative values means that the robot's gun is set to turn left instead of right.

Example:

   // Turn the robot's gun 180 degrees to the right
   turnGunRightRadians(Math.PI);
 

// Afterwards, turn the robot's gun 90 degrees to the left turnGunRightRadians(-Math.PI / 2);

Parameters:
radians - the amount of radians to turn the robot's gun to the right. If radians > 0 the robot's gun will turn right. If radians < 0 the robot's gun will turn left. If radians = 0 the robot's gun will not turn, but execute.
See Also:
Robot.turnGunRight(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), Robot.turnLeft(double), turnLeftRadians(double), Robot.turnRight(double), turnRightRadians(double), Robot.turnRadarLeft(double), turnRadarLeftRadians(double), Robot.turnRadarRight(double), turnRadarRightRadians(double), Robot.setAdjustGunForRobotTurn(boolean)

turnRadarLeftRadians

public void turnRadarLeftRadians(double radians)
Immediately turns the robot's radar to the left by radians.

This call executes immediately, and does not return until it is complete, i.e. when the angle remaining in the radar's turn is 0.

Note that both positive and negative values can be given as input, where negative values means that the robot's radar is set to turn right instead of left.

Example:

   // Turn the robot's radar 180 degrees to the left
   turnRadarLeftRadians(Math.PI);
 

// Afterwards, turn the robot's radar 90 degrees to the right turnRadarLeftRadians(-Math.PI / 2);

Parameters:
radians - the amount of radians to turn the robot's radar to the left. If radians > 0 the robot's radar will turn left. If radians < 0 the robot's radar will turn right. If radians = 0 the robot's radar will not turn, but execute.
See Also:
Robot.turnRadarLeft(double), Robot.turnRadarRight(double), turnGunRightRadians(double), Robot.turnLeft(double), turnLeftRadians(double), Robot.turnRight(double), turnRightRadians(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), Robot.turnGunRight(double), turnGunRightRadians(double), Robot.setAdjustRadarForRobotTurn(boolean), Robot.setAdjustRadarForGunTurn(boolean)

turnRadarRightRadians

public void turnRadarRightRadians(double radians)
Immediately turns the robot's radar to the right by radians. This call executes immediately, and does not return until it is complete, i.e. when the angle remaining in the radar's turn is 0.

Note that both positive and negative values can be given as input, where negative values means that the robot's radar is set to turn left instead of right.

Example:

   // Turn the robot's radar 180 degrees to the right
   turnRadarRightRadians(Math.PI);
 

// Afterwards, turn the robot's radar 90 degrees to the left turnRadarRightRadians(-Math.PI / 2);

Parameters:
radians - the amount of radians to turn the robot's radar to the right. If radians > 0 the robot's radar will turn right. If radians < 0 the robot's radar will turn left. If radians = 0 the robot's radar will not turn, but execute.
See Also:
Robot.turnRadarRight(double), Robot.turnRadarLeft(double), turnGunLeftRadians(double), Robot.turnLeft(double), turnLeftRadians(double), Robot.turnRight(double), turnRightRadians(double), Robot.turnGunLeft(double), turnGunLeftRadians(double), Robot.turnGunRight(double), turnGunRightRadians(double), Robot.setAdjustRadarForRobotTurn(boolean), Robot.setAdjustRadarForGunTurn(boolean)

getGunTurnRemainingRadians

public double getGunTurnRemainingRadians()
Returns the angle remaining in the gun's turn, in radians.

This call returns both positive and negative values. Positive values means that the gun is currently turning to the right. Negative values means that the gun is currently turning to the left.

Returns:
the angle remaining in the gun's turn, in radians
See Also:
AdvancedRobot.getGunTurnRemaining(), getTurnRemaining(), getTurnRemainingRadians(), getRadarTurnRemaining(), getRadarTurnRemainingRadians()

getRadarTurnRemainingRadians

public double getRadarTurnRemainingRadians()
Returns the angle remaining in the radar's turn, in radians.

This call returns both positive and negative values. Positive values means that the radar is currently turning to the right. Negative values means that the radar is currently turning to the left.

Returns:
the angle remaining in the radar's turn, in radians
See Also:
AdvancedRobot.getRadarTurnRemaining(), getTurnRemaining(), getTurnRemainingRadians(), getGunTurnRemaining(), getGunTurnRemainingRadians()

getTurnRemainingRadians

public double getTurnRemainingRadians()
Returns the angle remaining in the robot's turn, in radians.

This call returns both positive and negative values. Positive values means that the robot is currently turning to the right. Negative values means that the robot is currently turning to the left.

Returns:
the angle remaining in the robot's turn, in radians
See Also:
AdvancedRobot.getTurnRemaining(), getGunTurnRemaining(), getGunTurnRemainingRadians(), getRadarTurnRemaining(), getRadarTurnRemainingRadians()