robocode

Class Robot

Implemented Interfaces:
IBasicEvents, IBasicEvents2, IBasicRobot, IInteractiveEvents, IInteractiveRobot, IPaintEvents, IPaintRobot, Runnable

public class Robot
extends robocode._Robot
implements IInteractiveRobot, IPaintRobot, IBasicEvents2, IInteractiveEvents, IPaintEvents

The basic robot class that you will extend to create your own robots.

Please note the following standards will be used:
heading - absolute angle in degrees with 0 facing up the screen, positive clockwise. 0 <= heading <32360.
bearing - relative angle to some object from your robot's heading, positive clockwise. -180 <32bearing <= 180
All coordinates are expressed as (x,y).
All coordinates are positive.
The origin (0,0) is at the bottom left of the screen.
Positive x is right.
Positive y is up.

Authors:
Mathew A. Nelson (original)
Flemming N. Larsen (contributor)
Matthew Reeder (contributor)
Stefan Westen (contributor)
Pavel Savara (contributor)
See Also:
robocode.sourceforge.net, Building your first robot, JuniorRobot, AdvancedRobot, TeamRobot, Droid

Field Summary

Fields inherited from class robocode._RobotBase

out

Constructor Summary

Robot()
Constructs a new robot.

Method Summary

void
ahead(double distance)
Immediately moves your robot ahead (forward) by distance measured in pixels.
void
back(double distance)
Immediately moves your robot backward by distance measured in pixels.
void
doNothing()
Do nothing this turn, meaning that the robot will skip it's turn.
void
fire(double power)
Immediately fires a bullet.
Bullet
fireBullet(double power)
Immediately fires a bullet.
IBasicEvents
getBasicEventListener()
}
double
getBattleFieldHeight()
Returns the height of the current battlefield measured in pixels.
double
getBattleFieldWidth()
Returns the width of the current battlefield measured in pixels.
double
getEnergy()
Returns the robot's current energy.
Graphics2D
getGraphics()
Returns a graphics context used for painting graphical items for the robot.
double
getGunCoolingRate()
Returns the rate at which the gun will cool down, i.e.
double
getGunHeading()
Returns the direction that the robot's gun is facing, in degrees.
double
getGunHeat()
Returns the current heat of the gun.
double
getHeading()
Returns the direction that the robot's body is facing, in degrees.
double
getHeight()
Returns the height of the robot measured in pixels.
IInteractiveEvents
getInteractiveEventListener()
}
String
getName()
Returns the robot's name.
int
getNumRounds()
Returns the number of rounds in the current battle.
int
getOthers()
Returns how many opponents that are left in the current round.
IPaintEvents
getPaintEventListener()
}
double
getRadarHeading()
Returns the direction that the robot's radar is facing, in degrees.
Runnable
getRobotRunnable()
}
int
getRoundNum()
Returns the current round number (0 to getNumRounds() - 1) of the battle.
long
getTime()
Returns the game time of the current round, where the time is equal to the current turn in the round.
double
getVelocity()
Returns the velocity of the robot measured in pixels/turn.
double
getWidth()
Returns the width of the robot measured in pixels.
double
getX()
Returns the X position of the robot.
double
getY()
Returns the Y position of the robot.
void
onBattleEnded(BattleEndedEvent event)
void
onBulletHit(BulletHitEvent event)
void
onBulletHitBullet(BulletHitBulletEvent event)
void
onBulletMissed(BulletMissedEvent event)
void
onDeath(DeathEvent event)
void
onHitByBullet(HitByBulletEvent event)
void
onHitRobot(HitRobotEvent event)
void
onHitWall(HitWallEvent event)
void
onKeyPressed(KeyEvent e)
void
onKeyReleased(KeyEvent e)
void
onKeyTyped(KeyEvent e)
void
onMouseClicked(MouseEvent e)
void
onMouseDragged(MouseEvent e)
void
onMouseEntered(MouseEvent e)
void
onMouseExited(MouseEvent e)
void
onMouseMoved(MouseEvent e)
void
onMousePressed(MouseEvent e)
void
onMouseReleased(MouseEvent e)
void
onMouseWheelMoved(MouseWheelEvent e)
void
onPaint(Graphics2D g)
void
onRobotDeath(RobotDeathEvent event)
void
onScannedRobot(ScannedRobotEvent event)
void
onStatus(StatusEvent e)
void
onWin(WinEvent event)
void
resume()
Immediately resumes the movement you stopped by stop(), if any.
void
run()
The main method in every robot.
void
scan()
Scans for other robots.
void
setAdjustGunForRobotTurn(boolean independent)
Sets the gun to turn independent from the robot's turn.
void
setAdjustRadarForGunTurn(boolean independent)
Sets the radar to turn independent from the gun's turn.
void
setAdjustRadarForRobotTurn(boolean independent)
Sets the radar to turn independent from the robot's turn.
void
setAllColors(Color color)
Sets all the robot's color to the same color in the same time, i.e.
void
setBodyColor(Color color)
Sets the color of the robot's body.
void
setBulletColor(Color color)
Sets the color of the robot's bullets.
void
setColors(Color bodyColor, Color gunColor, Color radarColor)
Sets the color of the robot's body, gun, and radar in the same time.
void
setColors(Color bodyColor, Color gunColor, Color radarColor, Color bulletColor, Color scanArcColor)
Sets the color of the robot's body, gun, radar, bullet, and scan arc in the same time.
void
setDebugProperty(String key, String value)
Sets the debug property with the specified key to the specified value.
void
setGunColor(Color color)
Sets the color of the robot's gun.
void
setRadarColor(Color color)
Sets the color of the robot's radar.
void
setScanColor(Color color)
Sets the color of the robot's scan arc.
void
stop()
Immediately stops all movement, and saves it for a call to resume().
void
stop(boolean overwrite)
Immediately stops all movement, and saves it for a call to resume().
void
turnGunLeft(double degrees)
Immediately turns the robot's gun to the left by degrees.
void
turnGunRight(double degrees)
Immediately turns the robot's gun to the right by degrees.
void
turnLeft(double degrees)
Immediately turns the robot's body to the left by degrees.
void
turnRadarLeft(double degrees)
Immediately turns the robot's radar to the left by degrees.
void
turnRadarRight(double degrees)
Immediately turns the robot's radar to the right by degrees.
void
turnRight(double degrees)
Immediately turns the robot's body to the right by degrees.
protected @Override
void finalize()
Called by the system to 'clean up' after your robot.

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

Constructor Details

Robot

public Robot()
Constructs a new robot.

Method Details

ahead

public void ahead(double distance)
Immediately moves your robot ahead (forward) by distance measured in pixels.

This call executes immediately, and does not return until it is complete, i.e. when the remaining distance to move is 0.

If the robot collides with a wall, the move is complete, meaning that the robot will not move any further. If the robot collides with another robot, the move is complete if you are heading toward the other robot.

Note that both positive and negative values can be given as input, where negative values means that the robot is set to move backward instead of forward.

Example:

   // Move the robot 100 pixels forward
   ahead(100);
 

// Afterwards, move the robot 50 pixels backward ahead(-50);

Parameters:
distance - the distance to move ahead measured in pixels. If this value is negative, the robot will move back instead of ahead.

back

public void back(double distance)
Immediately moves your robot backward by distance measured in pixels.

This call executes immediately, and does not return until it is complete, i.e. when the remaining distance to move is 0.

If the robot collides with a wall, the move is complete, meaning that the robot will not move any further. If the robot collides with another robot, the move is complete if you are heading toward the other robot.

Note that both positive and negative values can be given as input, where negative values means that the robot is set to move forward instead of backward.

Example:

   // Move the robot 100 pixels backward
   back(100);
 

// Afterwards, move the robot 50 pixels forward back(-50);

Parameters:
distance - the distance to move back measured in pixels. If this value is negative, the robot will move ahead instead of back.

doNothing

public void doNothing()
Do nothing this turn, meaning that the robot will skip it's turn.

This call executes immediately, and does not return until the turn is over.


fire

public void fire(double power)
Immediately fires a bullet. The bullet will travel in the direction the gun is pointing.

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:

   // Fire a bullet with maximum power if the gun is ready
   if (getGunHeat() == 0) {
       fire(Rules.MAX_BULLET_POWER);
   }
 
Parameters:
power - the amount of energy given to the bullet, and subtracted from the robot's energy.

fireBullet

public Bullet fireBullet(double power)
Immediately fires a bullet. The bullet will travel in the direction the gun is pointing.

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:

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

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

getBasicEventListener

public final IBasicEvents getBasicEventListener()
}
Specified by:
getBasicEventListener in interface IBasicRobot

getBattleFieldHeight

public double getBattleFieldHeight()
Returns the height of the current battlefield measured in pixels.
Returns:
the height of the current battlefield measured in pixels.

getBattleFieldWidth

public double getBattleFieldWidth()
Returns the width of the current battlefield measured in pixels.
Returns:
the width of the current battlefield measured in pixels.

getEnergy

public double getEnergy()
Returns the robot's current energy.
Returns:
the robot's current energy.

getGraphics

public Graphics2D getGraphics()
Returns a graphics context used for painting graphical items for the robot.

This method is very useful for debugging your robot.

Note that the robot will only be painted if the "Paint" is enabled on the robot's console window; otherwise the robot will never get painted (the reason being that all robots might have graphical items that must be painted, and then you might not be able to tell what graphical items that have been painted for your robot).

Also note that the coordinate system for the graphical context where you paint items fits for the Robocode coordinate system where (0, 0) is at the bottom left corner of the battlefield, where X is towards right and Y is upwards.

Returns:
a graphics context used for painting graphical items for the robot.
Since:
1.6.1

getGunCoolingRate

public double getGunCoolingRate()
Returns the rate at which the gun will cool down, i.e. the amount of heat the gun heat will drop per turn.

The gun cooling rate is default 0.1 / turn, but can be changed by the battle setup. So don't count on the cooling rate being 0.1!

Returns:
the gun cooling rate

getGunHeading

public double getGunHeading()
Returns the direction that the robot's gun is facing, in degrees. The value returned will be between 0 and 360 (is excluded).

Note that the heading in Robocode is like a compass, where 0 means North, 90 means East, 180 means South, and 270 means West.

Returns:
the direction that the robot's gun is facing, in degrees.

getGunHeat

public double getGunHeat()
Returns:
the current gun heat

getHeading

public double getHeading()
Returns the direction that the robot's body is facing, in degrees. The value returned will be between 0 and 360 (is excluded).

Note that the heading in Robocode is like a compass, where 0 means North, 90 means East, 180 means South, and 270 means West.

Returns:
the direction that the robot's body is facing, in degrees.

getHeight

public double getHeight()
Returns the height of the robot measured in pixels.
Returns:
the height of the robot measured in pixels.

getInteractiveEventListener

public final IInteractiveEvents getInteractiveEventListener()
}
Specified by:
getInteractiveEventListener in interface IInteractiveRobot

getName

public String getName()
Returns the robot's name.
Returns:
the robot's name.

getNumRounds

public int getNumRounds()
Returns the number of rounds in the current battle.
Returns:
the number of rounds in the current battle

getOthers

public int getOthers()
Returns how many opponents that are left in the current round.
Returns:
how many opponents that are left in the current round.

getPaintEventListener

public final IPaintEvents getPaintEventListener()
}
Specified by:
getPaintEventListener in interface IPaintRobot

getRadarHeading

public double getRadarHeading()
Returns the direction that the robot's radar is facing, in degrees. The value returned will be between 0 and 360 (is excluded).

Note that the heading in Robocode is like a compass, where 0 means North, 90 means East, 180 means South, and 270 means West.

Returns:
the direction that the robot's radar is facing, in degrees.

getRobotRunnable

public final Runnable getRobotRunnable()
}
Specified by:
getRobotRunnable in interface IBasicRobot

getRoundNum

public int getRoundNum()
Returns:
the current round number of the battle

getTime

public long getTime()
Returns the game time of the current round, where the time is equal to the current turn in the round.

A battle consists of multiple rounds.

Time is reset to 0 at the beginning of every round.

Returns:
the game time/turn of the current round.

getVelocity

public double getVelocity()
Returns:
the velocity of the robot measured in pixels/turn.

getWidth

public double getWidth()
Returns the width of the robot measured in pixels.
Returns:
the width of the robot measured in pixels.

getX

public double getX()
Returns the X position of the robot. (0,0) is at the bottom left of the battlefield.
Returns:
the X position of the robot.

getY

public double getY()
Returns the Y position of the robot. (0,0) is at the bottom left of the battlefield.
Returns:
the Y position of the robot.

onBattleEnded

public void onBattleEnded(BattleEndedEvent event)
Specified by:
onBattleEnded in interface IBasicEvents2

onBulletHit

public void onBulletHit(BulletHitEvent event)
Specified by:
onBulletHit in interface IBasicEvents

onBulletHitBullet

public void onBulletHitBullet(BulletHitBulletEvent event)
Specified by:
onBulletHitBullet in interface IBasicEvents

onBulletMissed

public void onBulletMissed(BulletMissedEvent event)
Specified by:
onBulletMissed in interface IBasicEvents

onDeath

public void onDeath(DeathEvent event)
Specified by:
onDeath in interface IBasicEvents

onHitByBullet

public void onHitByBullet(HitByBulletEvent event)
Specified by:
onHitByBullet in interface IBasicEvents

onHitRobot

public void onHitRobot(HitRobotEvent event)
Specified by:
onHitRobot in interface IBasicEvents

onHitWall

public void onHitWall(HitWallEvent event)
Specified by:
onHitWall in interface IBasicEvents

onKeyPressed

public void onKeyPressed(KeyEvent e)
Specified by:
onKeyPressed in interface IInteractiveEvents

onKeyReleased

public void onKeyReleased(KeyEvent e)
Specified by:
onKeyReleased in interface IInteractiveEvents

onKeyTyped

public void onKeyTyped(KeyEvent e)
Specified by:
onKeyTyped in interface IInteractiveEvents

onMouseClicked

public void onMouseClicked(MouseEvent e)
Specified by:
onMouseClicked in interface IInteractiveEvents

onMouseDragged

public void onMouseDragged(MouseEvent e)
Specified by:
onMouseDragged in interface IInteractiveEvents

onMouseEntered

public void onMouseEntered(MouseEvent e)
Specified by:
onMouseEntered in interface IInteractiveEvents

onMouseExited

public void onMouseExited(MouseEvent e)
Specified by:
onMouseExited in interface IInteractiveEvents

onMouseMoved

public void onMouseMoved(MouseEvent e)
Specified by:
onMouseMoved in interface IInteractiveEvents

onMousePressed

public void onMousePressed(MouseEvent e)
Specified by:
onMousePressed in interface IInteractiveEvents

onMouseReleased

public void onMouseReleased(MouseEvent e)
Specified by:
onMouseReleased in interface IInteractiveEvents

onMouseWheelMoved

public void onMouseWheelMoved(MouseWheelEvent e)
Specified by:
onMouseWheelMoved in interface IInteractiveEvents

onPaint

public void onPaint(Graphics2D g)
Specified by:
onPaint in interface IPaintEvents

onRobotDeath

public void onRobotDeath(RobotDeathEvent event)
Specified by:
onRobotDeath in interface IBasicEvents

onScannedRobot

public void onScannedRobot(ScannedRobotEvent event)
Specified by:
onScannedRobot in interface IBasicEvents

onStatus

public void onStatus(StatusEvent e)
Specified by:
onStatus in interface IBasicEvents

onWin

public void onWin(WinEvent event)
Specified by:
onWin in interface IBasicEvents

resume

public void resume()
Immediately resumes the movement you stopped by stop(), if any.

This call executes immediately, and does not return until it is complete.


run

public void run()
The main method in every robot. You must override this to set up your robot's basic behavior.

Example:

   // A basic robot that moves around in a square
   public void run() {
       while (true) {
           ahead(100);
           turnRight(90);
       }
   }
 

scan

public void scan()
Scans for other robots. This method is called automatically by the game, as long as the robot is moving, turning its body, turning its gun, or turning its radar.

Scan will cause onScannedRobot(ScannedRobotEvent) to be called if you see a robot.

There are 2 reasons to call scan() manually:

  1. You want to scan after you stop moving.
  2. You want to interrupt the onScannedRobot event. This is more likely. If you are in onScannedRobot and call scan(), and you still see a robot, then the system will interrupt your onScannedRobot event immediately and start it from the top.

This call executes immediately.


setAdjustGunForRobotTurn

public void setAdjustGunForRobotTurn(boolean independent)
Parameters:
independent - true if the gun must turn independent from the robot's turn; false if the gun must turn with the robot's turn.

setAdjustRadarForGunTurn

public void setAdjustRadarForGunTurn(boolean independent)
Parameters:
independent - true if the radar must turn independent from the gun's turn; false if the radar must turn with the gun's turn.

setAdjustRadarForRobotTurn

public void setAdjustRadarForRobotTurn(boolean independent)
Sets the radar to turn independent from the robot's turn.

Ok, so this needs some explanation: The radar is mounted on the gun, and the gun is mounted on the robot's body. So, normally, if the robot turns 90 degrees to the right, the gun turns, as does the radar. Hence, if the robot turns 90 degrees to the right, then the gun and radar will turn with it as the radar is mounted on top of the gun. To compensate for this, you can call setAdjustRadarForRobotTurn(true). When this is set, the radar will turn independent from the robot's turn, i.e. the radar will compensate for the robot's turn.

Example, assuming the robot, gun, and radar all start out facing up (0 degrees):

   // Set radar to turn with the robots's turn
   setAdjustRadarForRobotTurn(false); // This is the default
   turnRight(90);
   // At this point, the body, gun, and radar are all facing right (90 degrees);
 

-- or --

// Set radar to turn independent from the robot's turn setAdjustRadarForRobotTurn(true); turnRight(90); // At this point, the robot and gun are facing right (90 degrees), but the radar is still facing up.

Parameters:
independent - true if the radar must turn independent from the robots's turn; false if the radar must turn with the robot's turn.

setAllColors

public void setAllColors(Color color)
Sets all the robot's color to the same color in the same time, i.e. the color of the body, gun, radar, bullet, and scan arc.

You may only call this method one time per battle. A null indicates the default (blue) color for the body, gun, radar, and scan arc, but white for the bullet color.

 Example:
   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setAllColors(Color.RED); ... }

Parameters:
color - the new color for all the colors of the robot
Since:
1.1.3

setBodyColor

public void setBodyColor(Color color)
Sets the color of the robot's body.

A null indicates the default (blue) color.

 Example:
   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setBodyColor(Color.BLACK); ... }

Parameters:
color - the new body color
Since:
1.1.2

setBulletColor

public void setBulletColor(Color color)
Sets the color of the robot's bullets.

A null indicates the default white color.

 Example:
   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setBulletColor(Color.GREEN); ... }

Parameters:
color - the new bullet color
Since:
1.1.2

setColors

public void setColors(Color bodyColor,
                      Color gunColor,
                      Color radarColor)
Sets the color of the robot's body, gun, and radar in the same time.

You may only call this method one time per battle. A null indicates the default (blue) color.

Example:

   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setColors(null, Color.RED, new Color(150, 0, 150)); ... }

Parameters:
bodyColor - the new body color
gunColor - the new gun color
radarColor - the new radar color

setColors

public void setColors(Color bodyColor,
                      Color gunColor,
                      Color radarColor,
                      Color bulletColor,
                      Color scanArcColor)
Sets the color of the robot's body, gun, radar, bullet, and scan arc in the same time.

You may only call this method one time per battle. A null indicates the default (blue) color for the body, gun, radar, and scan arc, but white for the bullet color.

Example:

   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setColors(null, Color.RED, Color.GREEN, null, new Color(150, 0, 150)); ... }

Parameters:
bodyColor - the new body color
gunColor - the new gun color
radarColor - the new radar color
bulletColor - the new bullet color
scanArcColor - the new scan arc color
Since:
1.1.3

setDebugProperty

public void setDebugProperty(String key,
                             String value)
Sets the debug property with the specified key to the specified value.

This method is very useful when debugging or reviewing your robot as you will be able to see this property displayed in the robot console for your robots under the Debug Properties tab page.

Parameters:
key - the name/key of the debug property.
value - the new value of the debug property, where null or the empty string is used for removing this debug property.
Since:
1.6.2

setGunColor

public void setGunColor(Color color)
Sets the color of the robot's gun.

A null indicates the default (blue) color.

 Example:
   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setGunColor(Color.RED); ... }

Parameters:
color - the new gun color
Since:
1.1.2

setRadarColor

public void setRadarColor(Color color)
Sets the color of the robot's radar.

A null indicates the default (blue) color.

 Example:
   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setRadarColor(Color.YELLOW); ... }

Parameters:
color - the new radar color
Since:
1.1.2

setScanColor

public void setScanColor(Color color)
Sets the color of the robot's scan arc.

A null indicates the default (blue) color.

 Example:
   // Don't forget to import java.awt.Color at the top...
   import java.awt.Color;
   ...
 

public void run() { setScanColor(Color.WHITE); ... }

Parameters:
color - the new scan arc color
Since:
1.1.2

stop

public void stop()
Immediately stops all movement, and saves it for a call to resume(). If there is already movement saved from a previous stop, this will have no effect.

This method is equivalent to #stop(false).


stop

public void stop(boolean overwrite)
Immediately stops all movement, and saves it for a call to resume(). If there is already movement saved from a previous stop, you can overwrite it by calling stop(true).
Parameters:
overwrite - If there is already movement saved from a previous stop, you can overwrite it by calling stop(true).
See Also:
resume(), stop()

turnGunLeft

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

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
   turnGunLeft(180);
 

// Afterwards, turn the robot's gun 90 degrees to the right turnGunLeft(-90);

Parameters:
degrees - the amount of degrees to turn the robot's gun to the left. If degrees > 0 the robot's gun will turn left. If degrees <320 the robot's gun will turn right. If degrees = 0 the robot's gun will not turn, but execute.

turnGunRight

public void turnGunRight(double degrees)
Immediately turns the robot's gun to the right by degrees. 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
   turnGunRight(180);
 

// Afterwards, turn the robot's gun 90 degrees to the left turnGunRight(-90);

Parameters:
degrees - the amount of degrees to turn the robot's gun to the right. If degrees > 0 the robot's gun will turn right. If degrees <320 the robot's gun will turn left. If degrees = 0 the robot's gun will not turn, but execute.

turnLeft

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

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
   turnLeft(180);
 

// Afterwards, turn the robot 90 degrees to the right turnLeft(-90);

Parameters:
degrees - the amount of degrees to turn the robot's body to the left. If degrees > 0 the robot will turn left. If degrees <320 the robot will turn right. If degrees = 0 the robot will not turn, but execute.

turnRadarLeft

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

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
   turnRadarLeft(180);
 

// Afterwards, turn the robot's radar 90 degrees to the right turnRadarLeft(-90);

Parameters:
degrees - the amount of degrees to turn the robot's radar to the left. If degrees > 0 the robot's radar will turn left. If degrees <320 the robot's radar will turn right. If degrees = 0 the robot's radar will not turn, but execute.

turnRadarRight

public void turnRadarRight(double degrees)
Immediately turns the robot's radar to the right by degrees. 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
   turnRadarRight(180);
 

// Afterwards, turn the robot's radar 90 degrees to the left turnRadarRight(-90);

Parameters:
degrees - the amount of degrees to turn the robot's radar to the right. If degrees > 0 the robot's radar will turn right. If degrees <320 the robot's radar will turn left. If degrees = 0 the robot's radar will not turn, but execute.

turnRight

public void turnRight(double degrees)
Immediately turns the robot's body to the right by degrees. 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
   turnRight(180);
 

// Afterwards, turn the robot 90 degrees to the left turnRight(-90);

Parameters:
degrees - the amount of degrees to turn the robot's body to the right. If degrees > 0 the robot will turn right. If degrees <320 the robot will turn left. If degrees = 0 the robot will not turn, but execute.

void finalize

protected final @Override void finalize()
            throws Throwable
Called by the system to 'clean up' after your robot. You may not override this method.