RobotController (Battlecode 2014)

```
public interface RobotController
```
A RobotController allows contestants to make their robot sense and interact with the game world. When a contestant's RobotPlayer is constructed, it is passed an instance of RobotController that controls the newly created robot.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addMatchObservation(String observation)` Adds a custom observation to the match file, such that when it is analyzed, this observation will appear.
`void`	`attackSquare(MapLocation loc)` Attacks the given location Also applies to NOISETOWER, but does not deal damage in that case Creates a long-range noise at the targeted location
`void`	`attackSquareLight(MapLocation loc)` NOISETOWER only 'Attacks' the given location Does not deal damage, but creates a short-range noise at the targeted location
`void`	`breakpoint()` If breakpoints are enabled, calling this method causes the game engine to pause execution at the end of this round, until the user decides to resume execution.
`void`	`broadcast(int channel, int data)` Broadcasts a message to the global message board.
`boolean`	`canAttackSquare(MapLocation loc)` Returns whether the given location is within the robot's attack range.
`boolean`	`canMove(Direction dir)` Tells whether this robot can move in the given direction.
`boolean`	`canSenseObject(GameObject o)` Returns true if the given object is within the robot's sensor range
`boolean`	`canSenseSquare(MapLocation loc)` Returns true if the given location is within the robot's sensor range
`void`	`construct(RobotType type)` After a delay, kills the soldier and spawns a robot of the given building type
`double`	`getActionDelay()` Gets the robot's current action delay.
`int`	`getConstructingRounds()` Returns the number of turns left in the current construction.
`RobotType`	`getConstructingType()` Returns the RobotType of the structure the robot is constructing.
`long`	`getControlBits()` Gets this robot's 'control bits' for debugging purposes.
`double`	`getHealth()` Gets the robot's current health (hitpoints).
`MapLocation`	`getLocation()` Gets the robot's current location.
`int`	`getMapHeight()`
`int`	`getMapWidth()`
`Robot`	`getRobot()` Use this method to access your robot.
`Team`	`getTeam()` Gets the Team of this robot.
`long[]`	`getTeamMemory()` Returns the team memory from the last game of the match.
`RobotType`	`getType()` Gets this robot's type (SOLDIER, HQ, etc.)
`boolean`	`isActive()` Returns if the robot is active (able to move, construct, and attack)
`boolean`	`isConstructing()` Returns whether the robot is currently constructing a structure.
`void`	`move(Direction dir)` Move in the given direction if possible Creates a short-range noise at the destination location
`int`	`readBroadcast(int channel)` Retrieves the message stored at the given radio channel.
`void`	`resign()` Causes your team to lose the game.
`int`	`roundsUntilActive()` Returns the number of rounds until the robot is active again
`void`	`selfDestruct()` Kills your robot and deals area damage within distanceSquared 2 equal to `GameConstants.SELF_DESTRUCT_BASE_DAMAGE` plus the robot's current hp multiplied by `GameConstants.SELF_DESTRUCT_DAMAGE_FACTOR`.
`MapLocation[]`	`senseBroadcastingRobotLocations()` Returns an array of all the locations of the robots that have broadcasted in the last round (unconstrained by sensor range or distance)
`MapLocation[]`	`senseBroadcastingRobotLocations(Team t)` Returns an array of all the locations of the robots that have broadcasted in the last round, filtered by team (unconstrained by sensor range or distance)
`Robot[]`	`senseBroadcastingRobots()` Returns an array of all the robots that have broadcasted in the last round (unconstrained by sensor range or distance)
`Robot[]`	`senseBroadcastingRobots(Team t)` Returns an array of all the robots that have broadcasted in the last round, filtered by team (unconstrained by sensor range or distance)
`double[][]`	`senseCowGrowth()` Gives a representation of the cow growths of each location of the map (unconstrained by sensor range or distance)
`double`	`senseCowsAtLocation(MapLocation loc)` Returns the number of cows currently at a given location.
`MapLocation`	`senseEnemyHQLocation()` Returns location of the enemy team's HQ (unconstrained by sensor range or distance)
`MapLocation`	`senseHQLocation()` Returns location of the allied team's HQ (unconstrained by sensor range or distance)
`MapLocation`	`senseLocationOf(GameObject o)` Sense the location of the given object.
`<T extends GameObject> T[]`	`senseNearbyGameObjects(Class<T> type)` Returns all game objects of a given type nearby the robot
`<T extends GameObject> T[]`	`senseNearbyGameObjects(Class<T> type, int radiusSquared)` Returns all game objects of a given type nearby the robot
`<T extends GameObject> T[]`	`senseNearbyGameObjects(Class<T> type, int radiusSquared, Team team)` Returns all game objects of a given type nearby the robot of a given team
`<T extends GameObject> T[]`	`senseNearbyGameObjects(Class<T> type, MapLocation center, int radiusSquared, Team team)` Senses all game objects of a given type within a given search area specified by the parameters (constrainted by sensor range and distance)
`GameObject`	`senseObjectAtLocation(MapLocation loc)` Returns the object at the given location, or `null` if there is no object there.
`MapLocation[]`	`sensePastrLocations(Team t)` Returns the locations of PASTRS filtered by a team (unconstrained by sensor range or distance)
`int`	`senseRobotCount()` Gets the team's current robot count (with weighting).
`RobotInfo`	`senseRobotInfo(Robot r)` Sense the RobotInfo for the given robot.
`double`	`senseTeamMilkQuantity(Team t)` Sense the milk level for a given team.
`TerrainTile`	`senseTerrainTile(MapLocation loc)` Senses the terrain at the given location.
`void`	`setIndicatorString(int stringIndex, String newString)` Sets one of this robot's 'indicator strings' for debugging purposes.
`void`	`setTeamMemory(int index, long value)` Sets the team's "memory", which is saved for the next game in the match.
`void`	`setTeamMemory(int index, long value, long mask)` Sets this team's "memory".
`void`	`sneak(Direction dir)` Sneak in the given direction if possible
`void`	`spawn(Direction dir)` HQ ONLY.
`void`	`wearHat()` Puts a hat on the robot.
`void`	`win()`
`void`	`yield()` Ends the current round.

- Method Detail
  - getActionDelay
```
double getActionDelay()
```
    Gets the robot's current action delay.
    
    Returns:
    this robot's current action delay
  - getHealth
```
double getHealth()
```
    Gets the robot's current health (hitpoints).
    
    Returns:
    this robot's current health / hitpoints
  - getLocation
```
MapLocation getLocation()
```
    Gets the robot's current location.
    
    Returns:
    this robot's current location
  - getMapWidth
```
int getMapWidth()
```
    Returns:
    the current map's width
  - getMapHeight
```
int getMapHeight()
```
    Returns:
    the current map's height
  - getTeam
```
Team getTeam()
```
    Gets the Team of this robot. Equivalent to this.getRobot().getTeam().
    
    Returns:
    this robot's Team
    See Also:
    Team
  - getRobot
```
Robot getRobot()
```
    Use this method to access your robot.
    
    Returns:
    the Robot associated with this RobotController
  - getType
```
RobotType getType()
```
    Gets this robot's type (SOLDIER, HQ, etc.)
    
    Returns:
    this robot's type.
  - isConstructing
```
boolean isConstructing()
```
    Returns whether the robot is currently constructing a structure.
    
    Returns:
    whether this robot is currently constructing a structure.
  - getConstructingType
```
RobotType getConstructingType()
```
    Returns the RobotType of the structure the robot is constructing.
    
    Returns:
    the RobotType of the structure this robot is constructing.
  - getConstructingRounds
```
int getConstructingRounds()
```
    Returns the number of turns left in the current construction.
    
    Returns:
    the number of turns left in the current construction.
  - senseTeamMilkQuantity
```
double senseTeamMilkQuantity(Team t)
```
    Sense the milk level for a given team. If the team is not your team, then it gets rounded down to the nearest multiple of GameConstants.OPPONENT_MILK_SENSE_ACCURACY
    
    Returns:
    the current milk total of the team (rounded if it's the opponent team)
    Bytecode cost:
    100
  - senseRobotCount
```
int senseRobotCount()
```
    Gets the team's current robot count (with weighting).
    
    Returns:
    the total number of robots controlled (with weighting).
    Bytecode cost:
    5
  - senseObjectAtLocation
```
GameObject senseObjectAtLocation(MapLocation loc)
                                 throws GameActionException
```
    Returns the object at the given location, or null if there is no object there.
    
    Throws:
    
    GameActionException - if loc is not within sensor range (CANT_SENSE_THAT)
    Bytecode cost:
    25
  - senseNearbyGameObjects
```
<T extends GameObject> T[] senseNearbyGameObjects(Class<T> type)
```
    Returns all game objects of a given type nearby the robot
    
    See Also:
    senseNearbyGameObjects(Class, MapLocation, int, Team)
    Bytecode cost:
    100
  - senseNearbyGameObjects
```
<T extends GameObject> T[] senseNearbyGameObjects(Class<T> type,
                                                int radiusSquared)
```
    Returns all game objects of a given type nearby the robot
    
    See Also:
    senseNearbyGameObjects(Class, MapLocation, int, Team)
    Bytecode cost:
    100
  - senseNearbyGameObjects
```
<T extends GameObject> T[] senseNearbyGameObjects(Class<T> type,
                                                int radiusSquared,
                                                Team team)
```
    Returns all game objects of a given type nearby the robot of a given team
    
    See Also:
    senseNearbyGameObjects(Class, MapLocation, int, Team)
    Bytecode cost:
    100
  - senseNearbyGameObjects
```
<T extends GameObject> T[] senseNearbyGameObjects(Class<T> type,
                                                MapLocation center,
                                                int radiusSquared,
                                                Team team)
```
    Senses all game objects of a given type within a given search area specified by the parameters (constrainted by sensor range and distance)
    
    Parameters:
    type - - type of game object to sense, eg: Robot.class
    center - - center of the given search radius
    radiusSquared - - return objects this distance away from the center
    team - - filter game objects by the given team. If null is passed, objects from all teams are returned
    
    Returns:
    array of class type of game objects
    Bytecode cost:
    100
  - senseBroadcastingRobots
```
Robot[] senseBroadcastingRobots()
```
    Returns an array of all the robots that have broadcasted in the last round (unconstrained by sensor range or distance)
    
    Returns:
    an array of all robots that have broadcasted in the last round.
    Bytecode cost:
    100
  - senseBroadcastingRobots
```
Robot[] senseBroadcastingRobots(Team t)
```
    Returns an array of all the robots that have broadcasted in the last round, filtered by team (unconstrained by sensor range or distance)
    
    Parameters:
    t - - filter robots by the given team.
    
    Returns:
    an array of all robots of the given team that have broadcasted in the last round.
    Bytecode cost:
    100
  - senseBroadcastingRobotLocations
```
MapLocation[] senseBroadcastingRobotLocations()
```
    Returns an array of all the locations of the robots that have broadcasted in the last round (unconstrained by sensor range or distance)
    
    Returns:
    an array of all the locations of the robots that have broadcasted in the last round.
    Bytecode cost:
    100
  - senseBroadcastingRobotLocations
```
MapLocation[] senseBroadcastingRobotLocations(Team t)
```
    Returns an array of all the locations of the robots that have broadcasted in the last round, filtered by team (unconstrained by sensor range or distance)
    
    Parameters:
    t - - filter robots by the given team.
    
    Returns:
    an array of all the locations of the robots of the given team that have broadcasted in the last round.
    Bytecode cost:
    100
  - senseLocationOf
```
MapLocation senseLocationOf(GameObject o)
                            throws GameActionException
```
    Sense the location of the given object.
    
    Returns:
    the location of the given object.
    
    Throws:
    
    GameActionException - if object is not within sensor range (CANT_SENSE_THAT)
    Bytecode cost:
    25
  - senseRobotInfo
```
RobotInfo senseRobotInfo(Robot r)
                         throws GameActionException
```
    Sense the RobotInfo for the given robot.
    
    Returns:
    the RobotInfo for the given robot.
    
    Throws:
    
    GameActionException - if robot is not within sensor range (CANT_SENSE_THAT)
    Bytecode cost:
    25
  - canSenseObject
```
boolean canSenseObject(GameObject o)
```
    Returns true if the given object is within the robot's sensor range
    
    Returns:
    whether the given object is within the robot's sensor range
    Bytecode cost:
    15
  - canSenseSquare
```
boolean canSenseSquare(MapLocation loc)
```
    Returns true if the given location is within the robot's sensor range
    
    Returns:
    whether the given location is within the robot's sensor range
    Bytecode cost:
    15
  - senseHQLocation
```
MapLocation senseHQLocation()
```
    Returns location of the allied team's HQ (unconstrained by sensor range or distance)
    
    Returns:
    the team's HQ location
    Bytecode cost:
    10
  - senseEnemyHQLocation
```
MapLocation senseEnemyHQLocation()
```
    Returns location of the enemy team's HQ (unconstrained by sensor range or distance)
    
    Returns:
    the enemy team's HQ location
    Bytecode cost:
    10
  - sensePastrLocations
```
MapLocation[] sensePastrLocations(Team t)
```
    Returns the locations of PASTRS filtered by a team (unconstrained by sensor range or distance)
    
    Parameters:
    t - - filter PASTR locations by the given team
    
    Returns:
    an array of all MapLocations of PASTR locations
    Bytecode cost:
    100
  - senseCowGrowth
```
double[][] senseCowGrowth()
```
    Gives a representation of the cow growths of each location of the map (unconstrained by sensor range or distance)
    
    Returns:
    an array of arrays of doubles, where element [a][b] is the natural cow growth at MapLocation (a,b). Will be 0 on all VOID locations.
    Bytecode cost:
    100
  - senseCowsAtLocation
```
double senseCowsAtLocation(MapLocation loc)
                           throws GameActionException
```
    Returns the number of cows currently at a given location. Returns 0 for locations off the map.
    
    Parameters:
    loc - - location to sense at (must be within sensor range)
    
    Returns:
    a double equal to how many cows are currently at the location
    
    Throws:
    
    GameActionException
    Bytecode cost:
    10
  - roundsUntilActive
```
int roundsUntilActive()
```
    Returns the number of rounds until the robot is active again
    
    Returns:
    the number of rounds until this robot's action cooldown ends, or 0 if it is already active
    Bytecode cost:
    10
  - isActive
```
boolean isActive()
```
    Returns if the robot is active (able to move, construct, and attack)
    
    Returns:
    true if this robot is active. If a robot is active, it can move, construct, and attack
    Bytecode cost:
    5
  - move
```
void move(Direction dir)
          throws GameActionException
```
    Move in the given direction if possible Creates a short-range noise at the destination location
    
    Parameters:
    dir -
    
    Throws:
    
    GameActionException - if the robot cannot move in this direction
    Bytecode cost:
    25
  - sneak
```
void sneak(Direction dir)
           throws GameActionException
```
    Sneak in the given direction if possible
    
    Parameters:
    dir -
    
    Throws:
    
    GameActionException - if the robot cannot move in this direction
    Bytecode cost:
    25
  - canMove
```
boolean canMove(Direction dir)
```
    Tells whether this robot can move in the given direction. Takes into account only the map terrain and positions of other robots. Does not take into account this robot's type or whether this robot is currently active. Returns false for the OMNI and NONE directions.
    
    Returns:
    true if there are no robots or walls preventing this robot from moving in the given direction; false otherwise
    Bytecode cost:
    25
  - canAttackSquare
```
boolean canAttackSquare(MapLocation loc)
```
    Returns whether the given location is within the robot's attack range. Does not take into account whether the robot is currently attacking.
    
    Returns:
    true if the given location is within this robot's attack range. Does not take into account whether the robot is currently attacking
    Bytecode cost:
    15
  - attackSquare
```
void attackSquare(MapLocation loc)
                  throws GameActionException
```
    Attacks the given location Also applies to NOISETOWER, but does not deal damage in that case Creates a long-range noise at the targeted location
    
    Throws:
    
    GameActionException - if the robot cannot attack the given square
    Bytecode cost:
    25
  - attackSquareLight
```
void attackSquareLight(MapLocation loc)
                       throws GameActionException
```
    NOISETOWER only 'Attacks' the given location Does not deal damage, but creates a short-range noise at the targeted location
    
    Throws:
    
    GameActionException - if the robot cannot attack the given square
    Bytecode cost:
    25
  - broadcast
```
void broadcast(int channel,
             int data)
               throws GameActionException
```
    Broadcasts a message to the global message board. The data is not written until the end of the robot's turn.
    
    Parameters:
    channel - - the channel to write to, from 0 to BROADCAST_MAX_CHANNELS
    data - - one int's worth of data to write
    
    Throws:
    
    GameActionException - if the channel is invalid
    Bytecode cost:
    10
  - readBroadcast
```
int readBroadcast(int channel)
                  throws GameActionException
```
    Retrieves the message stored at the given radio channel.
    
    Parameters:
    channel - - radio channel to query, from 0 to BROADCAST_MAX_CHANNELS
    
    Returns:
    data currently stored on the channel
    
    Throws:
    
    GameActionException - if the channel is invalid
    Bytecode cost:
    2
  - spawn
```
void spawn(Direction dir)
           throws GameActionException
```
    HQ ONLY. Queues a spawn action to be performed at the end of this robot's turn. When the action is executed, a new robot will be created adjacent to the HQ in the given direction. The square must not already be occupied. The new robot is created and starts executing bytecodes immediately
    
    Parameters:
    dir - the direction to spawn robot in
    
    Throws:
    
    GameActionException - if this robot is not the HQ (CANT_DO_THAT_BRO)
    
    GameActionException - if this robot is currently inactive (NOT_ACTIVE)
    
    GameActionException - if location is already occupied (CANT_MOVE_THERE)
    
    GameActionException - if the maximum robot count has already been reached (CANT_DO_THAT_BRO)
    Bytecode cost:
    25
  - construct
```
void construct(RobotType type)
               throws GameActionException
```
    After a delay, kills the soldier and spawns a robot of the given building type
    
    Parameters:
    type -
    
    Throws:
    
    GameActionException - if it's not a soldier constructing or if the soldier is not constructing a structure
    Bytecode cost:
    25
  - yield
```
void yield()
```
    Ends the current round. Never fails.
  - selfDestruct
```
void selfDestruct()
                  throws GameActionException
```
    Kills your robot and deals area damage within distanceSquared 2 equal to GameConstants.SELF_DESTRUCT_BASE_DAMAGE plus the robot's current hp multiplied by GameConstants.SELF_DESTRUCT_DAMAGE_FACTOR. Destroys all cows in all effected squares and creates a long-range noise at the robot's former location
    
    Throws:
    
    GameActionException - if it's not a soldier
  - resign
```
void resign()
```
    Causes your team to lose the game. It's like typing "gg."
  - win
```
void win()
```
  - wearHat
```
void wearHat()
             throws GameActionException
```
    Puts a hat on the robot. You require the BATTLECODE-HATS DLC. You also cannot be moving while putting on your hat. This costs milk (GameConstants.HAT_MILK_COST). The HQ's first hat is free.
    
    Throws:
    
    GameActionException - if you have action delay or if you do not have enough milk
    Bytecode cost:
    5000
  - setIndicatorString
```
void setIndicatorString(int stringIndex,
                      String newString)
```
    Sets one of this robot's 'indicator strings' for debugging purposes. These strings are displayed in the client. This method has no effect on gameplay (aside from the number of bytecodes executed to call this method).
    
    Parameters:
    stringIndex - the index of the indicator string to set. Must satisfy stringIndex >= 0 && stringIndex < GameConstants.NUMBER_OF_INDICATOR_STRINGS
    newString - the value to which the indicator string should be set
  - senseTerrainTile
```
TerrainTile senseTerrainTile(MapLocation loc)
```
    Senses the terrain at the given location.
    
    Bytecode cost:
    10
  - getControlBits
```
long getControlBits()
```
    Gets this robot's 'control bits' for debugging purposes. These bits can be set manually by the user, so a robot can respond to them.
    
    Returns:
    this robot's control bits
  - addMatchObservation
```
void addMatchObservation(String observation)
```
    Adds a custom observation to the match file, such that when it is analyzed, this observation will appear.
    
    Parameters:
    observation - the observation you want to inject into the match file
  - setTeamMemory
```
void setTeamMemory(int index,
                 long value)
```
    Sets the team's "memory", which is saved for the next game in the match. The memory is an array of GameConstants.TEAM_MEMORY_LENGTH longs. If this method is called more than once with the same index in the same game, the last call is what is saved for the next game.
    
    Parameters:
    index - the index of the array to set
    value - the data that the team should remember for the next game
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if index is less than zero or greater than or equal to GameConstants.TEAM_MEMORY_LENGTH
    See Also:
    getTeamMemory(), setTeamMemory(int, long, long)
    Bytecode cost:
    15
  - setTeamMemory
```
void setTeamMemory(int index,
                 long value,
                 long mask)
```
    Sets this team's "memory". This function allows for finer control than setTeamMemory(int, long) provides. For example, if mask == 0xFF then only the eight least significant bits of the memory will be set.
    
    Parameters:
    index - the index of the array to set
    value - the data that the team should remember for the next game
    mask - indicates which bits should be set
    
    Throws:
    
    ArrayIndexOutOfBoundsException - if index is less than zero or greater than or equal to GameConstants.TEAM_MEMORY_LENGTH
    See Also:
    getTeamMemory(), setTeamMemory(int, long)
    Bytecode cost:
    15
  - getTeamMemory
```
long[] getTeamMemory()
```
    Returns the team memory from the last game of the match. The return value is an array of length GameConstants.TEAM_MEMORY_LENGTH. If setTeamMemory was not called in the last game, or there was no last game, the corresponding long defaults to 0.
    
    Returns:
    the team memory from the the last game of the match
    See Also:
    setTeamMemory(int, long), setTeamMemory(int, long, long)
  - breakpoint
```
void breakpoint()
```
    If breakpoints are enabled, calling this method causes the game engine to pause execution at the end of this round, until the user decides to resume execution.

Interface RobotController

Method Summary

Method Detail

getActionDelay

getHealth

getLocation

getMapWidth

getMapHeight

getTeam

getRobot

getType

isConstructing

getConstructingType

getConstructingRounds

senseTeamMilkQuantity

senseRobotCount

senseObjectAtLocation

senseNearbyGameObjects

senseNearbyGameObjects

senseNearbyGameObjects

senseNearbyGameObjects

senseBroadcastingRobots

senseBroadcastingRobots

senseBroadcastingRobotLocations

senseBroadcastingRobotLocations

senseLocationOf

senseRobotInfo

canSenseObject

canSenseSquare

senseHQLocation

senseEnemyHQLocation

sensePastrLocations

senseCowGrowth

senseCowsAtLocation

roundsUntilActive

isActive

move

sneak

canMove

canAttackSquare

attackSquare

attackSquareLight

broadcast

readBroadcast

spawn

construct

yield

selfDestruct

resign

win

wearHat

setIndicatorString

senseTerrainTile

getControlBits

addMatchObservation

setTeamMemory

setTeamMemory

getTeamMemory

breakpoint