## robocode
Class AdvancedRobot

    java.lang.Object
      robocode._RobotBase
          robocode._Robot
              robocode.Robot
                  robocode._AdvancedRobot
                      robocode._AdvancedRadiansRobot
                          robocode.AdvancedRobot

All Implemented Interfaces:
  Runnable, IAdvancedEvents, IAdvancedRobot, IBasicEvents, IBasicEvents2, IBasicEvents3, IBasicRobot, IInteractiveEvents, IInteractiveRobot, IPaintEvents, IPaintRobot

Direct Known Subclasses:
  TeamRobot

    public class AdvancedRobot

extends _AdvancedRadiansRobot
implements IAdvancedRobot, IAdvancedEvents

A more advanced type of robot than Robot that allows non-blocking calls, custom events, and writes to the filesystem.

If you have not already, you should create a `Robot` first.

Author:
  Mathew A. Nelson (original), Flemming N. Larsen (contributor), Robert D. Maupin (contributor), Pavel Savara (contributor)
See Also:
  robocode.sourceforge.net, Building your first robot, `JuniorRobot`, `Robot`, `TeamRobot`, `Droid`

Field Summary

Fields inherited from class robocode._RobotBase
`out`

Constructor Summary
`AdvancedRobot()`

Method Summary
`void` `addCustomEvent(Condition condition)` Registers a custom event to be called when a condition is met.
`void` `clearAllEvents()` Clears out any pending events in the robot's event queue immediately.
`void` `execute()` Executes any pending actions, or continues executing actions that are in process.
`IAdvancedEvents` `getAdvancedEventListener()` Do not call this method!
`Vector<Event>` `getAllEvents()` Returns a vector containing all events currently in the robot's queue.
`Vector<BulletHitBulletEvent>` `getBulletHitBulletEvents()` Returns a vector containing all BulletHitBulletEvents currently in the robot's queue.
`Vector<BulletHitEvent>` `getBulletHitEvents()` Returns a vector containing all BulletHitEvents currently in the robot's queue.
`Vector<BulletMissedEvent>` `getBulletMissedEvents()` Returns a vector containing all BulletMissedEvents currently in the robot's queue.
`File` `getDataDirectory()` Returns a file representing a data directory for the robot, which can be written to using `RobocodeFileOutputStream` or `RobocodeFileWriter`.
`File` `getDataFile(String filename)` Returns a file in your data directory that you can write to using `RobocodeFileOutputStream` or `RobocodeFileWriter`.
`long` `getDataQuotaAvailable()` Returns the data quota available in your data directory, i.e. the amount of bytes left in the data directory for the robot.
`double` `getDistanceRemaining()` Returns the distance remaining in the robot's current move measured in pixels.
`int` `getEventPriority(String eventClass)` Returns the current priority of a class of events.
`double` `getGunHeadingRadians()` Returns the direction that the robot's gun is facing, in radians.
`double` `getGunTurnRemaining()` Returns the angle remaining in the gun's turn, in degrees.
`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.
`Vector<HitByBulletEvent>` `getHitByBulletEvents()` Returns a vector containing all HitByBulletEvents currently in the robot's queue.
`Vector<HitRobotEvent>` `getHitRobotEvents()` Returns a vector containing all HitRobotEvents currently in the robot's queue.
`Vector<HitWallEvent>` `getHitWallEvents()` Returns a vector containing all HitWallEvents currently in the robot's queue.
`double` `getRadarHeadingRadians()` Returns the direction that the robot's radar is facing, in radians.
`double` `getRadarTurnRemaining()` Returns the angle remaining in the radar's turn, in degrees.
`double` `getRadarTurnRemainingRadians()` Returns the angle remaining in the radar's turn, in radians.
`Vector<RobotDeathEvent>` `getRobotDeathEvents()` Returns a vector containing all RobotDeathEvents currently in the robot's queue.
`Vector<ScannedRobotEvent>` `getScannedRobotEvents()` Returns a vector containing all ScannedRobotEvents currently in the robot's queue.
`Vector<StatusEvent>` `getStatusEvents()` Returns a vector containing all StatusEvents currently in the robot's queue.
`double` `getTurnRemaining()` Returns the angle remaining in the robots's turn, in degrees.
`double` `getTurnRemainingRadians()` Returns the angle remaining in the robot's turn, in radians.
`boolean` `isAdjustGunForRobotTurn()` Checks if the gun is set to adjust for the robot turning, i.e. to turn independent from the robot's body turn.
`boolean` `isAdjustRadarForGunTurn()` Checks if the radar is set to adjust for the gun turning, i.e. to turn independent from the gun's turn.
`boolean` `isAdjustRadarForRobotTurn()` Checks if the radar is set to adjust for the robot turning, i.e. to turn independent from the robot's body turn.
`void` `onCustomEvent(CustomEvent event)` This method is called when a custom condition is met.
`void` `onDeath(DeathEvent event)` This method is called if your robot dies.
`void` `onSkippedTurn(SkippedTurnEvent event)` This method is called if the robot is using too much time between actions.
`void` `removeCustomEvent(Condition condition)` Removes a custom event that was previously added by calling `addCustomEvent(Condition)`.
`void` `setAhead(double distance)` Sets the robot to move ahead (forward) by distance measured in pixels when the next execution takes place.
`void` `setBack(double distance)` Sets the robot to move back by distance measured in pixels when the next execution takes place.
`void` `setEventPriority(String eventClass, int priority)` Sets the priority of a class of events.
`void` `setFire(double power)` Sets the gun to fire a bullet when the next execution takes place.
`Bullet` `setFireBullet(double power)` Sets the gun to fire a bullet when the next execution takes place.
`void` `setInterruptible(boolean interruptible)` Call this during an event handler to allow new events of the same priority to restart the event handler.
`void` `setMaxTurnRate(double newMaxTurnRate)` Sets the maximum turn rate of the robot measured in degrees if the robot should turn slower than `Rules.MAX_TURN_RATE` (10 degress/turn).
`void` `setMaxVelocity(double newMaxVelocity)` Sets the maximum velocity of the robot measured in pixels/turn if the robot should move slower than `Rules.MAX_VELOCITY` (8 pixels/turn).
`void` `setResume()` Sets the robot to resume the movement stopped by `stop()` or `setStop()`, if any.
`void` `setStop()` This call is identical to `stop()`, but returns immediately, and will not execute until you call `execute()` or take an action that executes.
`void` `setStop(boolean overwrite)` This call is identical to `stop(boolean)`, but returns immediately, and will not execute until you call `execute()` or take an action that executes.
`void` `setTurnGunLeft(double degrees)` Sets the robot's gun to turn left by degrees when the next execution takes place.
`void` `setTurnGunLeftRadians(double radians)` Sets the robot's gun to turn left by radians when the next execution takes place.
`void` `setTurnGunRight(double degrees)` Sets the robot's gun to turn right by degrees 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` `setTurnLeft(double degrees)` Sets the robot's body to turn left by degrees 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` `setTurnRadarLeft(double degrees)` Sets the robot's radar to turn left by degrees 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` `setTurnRadarRight(double degrees)` Sets the robot's radar to turn right by degrees 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` `setTurnRight(double degrees)` Sets the robot's body to turn right by degrees 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.
`void` `waitFor(Condition condition)` Does not return until a condition is met, i.e. when a `Condition.test()` returns `true`.

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, 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, onHitByBullet, onHitRobot, onHitWall, onKeyPressed, onKeyReleased, onKeyTyped, onMouseClicked, onMouseDragged, onMouseEntered, onMouseExited, onMouseMoved, onMousePressed, onMouseReleased, onMouseWheelMoved, onPaint, onRobotDeath, onRoundEnded, onScannedRobot, onStatus, onWin, resume, run, scan, setAdjustGunForRobotTurn, setAdjustRadarForGunTurn, setAdjustRadarForRobotTurn, setAllColors, setBodyColor, setBulletColor, setColors, setColors, setDebugProperty, 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, setRadarImageName, setRobotImageName`

Methods inherited from class robocode._RobotBase
`finalize, 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
`getBasicEventListener, getRobotRunnable, setOut, setPeer`

Constructor Detail

### AdvancedRobot

    public AdvancedRobot()

Method Detail

### getDistanceRemaining

    public double getDistanceRemaining()

  Returns the distance remaining in the robot's current move measured in pixels.

  This call returns both positive and negative values. Positive values means that the robot is currently moving forwards. Negative values means that the robot is currently moving backwards. If the returned value is 0, the robot currently stands still.

  Returns:
    the distance remaining in the robot's current move measured in pixels.
  See Also:
    `getTurnRemaining()`, `getTurnRemainingRadians()`, `getGunTurnRemaining()`, `getGunTurnRemainingRadians()`, `getRadarTurnRemaining()`, `getRadarTurnRemainingRadians()`

### getTurnRemaining

    public double getTurnRemaining()

  Returns the angle remaining in the robots's turn, in degrees.

  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. If the returned value is 0, the robot is currently not turning.

  Returns:
    the angle remaining in the robots's turn, in degrees
  See Also:
    `getTurnRemainingRadians()`, `getDistanceRemaining()`, `getGunTurnRemaining()`, `getGunTurnRemainingRadians()`, `getRadarTurnRemaining()`, `getRadarTurnRemainingRadians()`

### getGunTurnRemaining

    public double getGunTurnRemaining()

  Returns the angle remaining in the gun's turn, in degrees.

  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. If the returned value is 0, the gun is currently not turning.

  Returns:
    the angle remaining in the gun's turn, in degrees
  See Also:
    `getGunTurnRemainingRadians()`, `getDistanceRemaining()`, `getTurnRemaining()`, `getTurnRemainingRadians()`, `getRadarTurnRemaining()`, `getRadarTurnRemainingRadians()`

### getRadarTurnRemaining

    public double getRadarTurnRemaining()

  Returns the angle remaining in the radar's turn, in degrees.

  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. If the returned value is 0, the radar is currently not turning.

  Returns:
    the angle remaining in the radar's turn, in degrees
  See Also:
    `getRadarTurnRemainingRadians()`, `getDistanceRemaining()`, `getGunTurnRemaining()`, `getGunTurnRemainingRadians()`, `getRadarTurnRemaining()`, `getRadarTurnRemainingRadians()`

### setAhead

    public void setAhead(double distance)

  Sets the robot to move ahead (forward) by distance measured in pixels 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 positive values means that the robot is set to move ahead, and negative values means that the robot is set to move back. If 0 is given as input, the robot will stop its movement, but will have to decelerate till it stands still, and will thus not be able to stop its movement immediately, but eventually.

  Example:

         // Set the robot to move 50 pixels ahead
         setAhead(50);

         // Set the robot to move 100 pixels back
         // (overrides the previous order)
         setAhead(-100);

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

  Parameters:
    `distance` - the distance to move measured in pixels. If `distance` > 0 the robot is set to move ahead. If `distance` < 0 the robot is set to move back. If `distance` = 0 the robot is set to stop its movement.
  See Also:
    `ahead(double)`, `back(double)`, `setBack(double)`

### setBack

    public void setBack(double distance)

  Sets the robot to move back by distance measured in pixels 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 positive values means that the robot is set to move back, and negative values means that the robot is set to move ahead. If 0 is given as input, the robot will stop its movement, but will have to decelerate till it stands still, and will thus not be able to stop its movement immediately, but eventually.

  Example:

         // Set the robot to move 50 pixels back
         setBack(50);

         // Set the robot to move 100 pixels ahead
         // (overrides the previous order)
         setBack(-100);

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

  Parameters:
    `distance` - the distance to move measured in pixels. If `distance` > 0 the robot is set to move back. If `distance` < 0 the robot is set to move ahead. If `distance` = 0 the robot is set to stop its movement.
  See Also:
    `back(double)`, `ahead(double)`, `setAhead(double)`

### setTurnLeft

    public void setTurnLeft(double degrees)

  Sets the robot's body to turn left by degrees 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
         setTurnLeft(180);

         // Set the robot to turn 90 degrees to the right instead of left
         // (overrides the previous order)
         setTurnLeft(-90);

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

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

### setTurnRight

    public void setTurnRight(double degrees)

  Sets the robot's body to turn right by degrees 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
         setTurnRight(180);

         // Set the robot to turn 90 degrees to the left instead of right
         // (overrides the previous order)
         setTurnRight(-90);

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

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

### setFire

    public void setFire(double power)

  Sets the gun to fire a bullet when the next execution takes place. The bullet will travel in the direction the gun is pointing.

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

  The specified bullet power is an amount of energy that will be taken from the robot's energy. Hence, the more power you want to spend on the bullet, the more energy is taken from your robot.

  The bullet will do (4 * power) damage if it hits another robot. If power is greater than 1, it will do an additional 2 * (power - 1) damage. You will get (3 * power) back if you hit the other robot. You can call Rules#getBulletDamage(double)} for getting the damage that a bullet with a specific bullet power will do.

  The specified bullet power should be between `Rules.MIN_BULLET_POWER` and `Rules.MAX_BULLET_POWER`.

  Note that the gun cannot fire if the gun is overheated, meaning that `Robot.getGunHeat()` returns a value > 0.

  An event is generated when the bullet hits a robot, wall, or another bullet.

  Example:

         // Fire a bullet with maximum power if the gun is ready
         if (getGunHeat() == 0) {
             setFire(Rules.MAX_BULLET_POWER);
         }
         ...
         execute();

  Parameters:
    `power` - the amount of energy given to the bullet, and subtracted from the robot's energy.
  See Also:
    `setFireBullet(double)`, `fire(double)`, `fireBullet(double)`, `getGunHeat()`, `getGunCoolingRate()`, `onBulletHit(BulletHitEvent)`, `onBulletHitBullet(BulletHitBulletEvent)`, `onBulletMissed(BulletMissedEvent)`

### setFireBullet

    public Bullet setFireBullet(double power)

  Sets the gun to fire a bullet when the next execution takes place. The bullet will travel in the direction the gun is pointing.

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

  The specified bullet power is an amount of energy that will be taken from the robot's energy. Hence, the more power you want to spend on the bullet, the more energy is taken from your robot.

  The bullet will do (4 * power) damage if it hits another robot. If power is greater than 1, it will do an additional 2 * (power - 1) damage. You will get (3 * power) back if you hit the other robot. You can call `Rules.getBulletDamage(double)` for getting the damage that a bullet with a specific bullet power will do.

  The specified bullet power should be between `Rules.MIN_BULLET_POWER` and `Rules.MAX_BULLET_POWER`.

  Note that the gun cannot fire if the gun is overheated, meaning that `Robot.getGunHeat()` returns a value > 0.

  A event is generated when the bullet hits a robot (`BulletHitEvent`), wall (`BulletMissedEvent`), or another bullet (`BulletHitBulletEvent`).

  Example:

         Bullet bullet = null;

         // Fire a bullet with maximum power if the gun is ready
         if (getGunHeat() == 0) {
             bullet = setFireBullet(Rules.MAX_BULLET_POWER);
         }
         ...
         execute();
         ...
         // Get the velocity of the bullet
         if (bullet != null) {
             double bulletVelocity = bullet.getVelocity();
         }

  Parameters:
    `power` - the amount of energy given to the bullet, and subtracted from the robot's energy.
  Returns:
    a `Bullet` that contains information about the bullet if it was actually fired, which can be used for tracking the bullet after it has been fired. If the bullet was not fired, `null` is returned.
  See Also:
    `setFire(double)`, `Bullet`, `fire(double)`, `fireBullet(double)`, `getGunHeat()`, `getGunCoolingRate()`, `onBulletHit(BulletHitEvent)`, `onBulletHitBullet(BulletHitBulletEvent)`, `onBulletMissed(BulletMissedEvent)`

### addCustomEvent

    public void addCustomEvent(Condition condition)

  Registers a custom event to be called when a condition is met. When you are finished with your condition or just want to remove it you must call `removeCustomEvent(Condition)`.

  Example:

         // Create the condition for our custom event
         Condition triggerHitCondition = new Condition("triggerhit") {
             public boolean test() {
                 return (getEnergy() <= trigger);
             }
         }

         // Add our custom event based on our condition
         addCustomEvent(triggerHitCondition);

  Parameters:
    `condition` - the condition that must be met.
  Throws:
    `NullPointerException` - if the condition parameter has been set to `null`.
  See Also:
    `Condition`, `removeCustomEvent(Condition)`

### removeCustomEvent

    public void removeCustomEvent(Condition condition)

  Removes a custom event that was previously added by calling `addCustomEvent(Condition)`.

  Example:

         // Create the condition for our custom event
         Condition triggerHitCondition = new Condition("triggerhit") {
             public boolean test() {
                 return (getEnergy() <= trigger);
             }
         }

         // Add our custom event based on our condition
         addCustomEvent(triggerHitCondition);
         ...
         do something with your robot
         ...
         // Remove the custom event based on our condition
         removeCustomEvent(triggerHitCondition);

  Parameters:
    `condition` - the condition that was previous added and that must be removed now.
  Throws:
    `NullPointerException` - if the condition parameter has been set to `null`.
  See Also:
    `Condition`, `addCustomEvent(Condition)`

### clearAllEvents

    public void clearAllEvents()

  Clears out any pending events in the robot's event queue immediately.

  See Also:
    `getAllEvents()`

### execute

    public void execute()

  Executes any pending actions, or continues executing actions that are in process. This call returns after the actions have been started.

  Note that advanced robots must call this function in order to execute pending set* calls like e.g. `setAhead(double)`, `setFire(double)`, `setTurnLeft(double)` etc. Otherwise, these calls will never get executed.

  In this example the robot will move while turning:

         setTurnRight(90);
         setAhead(100);
         execute();

         while (getDistanceRemaining() > 0 && getTurnRemaining() > 0) {
             execute();
         }

### getAllEvents

    public Vector<Event> getAllEvents()

  Returns a vector containing all events currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (Event event : getAllEvents()) {
             if (event instanceof HitRobotEvent) {
                 // do something with the event
             } else if (event instanceof HitByBulletEvent) {
                 // do something with the event
             }
         }

  Returns:
    a vector containing all events currently in the robot's queue
  See Also:
    `Event`, `clearAllEvents()`, `getStatusEvents()`, `getScannedRobotEvents()`, `getBulletHitEvents()`, `getBulletMissedEvents()`, `getBulletHitBulletEvents()`, `getRobotDeathEvents()`

### getBulletHitBulletEvents

    public Vector<BulletHitBulletEvent> getBulletHitBulletEvents()

  Returns a vector containing all BulletHitBulletEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (BulletHitBulletEvent event : getBulletHitBulletEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all BulletHitBulletEvents currently in the robot's queue
  See Also:
    `onBulletHitBullet(BulletHitBulletEvent)`, `BulletHitBulletEvent`, `getAllEvents()`

### getBulletHitEvents

    public Vector<BulletHitEvent> getBulletHitEvents()

  Returns a vector containing all BulletHitEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (BulletHitEvent event: getBulletHitEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all BulletHitEvents currently in the robot's queue
  See Also:
    `onBulletHit(BulletHitEvent)`, `BulletHitEvent`, `getAllEvents()`

### getBulletMissedEvents

    public Vector<BulletMissedEvent> getBulletMissedEvents()

  Returns a vector containing all BulletMissedEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (BulletMissedEvent event : getBulletMissedEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all BulletMissedEvents currently in the robot's queue
  See Also:
    `onBulletMissed(BulletMissedEvent)`, `BulletMissedEvent`, `getAllEvents()`

### getDataDirectory

    public File getDataDirectory()

  Returns a file representing a data directory for the robot, which can be written to using `RobocodeFileOutputStream` or `RobocodeFileWriter`.

  The system will automatically create the directory for you, so you do not need to create it by yourself.

  Returns:
    a file representing the data directory for your robot
  See Also:
    `getDataFile(String)`, `RobocodeFileOutputStream`, `RobocodeFileWriter`

### getDataFile

    public File getDataFile(String filename)

  Returns a file in your data directory that you can write to using `RobocodeFileOutputStream` or `RobocodeFileWriter`.

  The system will automatically create the directory for you, so you do not need to create it by yourself.

  Please notice that the max. size of your data file is set to 200000 (~195 KB).

  See the `sample.SittingDuck` to see an example of how to use this method.

  Parameters:
    `filename` - the file name of the data file for your robot
  Returns:
    a file representing the data file for your robot
  See Also:
    `getDataDirectory()`, `RobocodeFileOutputStream`, `RobocodeFileWriter`

### getDataQuotaAvailable

    public long getDataQuotaAvailable()

  Returns the data quota available in your data directory, i.e. the amount of bytes left in the data directory for the robot.

  Returns:
    the amount of bytes left in the robot's data directory
  See Also:
    `getDataDirectory()`, `getDataFile(String)`

### getEventPriority

    public int getEventPriority(String eventClass)

  Returns the current priority of a class of events. An event priority is a value from 0 - 99. The higher value, the higher priority.

  Example:

         int myHitRobotPriority = getEventPriority("HitRobotEvent");

  The default priorities are, from highest to lowest:

         RoundEndedEvent:      100 (reserved)
         BattleEndedEvent:     100 (reserved)
         WinEvent:             100 (reserved)
         SkippedTurnEvent:     100 (reserved)
         StatusEvent:           99
         Key and mouse events:  98
         CustomEvent:           80 (default value)
         MessageEvent:          75
         RobotDeathEvent:       70
         BulletMissedEvent:     60
         BulletHitBulletEvent:  55
         BulletHitEvent:        50
         HitByBulletEvent:      40
         HitWallEvent:          30
         HitRobotEvent:         20
         ScannedRobotEvent:     10
         PaintEvent:             5
         DeathEvent:            -1 (reserved)

  Parameters:
    `eventClass` - the name of the event class (string)
  Returns:
    the current priority of a class of events
  See Also:
    `setEventPriority(String, int)`

### getHitByBulletEvents

    public Vector<HitByBulletEvent> getHitByBulletEvents()

  Returns a vector containing all HitByBulletEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (HitByBulletEvent event : getHitByBulletEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all HitByBulletEvents currently in the robot's queue
  See Also:
    `onHitByBullet(HitByBulletEvent)`, `HitByBulletEvent`, `getAllEvents()`

### getHitRobotEvents

    public Vector<HitRobotEvent> getHitRobotEvents()

  Returns a vector containing all HitRobotEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (HitRobotEvent event : getHitRobotEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all HitRobotEvents currently in the robot's queue
  See Also:
    `onHitRobot(HitRobotEvent)`, `HitRobotEvent`, `getAllEvents()`

### getHitWallEvents

    public Vector<HitWallEvent> getHitWallEvents()

  Returns a vector containing all HitWallEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (HitWallEvent event : getHitWallEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all HitWallEvents currently in the robot's queue
  See Also:
    `onHitWall(HitWallEvent)`, `HitWallEvent`, `getAllEvents()`

### getRobotDeathEvents

    public Vector<RobotDeathEvent> getRobotDeathEvents()

  Returns a vector containing all RobotDeathEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (RobotDeathEvent event : getRobotDeathEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all RobotDeathEvents currently in the robot's queue
  See Also:
    `onRobotDeath(RobotDeathEvent)`, `RobotDeathEvent`, `getAllEvents()`

### getScannedRobotEvents

    public Vector<ScannedRobotEvent> getScannedRobotEvents()

  Returns a vector containing all ScannedRobotEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (ScannedRobotEvent event : getScannedRobotEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all ScannedRobotEvents currently in the robot's queue
  See Also:
    `onScannedRobot(ScannedRobotEvent)`, `ScannedRobotEvent`, `getAllEvents()`

### getStatusEvents

    public Vector<StatusEvent> getStatusEvents()

  Returns a vector containing all StatusEvents currently in the robot's queue. You might, for example, call this while processing another event.

  Example:

         for (StatusEvent event : getStatusEvents()) {
             // do something with the event
         }

  Returns:
    a vector containing all StatusEvents currently in the robot's queue
  Since:
    1.6.1
  See Also:
    `onStatus(StatusEvent)`, `StatusEvent`, `getAllEvents()`

### isAdjustGunForRobotTurn

    public boolean isAdjustGunForRobotTurn()

  Checks if the gun is set to adjust for the robot turning, i.e. to turn independent from the robot's body turn.

  This call returns `true` if the gun is set to turn independent of the turn of the robot's body. Otherwise, `false` is returned, meaning that the gun is set to turn with the robot's body turn.

  Returns:
    `true` if the gun is set to turn independent of the robot turning; `false` if the gun is set to turn with the robot turning
  See Also:
    `setAdjustGunForRobotTurn(boolean)`, `isAdjustRadarForRobotTurn()`, `isAdjustRadarForGunTurn()`

### isAdjustRadarForRobotTurn

    public boolean isAdjustRadarForRobotTurn()

  Checks if the radar is set to adjust for the robot turning, i.e. to turn independent from the robot's body turn.

  This call returns `true` if the radar is set to turn independent of the turn of the robot. Otherwise, `false` is returned, meaning that the radar is set to turn with the robot's turn.

  Returns:
    `true` if the radar is set to turn independent of the robot turning; `false` if the radar is set to turn with the robot turning
  See Also:
    `setAdjustRadarForRobotTurn(boolean)`, `isAdjustGunForRobotTurn()`, `isAdjustRadarForGunTurn()`

### isAdjustRadarForGunTurn

    public boolean isAdjustRadarForGunTurn()

  Checks if the radar is set to adjust for the gun turning, i.e. to turn independent from the gun's turn.

  This call returns `true` if the radar is set to turn independent of the turn of the gun. Otherwise, `false` is returned, meaning that the radar is set to turn with the gun's turn.

  Returns:
    `true` if the radar is set to turn independent of the gun turning; `false` if the radar is set to turn with the gun turning
  See Also:
    `setAdjustRadarForGunTurn(boolean)`, `isAdjustGunForRobotTurn()`, `isAdjustRadarForRobotTurn()`

### onCustomEvent

    public void onCustomEvent(CustomEvent event)

  This method is called when a custom condition is met.

  See the sample robots for examples of use, e.g. the `sample.Target` robot.

  Specified by:
    `onCustomEvent` in interface `IAdvancedEvents`
  Parameters:
    `event` - the custom event that occurred
  See Also:
    `addCustomEvent(robocode.Condition)`, `CustomEvent`, `Event`

### setEventPriority

    public void setEventPriority(String eventClass,
                                 int priority)

  Sets the priority of a class of events.

  Events are sent to the onXXX handlers in order of priority. Higher priority events can interrupt lower priority events. For events with the same priority, newer events are always sent first. Valid priorities are 0 - 99, where 100 is reserved and 80 is the default priority.

  Example:

         setEventPriority("RobotDeathEvent", 15);

  The default priorities are, from highest to lowest:

               WinEvent:             100 (reserved)
               SkippedTurnEvent:     100 (reserved)
         StatusEvent:           99
               CustomEvent:           80
               MessageEvent:          75
               RobotDeathEvent:       70
               BulletMissedEvent:     60
               BulletHitBulletEvent:  55
               BulletHitEvent:        50
               HitByBulletEvent:      40
               HitWallEvent:          30
               HitRobotEvent:         20
               ScannedRobotEvent:     10
         PaintEvent:             5
               DeathEvent:            -1 (reserved)

  Note that you cannot change the priority for events with the special priority value -1 or 100 (reserved) as these event are system events. Also note that you cannot change the priority of CustomEvent. Instead you must change the priority of the condition(s) for your custom event(s).

  Parameters:
    `eventClass` - the name of the event class (string) to set the priority for
    `priority` - the new priority for that event class
  Since:
    1.5, the priority of DeathEvent was changed from 100 to -1 in order to let robots process pending events on its event queue before it dies. When the robot dies, it will not be able to process events.
  See Also:
    `getEventPriority(String)`, `setInterruptible(boolean)`

### setInterruptible

    public void setInterruptible(boolean interruptible)

  Call this during an event handler to allow new events of the same priority to restart the event handler.

  Example:

         public void onScannedRobot(ScannedRobotEvent e) {
             fire(1);
             setInterruptible(true);
             ahead(100); // If you see a robot while moving ahead,
                         // this handler will start from the top
                         // Without setInterruptible(true), we wouldn't
                         // receive scan events at all!
             // We'll only get here if we don't see a robot during the move.
             out.println("Ok, I can't see anyone");
         }

  Overrides:
    `setInterruptible` in class `_Robot`
  Parameters:
    `interruptible` - `true` if the event handler should be interrupted if new events of the same priority occurs; `false` otherwise
  See Also:
    `setEventPriority(String, int)`, `onScannedRobot(ScannedRobotEvent)`

### setMaxTurnRate

    public void setMaxTurnRate(double newMaxTurnRate)

  Sets the maximum turn rate of the robot measured in degrees if the robot should turn slower than `Rules.MAX_TURN_RATE` (10 degress/turn).

  Parameters:
    `newMaxTurnRate` - the new maximum turn rate of the robot measured in degrees. Valid values are 0 - `Rules.MAX_TURN_RATE`
  See Also:
    `turnRight(double)`, `turnLeft(double)`, `setTurnRight(double)`, `setTurnLeft(double)`, `setMaxVelocity(double)`

### setMaxVelocity

    public void setMaxVelocity(double newMaxVelocity)

  Sets the maximum velocity of the robot measured in pixels/turn if the robot should move slower than `Rules.MAX_VELOCITY` (8 pixels/turn).

  Parameters:
    `newMaxVelocity` - the new maximum turn rate of the robot measured in pixels/turn. Valid values are 0 - `Rules.MAX_VELOCITY`
  See Also:
    `Robot.ahead(double)`, `setAhead(double)`, `Robot.back(double)`, `setBack(double)`, `setMaxTurnRate(double)`

### setResume

    public void setResume()

  Sets the robot to resume the movement stopped by `stop()` or `setStop()`, if any.

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

  See Also:
    `resume()`, `stop()`, `stop(boolean)`, `setStop()`, `setStop(boolean)`, `execute()`

### setStop

    public void setStop()

  This call is identical to `stop()`, but returns immediately, and will not execute until you call `execute()` or take an action that executes.

  If there is already movement saved from a previous stop, this will have no effect.

  This call is equivalent to calling `setStop(false)`;

  See Also:
    `stop()`, `stop(boolean)`, `resume()`, `setResume()`, `setStop(boolean)`, `execute()`

### setStop

    public void setStop(boolean overwrite)

  This call is identical to `stop(boolean)`, but returns immediately, and will not execute until you call `execute()` or take an action that executes.

  If there is already movement saved from a previous stop, you can overwrite it by calling `setStop(true)`.

  Parameters:
    `overwrite` - `true` if the movement saved from a previous stop should be overwritten; `false` otherwise.
  See Also:
    `stop()`, `stop(boolean)`, `resume()`, `setResume()`, `setStop()`, `execute()`

### setTurnGunLeft

    public void setTurnGunLeft(double degrees)

  Sets the robot's gun to turn left by degrees 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
         setTurnGunLeft(180);

         // Set the gun to turn 90 degrees to the right instead of left
         // (overrides the previous order)
         setTurnGunLeft(-90);

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

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

### setTurnGunRight

    public void setTurnGunRight(double degrees)

  Sets the robot's gun to turn right by degrees 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
         setTurnGunRight(180);

         // Set the gun to turn 90 degrees to the left instead of right
         // (overrides the previous order)
         setTurnGunRight(-90);

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

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

### setTurnRadarLeft

    public void setTurnRadarLeft(double degrees)

  Sets the robot's radar to turn left by degrees 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
         setTurnRadarLeft(180);

         // Set the radar to turn 90 degrees to the right instead of left
         // (overrides the previous order)
         setTurnRadarLeft(-90);

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

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

### setTurnRadarRight

    public void setTurnRadarRight(double degrees)

  Sets the robot's radar to turn right by degrees 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
         setTurnRadarRight(180);

         // Set the radar to turn 90 degrees to the right instead of right
         // (overrides the previous order)
         setTurnRadarRight(-90);

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

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

### waitFor

    public void waitFor(Condition condition)

  Does not return until a condition is met, i.e. when a `Condition.test()` returns `true`.

  This call executes immediately.

  See the `sample.Crazy` robot for how this method can be used.

  Parameters:
    `condition` - the condition that must be met before this call returns
  See Also:
    `Condition`, `Condition.test()`

### onDeath

    public void onDeath(DeathEvent event)

  This method is called if your robot dies.

  You should override it in your robot if you want to be informed of this event. Actions will have no effect if called from this section. The intent is to allow you to perform calculations or print something out when the robot is killed.

  Specified by:
    `onDeath` in interface `IBasicEvents`
  Overrides:
    `onDeath` in class `Robot`
  Parameters:
    `event` - the death event set by the game
  See Also:
    `DeathEvent`, `Event`

### onSkippedTurn

    public void onSkippedTurn(SkippedTurnEvent event)

  This method is called if the robot is using too much time between actions. When this event occur, the robot's turn is skipped, meaning that it cannot take action anymore in this turn.

  If you receive 30 skipped turn event, your robot will be removed from the round and loose the round.

  You will only receive this event after taking an action. So a robot in an infinite loop will not receive any events, and will simply be stopped.

  No correctly working, reasonable robot should ever receive this event unless it is using too many CPU cycles.

  Specified by:
    `onSkippedTurn` in interface `IAdvancedEvents`
  Parameters:
    `event` - the skipped turn event set by the game
  See Also:
    `SkippedTurnEvent`, `Event`

### 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 / 2 means West.

  Overrides:
    `getHeadingRadians` in class `_AdvancedRadiansRobot`
  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();

  Overrides:
    `setTurnLeftRadians` in class `_AdvancedRadiansRobot`
  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();

  Overrides:
    `setTurnRightRadians` in class `_AdvancedRadiansRobot`
  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);

  Overrides:
    `turnLeftRadians` in class `_AdvancedRadiansRobot`
  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);

  Overrides:
    `turnRightRadians` in class `_AdvancedRadiansRobot`
  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 / 2 means West.

  Overrides:
    `getGunHeadingRadians` in class `_AdvancedRadiansRobot`
  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 / 2 means West.

  Overrides:
    `getRadarHeadingRadians` in class `_AdvancedRadiansRobot`
  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();

  Overrides:
    `setTurnGunLeftRadians` in class `_AdvancedRadiansRobot`
  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();

  Overrides:
    `setTurnGunRightRadians` in class `_AdvancedRadiansRobot`
  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();

  Overrides:
    `setTurnRadarLeftRadians` in class `_AdvancedRadiansRobot`
  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();

  Overrides:
    `setTurnRadarRightRadians` in class `_AdvancedRadiansRobot`
  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);

  Overrides:
    `turnGunLeftRadians` in class `_AdvancedRadiansRobot`
  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);

  Overrides:
    `turnGunRightRadians` in class `_AdvancedRadiansRobot`
  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);

  Overrides:
    `turnRadarLeftRadians` in class `_AdvancedRadiansRobot`
  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);

  Overrides:
    `turnRadarRightRadians` in class `_AdvancedRadiansRobot`
  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.

  Overrides:
    `getGunTurnRemainingRadians` in class `_AdvancedRadiansRobot`
  Returns:
    the angle remaining in the gun's turn, in radians
  See Also:
    `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.

  Overrides:
    `getRadarTurnRemainingRadians` in class `_AdvancedRadiansRobot`
  Returns:
    the angle remaining in the radar's turn, in radians
  See Also:
    `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.

  Overrides:
    `getTurnRemainingRadians` in class `_AdvancedRadiansRobot`
  Returns:
    the angle remaining in the robot's turn, in radians
  See Also:
    `getTurnRemaining()`, `getGunTurnRemaining()`, `getGunTurnRemainingRadians()`, `getRadarTurnRemaining()`, `getRadarTurnRemainingRadians()`

### getAdvancedEventListener

    public final IAdvancedEvents getAdvancedEventListener()

  Do not call this method!

  This method is called by the game to notify this robot about advanced robot event. Hence, this method must be implemented so it returns your `IAdvancedEvents` listener.

  Specified by:
    `getAdvancedEventListener` in interface `IAdvancedRobot`
  Returns:
    listener to advanced events or `null` if this robot should not receive the notifications.

Copyright © 2012 Robocode. All Rights Reserved.