Package robocode

Class AdvancedRobot

    • Constructor Detail

      • AdvancedRobot

        public AdvancedRobot()
    • Method Detail

      • 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:
        java.lang.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:
        java.lang.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();
           }
         
      • getBulletHitBulletEvents

        public java.util.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 java.util.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 java.util.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()
      • getDataFile

        public java.io.File getDataFile​(java.lang.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 or null if the data file could not be created due to an error.
        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)
      • getHitByBulletEvents

        public java.util.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 java.util.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 java.util.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 java.util.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 java.util.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 java.util.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()
      • setEventPriority

        public void setEventPriority​(java.lang.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)
      • 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)
      • 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
      • 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)
      • 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.