robocode

Class AdvancedRobot

Implemented Interfaces:
IAdvancedEvents, IAdvancedRobot, IBasicEvents, IBasicEvents2, IBasicRobot, IInteractiveEvents, IInteractiveRobot, IPaintEvents, IPaintRobot, Runnable
Known Direct 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.

Authors:
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

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
getAllEvents()
Returns a vector containing all events currently in the robot's queue.
Vector
getBulletHitBulletEvents()
Returns a vector containing all BulletHitBulletEvents currently in the robot's queue.
Vector
getBulletHitEvents()
Returns a vector containing all BulletHitEvents currently in the robot's queue.
Vector
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.
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
getGunTurnRemaining()
Returns the angle remaining in the gun's turn, in degrees.
Vector
getHitByBulletEvents()
Returns a vector containing all HitByBulletEvents currently in the robot's queue.
Vector
getHitRobotEvents()
Returns a vector containing all HitRobotEvents currently in the robot's queue.
Vector
getHitWallEvents()
Returns a vector containing all HitWallEvents currently in the robot's queue.
double
getRadarTurnRemaining()
Returns the angle remaining in the radar's turn, in degrees.
Vector
getRobotDeathEvents()
Returns a vector containing all RobotDeathEvents currently in the robot's queue.
Vector
getScannedRobotEvents()
Returns a vector containing all ScannedRobotEvents currently in the robot's queue.
Vector
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.
boolean
isAdjustGunForRobotTurn()
Checks if the gun is set to adjust for the robot turning, i.e.
boolean
isAdjustRadarForGunTurn()
Checks if the radar is set to adjust for the gun turning, i.e.
boolean
isAdjustRadarForRobotTurn()
Checks if the radar is set to adjust for the robot turning, i.e.
void
onCustomEvent(CustomEvent event)
void
onSkippedTurn(SkippedTurnEvent event)
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
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
setTurnGunRight(double degrees)
Sets the robot's gun to turn right by degrees 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
setTurnRadarLeft(double degrees)
Sets the robot's radar to turn left by degrees 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
setTurnRight(double degrees)
Sets the robot's body to turn right by degrees when the next execution takes place.
@Override
void onDeath(DeathEvent event)
This method is called if your robot dies.
@Override
void setInterruptible(boolean interruptible)
Call this during an event handler to allow new events of the same priority to restart the event handler.
void
waitFor(Condition condition)
Does not return until a condition is met, i.e.

Methods inherited from class robocode._AdvancedRadiansRobot

getGunHeadingRadians, getGunTurnRemainingRadians, getHeadingRadians, getRadarHeadingRadians, getRadarTurnRemainingRadians, getTurnRemainingRadians, setTurnGunLeftRadians, setTurnGunRightRadians, setTurnLeftRadians, setTurnRadarLeftRadians, setTurnRadarRightRadians, setTurnRightRadians, turnGunLeftRadians, turnGunRightRadians, turnLeftRadians, turnRadarLeftRadians, turnRadarRightRadians, turnRightRadians

Methods inherited from class robocode._AdvancedRobot

double getGunHeadingDegrees, double getHeadingDegrees, double getRadarHeadingDegrees, int getMaxWaitCount, int getWaitCount, void endTurn, void setTurnGunLeftDegrees, void setTurnGunRightDegrees, void setTurnLeftDegrees, void setTurnRadarLeftDegrees, void setTurnRadarRightDegrees, void setTurnRightDegrees, void turnGunLeftDegrees, void turnGunRightDegrees, void turnLeftDegrees, void turnRadarLeftDegrees, void turnRadarRightDegrees, void 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, 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, void finalize

Methods inherited from class robocode._Robot

String getGunImageName, String getRadarImageName, String getRobotImageName, double getGunCharge, double getLife, int getBattleNum, int getNumBattles, setInterruptible, void setGunImageName, void setRadarImageName, void setRobotImageName

Methods inherited from class robocode._RobotBase

setOut, setPeer

Method Details

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.

clearAllEvents

public void clearAllEvents()
Clears out any pending events in the robot's event queue immediately.

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(); }


getAdvancedEventListener

public final IAdvancedEvents getAdvancedEventListener()
Do not call this method!

Specified by:
getAdvancedEventListener in interface IAdvancedRobot

getAllEvents

public Vector 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

getBulletHitBulletEvents

public Vector 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

getBulletHitEvents

public Vector 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

getBulletMissedEvents

public Vector 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

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

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

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

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.

getEventPriority

public int getEventPriority(String eventClass)
Parameters:
eventClass - the name of the event class (string)
Returns:
the current priority of a class of events

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

getHitByBulletEvents

public Vector 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

getHitRobotEvents

public Vector 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

getHitWallEvents

public Vector 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

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

getRobotDeathEvents

public Vector 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

getScannedRobotEvents

public Vector 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

getStatusEvents

public Vector 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

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

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

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

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

onCustomEvent

public void onCustomEvent(CustomEvent event)
Specified by:
onCustomEvent in interface IAdvancedEvents

onSkippedTurn

public void onSkippedTurn(SkippedTurnEvent event)
Specified by:
onSkippedTurn in interface IAdvancedEvents

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.

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 <320 the robot is set to move back. If distance = 0 the robot is set to stop its movement.

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 <320 the robot is set to move ahead. If distance = 0 the robot is set to stop its movement.

setEventPriority

public void setEventPriority(String eventClass,
                             int priority)
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.

setFire

public void setFire(double power)
Parameters:
power - the amount of energy given to the bullet, and subtracted from the robot's energy.

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 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.

setMaxTurnRate

public void setMaxTurnRate(double newMaxTurnRate)
Parameters:
newMaxTurnRate - the new maximum turn rate of the robot measured in degrees. Valid values are 0 - Rules.MAX_TURN_RATE

setMaxVelocity

public void setMaxVelocity(double newMaxVelocity)
Parameters:
newMaxVelocity - the new maximum turn rate of the robot measured in pixels/turn. Valid values are 0 - Rules.MAX_VELOCITY

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.


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);


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.

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 <320 the robot's gun is set to turn right. If degrees = 0 the robot's gun is set to stop turning.

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 <320 the robot's gun is set to turn left. If degrees = 0 the robot's gun is set to stop turning.

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 <320 the robot is set to turn right. If degrees = 0 the robot is set to stop turning.

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 <320 the robot's radar is set to turn right. If degrees = 0 the robot's radar is set to stop turning.

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 <320 the robot's radar is set to turn left. If degrees = 0 the robot's radar is set to stop turning.

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 <320 the robot is set to turn left. If degrees = 0 the robot is set to stop turning.

void onDeath

public @Override 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.

Parameters:
event - the death event set by the game
See Also:
DeathEvent, Event

void setInterruptible

public @Override 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");
   }
 
Parameters:
interruptible - true if the event handler should be interrupted if new events of the same priority occurs; false otherwise

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