RobotController (Battlecode 2017)

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

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`broadcast(int channel, int data)` Broadcasts an integer to the team-shared array at index channel.
`void`	`broadcastBoolean(int channel, boolean data)` Broadcasts a boolean to the team-shared array at index channel.
`void`	`broadcastFloat(int channel, float data)` Broadcasts a float to the team-shared array at index channel.
`void`	`broadcastInt(int channel, int data)` Broadcasts an int to the team-shared array at index channel.
`void`	`buildRobot(RobotType type, Direction dir)` Builds a robot of the given type in the given direction.
`boolean`	`canBuildRobot(RobotType type, Direction dir)` Tests whether the robot can build a robot of the given type in the given direction.
`boolean`	`canChop(int id)` Tests whether the robot can chop a tree with the given ID.
`boolean`	`canChop(MapLocation loc)` Tests whether the robot can chop a tree at the given location.
`boolean`	`canFirePentadShot()` Tests whether there is enough bullets in your bullet supply to fire a pentad shot, the robot is of an appropriate type, and the robot has not attacked in the current turn.
`boolean`	`canFireSingleShot()` Tests whether there are enough bullets in your bullet supply to fire a single shot, the robot is of an appropriate type, and the robot has not attacked in the current turn.
`boolean`	`canFireTriadShot()` Tests whether there are enough bullets in your bullet supply to fire a triad shot, the robot is of an appropriate type, and the robot has not attacked in the current turn.
`boolean`	`canHireGardener(Direction dir)` Tests whether the robot can hire a Gardener in the given direction.
`boolean`	`canInteractWithTree(int id)` Tests whether there is a tree with the given ID and, if so, if the tree is within one stride of this robot and can therefore be interacted with through chop(), shake(), or water().
`boolean`	`canInteractWithTree(MapLocation loc)` Tests whether there is a tree at the given location and, if so, if the tree is within one stride of this robot and can therefore be interacted with through chop(), shake(), or water().
`boolean`	`canMove(Direction dir)` Tells whether this robot can move one stride in the given direction, without taking into account if they have already moved.
`boolean`	`canMove(Direction dir, float distance)` Tests whether this robot can move `distance` units in the given direction, without taking into account if they have already moved.
`boolean`	`canMove(MapLocation center)` Tests whether this robot can move to the target MapLocation.
`boolean`	`canPlantTree(Direction dir)` Tests whether the robot can build a bullet tree in the given direction.
`boolean`	`canSenseAllOfCircle(MapLocation center, float radius)` Senses whether all of the given circle is within the robot's sensor range.
`boolean`	`canSenseBullet(int id)` Tests the given bullet exists and it is within this robot's sensor range.
`boolean`	`canSenseBulletLocation(MapLocation loc)` Senses whether the given location is within the robot's bullet sense range.
`boolean`	`canSenseLocation(MapLocation loc)` Senses whether the given location is within the robot's sensor range.
`boolean`	`canSensePartOfCircle(MapLocation center, float radius)` Senses whether any portion of the given circle is within the robot's sensor range.
`boolean`	`canSenseRadius(float radius)` Senses whether a point at the given radius is within the robot's sensor range.
`boolean`	`canSenseRobot(int id)` Tests whether the given robot exists and any part of the given robot is within this robot's sensor range.
`boolean`	`canSenseTree(int id)` Tests whether the given tree exists and any part of the given tree is within this robot's sensor range.
`boolean`	`canShake()` Tests whether this robot can shake a tree, taking into account how many times this robot has shaken this turn.
`boolean`	`canShake(int id)` Tests whether this robot can shake a tree with the given ID.
`boolean`	`canShake(MapLocation loc)` Tests whether this robot can shake a tree at the given location.
`boolean`	`canStrike()` Tests whether a robot is able to strike this turn.
`boolean`	`canWater()` Tests whether this robot can water a tree, taking into account how many times this robot has watered this turn and this robot's type.
`boolean`	`canWater(int id)` Tests whether this robot can water a tree with the given ID.
`boolean`	`canWater(MapLocation loc)` Tests whether this robot can water a tree at the given location.
`void`	`chop(int id)` Chops the tree with the given ID.
`void`	`chop(MapLocation loc)` Chops the tree at the given location.
`void`	`disintegrate()` Kills your robot and ends the current round.
`void`	`donate(float bullets)` Donates the given amount of bullets to the reforestation fund in exchange for one victory point per ten bullets donated.
`void`	`firePentadShot(Direction dir)` Fires a five bullets with the center bullet in the direction dir and with a spread of `GameConstants.PENTAD_SPREAD_DEGREES` degrees for the other bullets.
`void`	`fireSingleShot(Direction dir)` Fires a single bullet in the direction dir at the cost of `GameConstants.SINGLE_SHOT_COST` from your team's bullet supply.
`void`	`fireTriadShot(Direction dir)` Fires a three bullets with the center bullet in the direction dir and with a spread of `GameConstants.TRIAD_SPREAD_DEGREES` degrees for the other bullets.
`int`	`getAttackCount()` Returns the number of times the robot has attacked this turn.
`int`	`getBuildCooldownTurns()` Returns the number of cooldown turns remaining before this unit can build() again.
`long`	`getControlBits()` Gets this robot's 'control bits' for debugging purposes.
`float`	`getHealth()` Returns this robot's current health.
`int`	`getID()` Returns the ID of this robot.
`MapLocation[]`	`getInitialArchonLocations(Team t)` Returns a list of the INITIAL locations of the archons of a particular team.
`MapLocation`	`getLocation()` Returns this robot's current location.
`int`	`getMoveCount()` Returns the number of times the robot has moved this turn.
`int`	`getOpponentVictoryPoints()` Returns your opponent's total victory points.
`int`	`getRobotCount()` Returns the number of robots on your team, including your archons.
`int`	`getRoundLimit()` Returns the number of rounds in the game.
`int`	`getRoundNum()` Returns the current round number, where round 0 is the first round of the match.
`Team`	`getTeam()` Returns this robot's Team.
`float`	`getTeamBullets()` Returns the team's total bullet supply.
`long[]`	`getTeamMemory()` Returns the team memory from the last game of the match.
`int`	`getTeamVictoryPoints()` Returns the team's total victory points.
`int`	`getTreeCount()` Returns the number of trees on your team.
`RobotType`	`getType()` Returns this robot's type (SOLDIER, ARCHON, etc.).
`float`	`getVictoryPointCost()` Returns the current cost of a victory point in bullets.
`boolean`	`hasAttacked()` Returns whether the robot has attacked this turn.
`boolean`	`hasMoved()` Returns whether the robot has moved this turn.
`boolean`	`hasRobotBuildRequirements(RobotType type)` Tests whether you have the bullets and dependencies to build the given robot, and this robot is a valid builder for the target robot.
`boolean`	`hasTreeBuildRequirements()` Tests whether you have the bullets and dependencies to build a bullet tree, and this robot is a valid builder for a bullet tree.
`void`	`hireGardener(Direction dir)` Hires a Gardener in the given direction.
`boolean`	`isBuildReady()` Returns whether the robot's build cooldown has expired.
`boolean`	`isCircleOccupied(MapLocation center, float radius)` Senses whether there is any robot or tree within a given circle.
`boolean`	`isCircleOccupiedExceptByThisRobot(MapLocation center, float radius)` Senses whether there is any robot or tree within a given circle, ignoring this robot if it itself occupies the circle.
`boolean`	`isLocationOccupied(MapLocation loc)` Senses whether there is a robot or tree at the given location.
`boolean`	`isLocationOccupiedByRobot(MapLocation loc)` Senses whether there is a robot at the given location.
`boolean`	`isLocationOccupiedByTree(MapLocation loc)` Senses whether there is a tree at the given location.
`void`	`move(Direction dir)` Moves one stride in the given direction.
`void`	`move(Direction dir, float distance)` Moves distance in the given direction.
`void`	`move(MapLocation center)` Moves to the target MapLocation.
`boolean`	`onTheMap(MapLocation loc)` Senses whether a MapLocation is on the map.
`boolean`	`onTheMap(MapLocation center, float radius)` Senses whether a given circle is completely on the map.
`void`	`plantTree(Direction dir)` Plants a bullet tree in the given direction.
`int`	`readBroadcast(int channel)` Retrieves the integer stored in the team-shared array at index channel.
`boolean`	`readBroadcastBoolean(int channel)` Retrieves the boolean stored in the team-shared array at index channel.
`float`	`readBroadcastFloat(int channel)` Retrieves the float stored in the team-shared array at index channel.
`int`	`readBroadcastInt(int channel)` Retrieves the int stored in the team-shared array at index channel.
`void`	`resign()` Causes your team to lose the game.
`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).
`BulletInfo`	`senseBullet(int id)` Senses information about a particular bullet given its ID.
`BulletInfo[]`	`senseNearbyBullets()` Returns all bullets within bullet sense radius.
`BulletInfo[]`	`senseNearbyBullets(float radius)` Returns all bullets that can be sensed within a certain radius of this robot.
`BulletInfo[]`	`senseNearbyBullets(MapLocation center, float radius)` Returns all bullets that can be sensed within a certain radius of a specified location.
`RobotInfo[]`	`senseNearbyRobots()` Returns all robots within sense radius.
`RobotInfo[]`	`senseNearbyRobots(float radius)` Returns all robots that can be sensed within a certain radius of this robot.
`RobotInfo[]`	`senseNearbyRobots(float radius, Team team)` Returns all robots of a given team that can be sensed within a certain radius of this robot.
`RobotInfo[]`	`senseNearbyRobots(MapLocation center, float radius, Team team)` Returns all robots of a given team that can be sensed within a certain radius of a specified location.
`TreeInfo[]`	`senseNearbyTrees()` Returns all trees within sense radius.
`TreeInfo[]`	`senseNearbyTrees(float radius)` Returns all trees that can be sensed within a certain radius of this robot.
`TreeInfo[]`	`senseNearbyTrees(float radius, Team team)` Returns all trees of a given team that can be sensed within a certain radius of this robot.
`TreeInfo[]`	`senseNearbyTrees(MapLocation center, float radius, Team team)` Returns all trees of a given team that can be sensed within a certain radius of a specified location.
`RobotInfo`	`senseRobot(int id)` Senses information about a particular robot given its ID.
`RobotInfo`	`senseRobotAtLocation(MapLocation loc)` Senses the robot at the given location, or null if there is no robot there.
`TreeInfo`	`senseTree(int id)` Senses information about a particular tree given its ID.
`TreeInfo`	`senseTreeAtLocation(MapLocation loc)` Senses the tree at the given location, or null if there is no tree there.
`void`	`setIndicatorDot(MapLocation loc, int red, int green, int blue)` Draw a dot on the game map for debugging purposes.
`void`	`setIndicatorLine(MapLocation startLoc, MapLocation endLoc, int red, int green, int blue)` Draw a line on the game map 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`	`shake(int id)` Shakes the tree with the given ID for all the bullets held within the tree; these bullets will be added to your team's bullet supply.
`void`	`shake(MapLocation loc)` Shakes the tree at the given location for all the bullets held within the tree; these bullets will be added to your team's bullet supply.
`void`	`strike()` Strikes and deals damage to all other robots and trees within `GameConstants.LUMBERJACK_STRIKE_RADIUS` of this robot.
`void`	`water(int id)` Waters the target tree with the given ID, restoring `GameConstants.WATER_HEALTH_REGEN_RATE` health to the tree.
`void`	`water(MapLocation loc)` Waters the target tree at the given location, restoring `WATER_HEALTH_REGEN_RATE` health to the tree.

- Method Detail
  - getRoundLimit
```
int getRoundLimit()
```
    Returns the number of rounds in the game. After this many rounds, if neither team has been destroyed, tiebreakers will be used.
    
    Returns:
    
    the number of rounds in the game.
    
    Bytecode cost:
    1
  - getRoundNum
```
int getRoundNum()
```
    Returns the current round number, where round 0 is the first round of the match.
    
    Returns:
    
    the current round number, where round 0 is the first round of the match.
    
    Bytecode cost:
    1
  - getTeamBullets
```
float getTeamBullets()
```
    Returns the team's total bullet supply.
    
    Returns:
    
    the team's total bullet supply.
    
    Bytecode cost:
    1
  - getTeamVictoryPoints
```
int getTeamVictoryPoints()
```
    Returns the team's total victory points.
    
    Returns:
    
    the team's total victory points.
    
    Bytecode cost:
    1
  - getOpponentVictoryPoints
```
int getOpponentVictoryPoints()
```
    Returns your opponent's total victory points.
    
    Returns:
    
    your opponent's total victory points.
    
    Bytecode cost:
    1
  - getRobotCount
```
int getRobotCount()
```
    Returns the number of robots on your team, including your archons. If this number ever reaches zero, the opposing team will automatically win by destruction.
    
    Returns:
    
    the number of robots on your team, including your archons.
    
    Bytecode cost:
    20
  - getTreeCount
```
int getTreeCount()
```
    Returns the number of trees on your team.
    
    Returns:
    
    the number of trees on your team.
    
    Bytecode cost:
    20
  - getInitialArchonLocations
```
MapLocation[] getInitialArchonLocations(Team t)
```
    Returns a list of the INITIAL locations of the archons of a particular team. The locations will be sorted by increasing x, with ties broken by increasing y. Will return an empty list if you query for Team.NEUTRAL.
    
    Parameters:
    
    t - the team for which you want to query the initial archon locations. Will return an empty list if you query for Team.NEUTRAL
    
    Returns:
    
    a list of the INITIAL locations of the archons of that team, or an empty list for Team.NEUTRAL.
    
    Bytecode cost:
    100
  - getID
```
int getID()
```
    Returns the ID of this robot.
    
    Returns:
    
    the ID of this robot.
    
    Bytecode cost:
    1
  - getTeam
```
Team getTeam()
```
    Returns this robot's Team.
    
    Returns:
    
    this robot's Team.
    
    Bytecode cost:
    1
  - getType
```
RobotType getType()
```
    Returns this robot's type (SOLDIER, ARCHON, etc.).
    
    Returns:
    
    this robot's type.
    
    Bytecode cost:
    1
  - getLocation
```
MapLocation getLocation()
```
    Returns this robot's current location.
    
    Returns:
    
    this robot's current location.
    
    Bytecode cost:
    1
  - getHealth
```
float getHealth()
```
    Returns this robot's current health.
    
    Returns:
    
    this robot's current health.
    
    Bytecode cost:
    1
  - getAttackCount
```
int getAttackCount()
```
    Returns the number of times the robot has attacked this turn.
    
    Returns:
    
    the number of times the robot has attacked this turn.
    
    Bytecode cost:
    1
  - getMoveCount
```
int getMoveCount()
```
    Returns the number of times the robot has moved this turn.
    
    Returns:
    
    the number of times the robot has moved this turn.
    
    Bytecode cost:
    1
  - onTheMap
```
boolean onTheMap(MapLocation loc)
          throws GameActionException
```
    Senses whether a MapLocation is on the map. Will throw an exception if the location is not currently within sensor range.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    true if the location is on the map; false otherwise.
    
    Throws:
    
    GameActionException - if the location is not within sensor range.
    
    Bytecode cost:
    5
  - onTheMap
```
boolean onTheMap(MapLocation center,
                 float radius)
          throws GameActionException
```
    Senses whether a given circle is completely on the map. Will throw an exception if the circle is not completely within sensor range.
    
    Parameters:
    
    center - the center of the circle to check
    
    radius - the radius of the circle to check
    
    Returns:
    
    true if the circle is completely on the map; false otherwise.
    
    Throws:
    
    GameActionException - if any portion of the given circle is not within sensor range.
    
    Bytecode cost:
    5
  - canSenseBulletLocation
```
boolean canSenseBulletLocation(MapLocation loc)
```
    Senses whether the given location is within the robot's bullet sense range.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    true if the given location is within the robot's bullet sense range, false otherwise.
    
    Bytecode cost:
    5
  - canSenseLocation
```
boolean canSenseLocation(MapLocation loc)
```
    Senses whether the given location is within the robot's sensor range.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    true if the given location is within the robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - canSenseRadius
```
boolean canSenseRadius(float radius)
```
    Senses whether a point at the given radius is within the robot's sensor range.
    
    Parameters:
    
    radius - the radius to check
    
    Returns:
    
    true if the given location is within the robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - canSensePartOfCircle
```
boolean canSensePartOfCircle(MapLocation center,
                             float radius)
```
    Senses whether any portion of the given circle is within the robot's sensor range.
    
    Parameters:
    
    center - the center of the circle to check
    
    radius - the radius of the circle to check
    
    Returns:
    
    true if a portion of the circle is within the robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - canSenseAllOfCircle
```
boolean canSenseAllOfCircle(MapLocation center,
                            float radius)
```
    Senses whether all of the given circle is within the robot's sensor range.
    
    Parameters:
    
    center - the center of the circle to check
    
    radius - the radius of the circle to check
    
    Returns:
    
    true if all of the circle is within the robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - isLocationOccupied
```
boolean isLocationOccupied(MapLocation loc)
                    throws GameActionException
```
    Senses whether there is a robot or tree at the given location.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    true if there is a robot or tree at the given location; false otherwise.
    
    Throws:
    
    GameActionException - if the location is not within sensor range.
    
    Bytecode cost:
    20
  - isLocationOccupiedByTree
```
boolean isLocationOccupiedByTree(MapLocation loc)
                          throws GameActionException
```
    Senses whether there is a tree at the given location.
    
    Parameters:
    
    loc - the location to check.
    
    Returns:
    
    true if there is a tree at the given location; false otherwise.
    
    Throws:
    
    GameActionException - if the location is not within sensor range.
    
    Bytecode cost:
    20
  - isLocationOccupiedByRobot
```
boolean isLocationOccupiedByRobot(MapLocation loc)
                           throws GameActionException
```
    Senses whether there is a robot at the given location.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    true if there is a robot at the given location; false otherwise.
    
    Throws:
    
    GameActionException - if the location is not within sensor range.
    
    Bytecode cost:
    20
  - isCircleOccupied
```
boolean isCircleOccupied(MapLocation center,
                         float radius)
                  throws GameActionException
```
    Senses whether there is any robot or tree within a given circle.
    
    Parameters:
    
    center - the center of the circle to check
    
    radius - the radius of the circle to check
    
    Returns:
    
    true if there is a robot or tree in the given circle; false otherwise.
    
    Throws:
    
    GameActionException - if any portion of the given circle is not within sensor range.
    
    Bytecode cost:
    20
  - isCircleOccupiedExceptByThisRobot
```
boolean isCircleOccupiedExceptByThisRobot(MapLocation center,
                                          float radius)
                                   throws GameActionException
```
    Senses whether there is any robot or tree within a given circle, ignoring this robot if it itself occupies the circle.
    
    Parameters:
    
    center - the center of the circle to check
    
    radius - the radius of the circle to check
    
    Returns:
    
    true if there is a robot or tree in the given circle; false otherwise.
    
    Throws:
    
    GameActionException - if any portion of the given circle is not within sensor range.
    
    Bytecode cost:
    20
  - senseTreeAtLocation
```
TreeInfo senseTreeAtLocation(MapLocation loc)
                      throws GameActionException
```
    Senses the tree at the given location, or null if there is no tree there.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    the tree at the given location.
    
    Throws:
    
    GameActionException - if the location is not within sensor range.
    
    Bytecode cost:
    20
  - senseRobotAtLocation
```
RobotInfo senseRobotAtLocation(MapLocation loc)
                        throws GameActionException
```
    Senses the robot at the given location, or null if there is no robot there.
    
    Parameters:
    
    loc - the location to check
    
    Returns:
    
    the robot at the given location.
    
    Throws:
    
    GameActionException - if the location is not within sensor range.
    
    Bytecode cost:
    20
  - canSenseTree
```
boolean canSenseTree(int id)
```
    Tests whether the given tree exists and any part of the given tree is within this robot's sensor range.
    
    Parameters:
    
    id - the ID of the tree to query
    
    Returns:
    
    true if the given tree is within this robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - canSenseRobot
```
boolean canSenseRobot(int id)
```
    Tests whether the given robot exists and any part of the given robot is within this robot's sensor range.
    
    Parameters:
    
    id - the ID of the robot to query
    
    Returns:
    
    true if the given robot is within this robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - canSenseBullet
```
boolean canSenseBullet(int id)
```
    Tests the given bullet exists and it is within this robot's sensor range.
    
    Parameters:
    
    id - the ID of the bullet to query
    
    Returns:
    
    true if the given bullet is within this robot's sensor range; false otherwise.
    
    Bytecode cost:
    5
  - senseTree
```
TreeInfo senseTree(int id)
            throws GameActionException
```
    Senses information about a particular tree given its ID.
    
    Parameters:
    
    id - the ID of the tree to query
    
    Returns:
    
    a TreeInfo object for the sensed tree.
    
    Throws:
    
    GameActionException - if the tree cannot be sensed (for example, if it doesn't exist or is out of sight range).
    
    Bytecode cost:
    25
  - senseRobot
```
RobotInfo senseRobot(int id)
              throws GameActionException
```
    Senses information about a particular robot given its ID.
    
    Parameters:
    
    id - the ID of the robot to query
    
    Returns:
    
    a RobotInfo object for the sensed robot.
    
    Throws:
    
    GameActionException - if the robot cannot be sensed (for example, if it doesn't exist or is out of sight range).
    
    Bytecode cost:
    25
  - senseBullet
```
BulletInfo senseBullet(int id)
                throws GameActionException
```
    Senses information about a particular bullet given its ID.
    
    Parameters:
    
    id - the ID of the bullet to query
    
    Returns:
    
    a BulletInfo object for the sensed bullet.
    
    Throws:
    
    GameActionException - if the bullet cannot be sensed (for example, if it doesn't exist or is out of sight range).
    
    Bytecode cost:
    25
  - senseNearbyRobots
```
RobotInfo[] senseNearbyRobots()
```
    Returns all robots within sense radius. The objects are returned in order of increasing distance from your robot.
    
    Returns:
    
    sorted array of RobotInfo objects, which contain information about all the robots you sensed.
    
    Bytecode cost:
    100
  - senseNearbyRobots
```
RobotInfo[] senseNearbyRobots(float radius)
```
    Returns all robots that can be sensed within a certain radius of this robot. The objects are returned in order of increasing distance from your robot.
    
    Parameters:
    
    radius - return robots this distance away from the center of this robot. If -1 is passed, all robots within sense radius are returned.
    
    Returns:
    
    sorted array of RobotInfo objects of all the robots you sensed.
    
    Bytecode cost:
    100
  - senseNearbyRobots
```
RobotInfo[] senseNearbyRobots(float radius,
                              Team team)
```
    Returns all robots of a given team that can be sensed within a certain radius of this robot. The objects are returned in order of increasing distance from your robot.
    
    Parameters:
    
    radius - return robots this distance away from the center of this robot. If -1 is passed, all robots within sense radius are returned
    
    team - filter game objects by the given team. If null is passed, robots from any team are returned
    
    Returns:
    
    sorted array of RobotInfo objects of all the robots you sensed.
    
    Bytecode cost:
    100
  - senseNearbyRobots
```
RobotInfo[] senseNearbyRobots(MapLocation center,
                              float radius,
                              Team team)
```
    Returns all robots of a given team that can be sensed within a certain radius of a specified location. The objects are returned in order of increasing distance from the specified center.
    
    Parameters:
    
    center - center of the given search radius
    
    radius - return robots this distance away from the given center location. If -1 is passed, all robots within sense radius are returned
    
    team - filter game objects by the given team. If null is passed, objects from all teams are returned
    
    Returns:
    
    sorted array of RobotInfo objects of the robots you sensed.
    
    Bytecode cost:
    100
  - senseNearbyTrees
```
TreeInfo[] senseNearbyTrees()
```
    Returns all trees within sense radius. The objects are returned in order of increasing distance from your robot.
    
    Returns:
    
    sorted array of TreeInfo objects, which contain information about all the trees you sensed.
    
    Bytecode cost:
    100
  - senseNearbyTrees
```
TreeInfo[] senseNearbyTrees(float radius)
```
    Returns all trees that can be sensed within a certain radius of this robot. The objects are returned in order of increasing distance from your robot.
    
    Parameters:
    
    radius - return trees this distance away from the center of this robot. If -1 is passed, all trees within sense radius are returned
    
    Returns:
    
    sorted array of TreeInfo objects of all the trees you sensed.
    
    Bytecode cost:
    100
  - senseNearbyTrees
```
TreeInfo[] senseNearbyTrees(float radius,
                            Team team)
```
    Returns all trees of a given team that can be sensed within a certain radius of this robot. The objects are returned in order of increasing distance from your robot.
    
    Parameters:
    
    radius - return trees this distance away from the center of this robot. If -1 is passed, all trees within sense radius are returned
    
    team - filter game objects by the given team. If null is passed, robots from any team are returned
    
    Returns:
    
    sorted array of TreeInfo objects of all the trees you sensed.
    
    Bytecode cost:
    100
  - senseNearbyTrees
```
TreeInfo[] senseNearbyTrees(MapLocation center,
                            float radius,
                            Team team)
```
    Returns all trees of a given team that can be sensed within a certain radius of a specified location. The objects are returned in order of increasing distance from the specified center.
    
    Parameters:
    
    center - center of the given search radius
    
    radius - return trees this distance away from given center location. If -1 is passed, all trees within sense radius are returned
    
    team - filter game objects by the given team. If null is passed, objects from all teams are returned
    
    Returns:
    
    sorted array of TreeInfo objects of the trees you sensed.
    
    Bytecode cost:
    100
  - senseNearbyBullets
```
BulletInfo[] senseNearbyBullets()
```
    Returns all bullets within bullet sense radius. The objects are returned in order of increasing distance from your robot.
    
    Returns:
    
    sorted array of BulletInfo objects, which contain information about all the bullets you sensed.
    
    Bytecode cost:
    50
  - senseNearbyBullets
```
BulletInfo[] senseNearbyBullets(float radius)
```
    Returns all bullets that can be sensed within a certain radius of this robot. The objects are returned in order of increasing distance from your robot.
    
    Parameters:
    
    radius - return bullets this distance away from the center of this robot. If -1 is passed, bullets from the whole map are returned
    
    Returns:
    
    sorted array of BulletInfo objects of all the bullets you sensed.
    
    Bytecode cost:
    50
  - senseNearbyBullets
```
BulletInfo[] senseNearbyBullets(MapLocation center,
                                float radius)
```
    Returns all bullets that can be sensed within a certain radius of a specified location. The objects are returned in order of increasing distance from the specified center.
    
    Parameters:
    
    center - center of the given search radius
    
    radius - return bullets this distance away from the given center location. If -1 is passed, all bullets within bullet sense radius are returned
    
    Returns:
    
    sorted array of TreeInfo objects of the bullets you sensed.
    
    Bytecode cost:
    50
  - 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
  - hasMoved
```
boolean hasMoved()
```
    Returns whether the robot has moved this turn.
    
    Returns:
    
    true if the robot has moved this turn; false otherwise.
    
    Bytecode cost:
    1
  - hasAttacked
```
boolean hasAttacked()
```
    Returns whether the robot has attacked this turn.
    
    Returns:
    
    true if the robot has attacked this turn; false otherwise.
    
    Bytecode cost:
    1
  - isBuildReady
```
boolean isBuildReady()
```
    Returns whether the robot's build cooldown has expired.
    
    Returns:
    
    true if the robot's build cooldown has expired; false otherwise.
    
    Bytecode cost:
    1
  - getBuildCooldownTurns
```
int getBuildCooldownTurns()
```
    Returns the number of cooldown turns remaining before this unit can build() again. When this number is 0, isBuildReady() is true.
    
    Returns:
    
    the number of cooldown turns remaining before this unit can build() again.
    
    Bytecode cost:
    1
  - canMove
```
boolean canMove(Direction dir)
```
    Tells whether this robot can move one stride in the given direction, without taking into account if they have already moved. Takes into account only the positions of trees, positions of other robots, and the edge of the game map. Does not take into account whether this robot is currently active. Note that one stride is equivalent to this robot's strideRadius.
    
    Parameters:
    
    dir - the direction to move in
    
    Returns:
    
    true if there is no external obstruction to prevent this robot from moving one stride in the given direction; false otherwise.
    
    Bytecode cost:
    10
  - canMove
```
boolean canMove(Direction dir,
                float distance)
```
    Tests whether this robot can move distance units in the given direction, without taking into account if they have already moved. Takes into account only the positions of trees, positions of other robots, and the edge of the game map. Does not take into account whether this robot is currently active. Note that one stride is equivalent to this robot's strideRadius.
    
    Parameters:
    
    dir - the direction to move in
    
    distance - the distance of a move you wish to check. Must be in [0, RobotType.strideRadius]
    
    Returns:
    
    true if there is no external obstruction to prevent this robot from moving distance in the given direction; false otherwise.
    
    Bytecode cost:
    10
  - canMove
```
boolean canMove(MapLocation center)
```
    Tests whether this robot can move to the target MapLocation. If the location is outside the robot's strideRadius, the location is rescaled to be at the strideRadius. Takes into account only the positions of trees, other robots, and the edge of the game map. Does not take into account whether this robot is currently active.
    
    Parameters:
    
    center - the MapLocation to move to
    
    Returns:
    
    true if there is no external obstruction to prevent this robot from moving to this MapLocation (or in the direction of this MapLocation if it is too far); false otherwise.
    
    Bytecode cost:
    10
  - move
```
void move(Direction dir)
   throws GameActionException
```
    Moves one stride in the given direction. Note that one stride is equivalent to this robot's strideRadius.
    
    Parameters:
    
    dir - the direction to move in
    
    Throws:
    
    GameActionException - if the robot cannot move one stride in this direction, such as already moved that turn, the target location being off the map, and the target destination being occupied with either another robot or a tree.
    
    Bytecode cost:
    0
  - move
```
void move(Direction dir,
          float distance)
   throws GameActionException
```
    Moves distance in the given direction. If the distance exceeds the robot's strideRadius, it is rescaled to strideRadius.
    
    Parameters:
    
    dir - the direction to move in
    
    distance - the distance to move in that direction
    
    Throws:
    
    GameActionException - if the robot cannot move distance in this direction, such as already moved that turn, the target location being off the map, and the target destination being occupied with either another robot or a tree.
    
    Bytecode cost:
    0
  - move
```
void move(MapLocation center)
   throws GameActionException
```
    Moves to the target MapLocation. If the target location is outside the robot's strideRadius, it is rescaled to be strideRadius away.
    
    Parameters:
    
    center - the MapLocation to move to (or toward)
    
    Throws:
    
    GameActionException - if the robot can not move to the target MapLocation, such as already having moved that turn, the target location being off the map, or a target destination being occupied with either another robot or a tree.
    
    Bytecode cost:
    0
  - canStrike
```
boolean canStrike()
```
    Tests whether a robot is able to strike this turn. This takes into accout the robot's type, and if the robot has attacked this turn.
    
    Returns:
    
    true if the robot is able to strike this turn; false otherwise.
    
    Bytecode cost:
    5
  - strike
```
void strike()
     throws GameActionException
```
    Strikes and deals damage to all other robots and trees within GameConstants.LUMBERJACK_STRIKE_RADIUS of this robot. Note that only Lumberjacks can perform this function.
    
    Throws:
    
    GameActionException - if the robot is not of type LUMBERJACK or cannot attack due to having already attacked that turn.
    
    Bytecode cost:
    0
  - canFireSingleShot
```
boolean canFireSingleShot()
```
    Tests whether there are enough bullets in your bullet supply to fire a single shot, the robot is of an appropriate type, and the robot has not attacked in the current turn.
    
    Returns:
    
    true if there are enough bullets in the bullet supply, this robot is of an appropriate type, and the robot hasn't attacked this turn; false otherwise.
    
    Bytecode cost:
    5
  - canFireTriadShot
```
boolean canFireTriadShot()
```
    Tests whether there are enough bullets in your bullet supply to fire a triad shot, the robot is of an appropriate type, and the robot has not attacked in the current turn.
    
    Returns:
    
    true if there are enough bullets in the bullet supply, this robot is of an appropriate type, and the robot hasn't attacked this turn; false otherwise.
    
    Bytecode cost:
    5
  - canFirePentadShot
```
boolean canFirePentadShot()
```
    Tests whether there is enough bullets in your bullet supply to fire a pentad shot, the robot is of an appropriate type, and the robot has not attacked in the current turn.
    
    Returns:
    
    true if there are enough bullets in the bullet supply, this robot is of an appropriate type, and the robot hasn't attacked this turn; false otherwise.
    
    Bytecode cost:
    5
  - fireSingleShot
```
void fireSingleShot(Direction dir)
             throws GameActionException
```
    Fires a single bullet in the direction dir at the cost of GameConstants.SINGLE_SHOT_COST from your team's bullet supply. The speed and damage of the bullet is determined from the type of this robot.
    
    Parameters:
    
    dir - the direction you wish to fire the bullet
    
    Throws:
    
    GameActionException - if this robot is not of a type that can fire single shots (ARCHON, GARDENER, etc.), cannot attack due to having already attacked, or for having insufficient bullets in the bullet supply.
    
    Bytecode cost:
    0
  - fireTriadShot
```
void fireTriadShot(Direction dir)
            throws GameActionException
```
    Fires a three bullets with the center bullet in the direction dir and with a spread of GameConstants.TRIAD_SPREAD_DEGREES degrees for the other bullets. This function costs GameConstants.TRIAD_SHOT_COST bullets from your team's supply. The speed and damage of the bullets is determined from the type of this robot.
    
    Parameters:
    
    dir - the direction you wish to fire the center bullet
    
    Throws:
    
    GameActionException - if this robot is not of a type that can fire triad shots (ARCHON, GARDENER, etc.), cannot attack due to having already attacked, or for having insufficient bullets in the bullet supply.
    
    Bytecode cost:
    0
  - firePentadShot
```
void firePentadShot(Direction dir)
             throws GameActionException
```
    Fires a five bullets with the center bullet in the direction dir and with a spread of GameConstants.PENTAD_SPREAD_DEGREES degrees for the other bullets. This function costs GameConstants.PENTAD_SHOT_COST bullets from your team's supply. The speed and damage of the bullets is determined from the type of this robot.
    
    Parameters:
    
    dir - the direction you wish to fire the center bullet
    
    Throws:
    
    GameActionException - if this robot is not of a type that can fire pentad shots (ARCHON, GARDENER, etc.), cannot attack due to having already attacked, or for having insufficient bullets in the bullet supply.
    
    Bytecode cost:
    0
  - canChop
```
boolean canChop(MapLocation loc)
```
    Tests whether the robot can chop a tree at the given location. Checks if the location is within GameConstants.INTERACTION_DIST_FROM_EDGE, the robot's type, if a tree exists, and if the robot hasn't attacked this turn.
    
    Parameters:
    
    loc - The location of the tree to chop
    
    Returns:
    
    true if this robot can chop the tree; false otherwise.
    
    Bytecode cost:
    5
  - canChop
```
boolean canChop(int id)
```
    Tests whether the robot can chop a tree with the given ID. Checks if the tree is within GameConstants.INTERACTION_DIST_FROM_EDGE, the robot's type, if a tree exists, and if the robot hasn't attacked this turn.
    
    Parameters:
    
    id - The ID of the tree to chop
    
    Returns:
    
    true if this robot can chop the tree; false otherwise.
    
    Bytecode cost:
    5
  - chop
```
void chop(MapLocation loc)
   throws GameActionException
```
    Chops the tree at the given location. This action counts as an attack.
    
    Parameters:
    
    loc - the location of the tree to chop
    
    Throws:
    
    GameActionException - if the given location does not contain a tree, the specified tree is not within GameConstants.INTERACTION_DIST_FROM_EDGE of this robot, this robot is not of type LUMBERJACK, or this robot has already attacked this turn.
    
    Bytecode cost:
    0
  - chop
```
void chop(int id)
   throws GameActionException
```
    Chops the tree with the given ID. This action counts as an attack.
    
    Parameters:
    
    id - the ID of the tree you wish to chop
    
    Throws:
    
    GameActionException - if there isn't a tree with the given id, the specified tree is not within one stride of this robot, this robot is not of type LUMBERJACK, or this robot has already attacked this turn.
    
    Bytecode cost:
    0
  - canShake
```
boolean canShake(MapLocation loc)
```
    Tests whether this robot can shake a tree at the given location. Checks if the tree is within GameConstants.INTERACTION_DIST_FROM_EDGE, if a tree exists, and if the robot hasn't shaken this turn.
    
    Parameters:
    
    loc - The location of the tree to shake
    
    Returns:
    
    true if this robot can shake the tree; false otherwise.
    
    Bytecode cost:
    5
  - canShake
```
boolean canShake(int id)
```
    Tests whether this robot can shake a tree with the given ID. Checks if the tree is within GameConstants.INTERACTION_DIST_FROM_EDGE, if a tree exists, and if the robot hasn't shaken this turn.
    
    Parameters:
    
    id - The ID of the tree to shake
    
    Returns:
    
    true if this robot can shake the tree; false otherwise.
    
    Bytecode cost:
    5
  - shake
```
void shake(MapLocation loc)
    throws GameActionException
```
    Shakes the tree at the given location for all the bullets held within the tree; these bullets will be added to your team's bullet supply. Robots can only shake once per turn.
    
    Parameters:
    
    loc - the location of the tree to shake
    
    Throws:
    
    GameActionException - if the given location does not contain a tree, if the tree (not location) is not within GameConstants.INTERACTION_DIST_FROM_EDGE of this robot, or if this robot has already shaken a tree this turn.
    
    Bytecode cost:
    0
  - shake
```
void shake(int id)
    throws GameActionException
```
    Shakes the tree with the given ID for all the bullets held within the tree; these bullets will be added to your team's bullet supply. Robots can only shake once per turn.
    
    Parameters:
    
    id - the ID of the tree to shake
    
    Throws:
    
    GameActionException - if there isn't a tree with the given id, if the tree (not location) is not within one stride of this robot, or if this robot has already shaken a tree this turn
    
    Bytecode cost:
    0
  - canWater
```
boolean canWater(MapLocation loc)
```
    Tests whether this robot can water a tree at the given location. Checks robot stride radius, the robot's type, if a tree exists, and if the robot hasn't watered this turn.
    
    Parameters:
    
    loc - The location of the tree to water
    
    Returns:
    
    true if this robot can water the tree; false otherwise.
    
    Bytecode cost:
    5
  - canWater
```
boolean canWater(int id)
```
    Tests whether this robot can water a tree with the given ID. Checks that the tree is within GameConstants.INTERACTION_DIST_FROM_EDGE, the robot's type, if a tree exists, and if the robot hasn't watered this turn.
    
    Parameters:
    
    id - The ID of a tree to check.
    
    Returns:
    
    true if this robot can water a tree; false otherwise.
    
    Bytecode cost:
    5
  - water
```
void water(MapLocation loc)
    throws GameActionException
```
    Waters the target tree at the given location, restoring WATER_HEALTH_REGEN_RATE health to the tree. Robots can only water once per turn and only with robots of type GARDENER.
    
    Parameters:
    
    loc - the location of the tree you wish to water
    
    Throws:
    
    GameActionException - if the given location does not contain a tree, the tree is not within GameConstants.INTERACTION_DIST_FROM_EDGE of this robot, this robot is not of type GARDENER, or this robot has already watered a tree.
    
    Bytecode cost:
    0
  - water
```
void water(int id)
    throws GameActionException
```
    Waters the target tree with the given ID, restoring GameConstants.WATER_HEALTH_REGEN_RATE health to the tree. Robots can only water once per turn and only with robots of type GARDENER.
    
    Parameters:
    
    id - the ID of the tree you wish to water.
    
    Throws:
    
    GameActionException - if there isn't a tree with the given id, the tree is not within GameConstants.INTERACTION_DIST_FROM_EDGE of this robot, this robot is not of type GARDENER, or this robot has already watered a tree.
    
    Bytecode cost:
    0
  - canWater
```
boolean canWater()
```
    Tests whether this robot can water a tree, taking into account how many times this robot has watered this turn and this robot's type.
    
    Returns:
    
    true if this robot can water a tree; false otherwise.
    
    Bytecode cost:
    5
  - canShake
```
boolean canShake()
```
    Tests whether this robot can shake a tree, taking into account how many times this robot has shaken this turn.
    
    Returns:
    
    true if this robot can shake a tree; false otherwise.
    
    Bytecode cost:
    5
  - canInteractWithTree
```
boolean canInteractWithTree(MapLocation loc)
```
    Tests whether there is a tree at the given location and, if so, if the tree is within one stride of this robot and can therefore be interacted with through chop(), shake(), or water().
    
    Parameters:
    
    loc - the location you wish to test
    
    Returns:
    
    true if there is a tree located at loc and if said tree is within GameConstants.INTERACTION_DIST_FROM_EDGE of this robot.
    
    Bytecode cost:
    5
  - canInteractWithTree
```
boolean canInteractWithTree(int id)
```
    Tests whether there is a tree with the given ID and, if so, if the tree is within one stride of this robot and can therefore be interacted with through chop(), shake(), or water().
    
    Parameters:
    
    id - the ID of the tree you wish to test
    
    Returns:
    
    true if there is a tree with id and if said tree is within GameConstants.INTERACTION_DIST_FROM_EDGE of this robot.
    
    Bytecode cost:
    5
  - broadcast
```
void broadcast(int channel,
               int data)
        throws GameActionException
```
    Broadcasts an integer to the team-shared array at index channel. The data is not written until the end of the robot's turn.
    
    Parameters:
    
    channel - the index to write to, from 0 to BROADCAST_MAX_CHANNELS
    
    data - one int of data to write
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    See Also:
    
    broadcastInt(int channel, int data)
    
    Bytecode cost:
    10
  - readBroadcast
```
int readBroadcast(int channel)
           throws GameActionException
```
    Retrieves the integer stored in the team-shared array at index channel.
    
    Parameters:
    
    channel - the index to query, from 0 to BROADCAST_MAX_CHANNELS
    
    Returns:
    
    the data currently stored on the channel, interpreted as an int.
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    See Also:
    
    readBroadcastInt(int channel)
    
    Bytecode cost:
    5
  - broadcastBoolean
```
void broadcastBoolean(int channel,
                      boolean data)
               throws GameActionException
```
    Broadcasts a boolean to the team-shared array at index channel. The data is not written until the end of the robot's turn.
    
    Parameters:
    
    channel - the index to write to, from 0 to BROADCAST_MAX_CHANNELS
    
    data - one int of data to write
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    Bytecode cost:
    10
  - readBroadcastBoolean
```
boolean readBroadcastBoolean(int channel)
                      throws GameActionException
```
    Retrieves the boolean stored in the team-shared array at index channel.
    
    Parameters:
    
    channel - the index to query, from 0 to BROADCAST_MAX_CHANNELS
    
    Returns:
    
    the data currently stored on the channel, interpreted as a boolean.
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    Bytecode cost:
    5
  - broadcastInt
```
void broadcastInt(int channel,
                  int data)
           throws GameActionException
```
    Broadcasts an int to the team-shared array at index channel. The data is not written until the end of the robot's turn.
    
    Parameters:
    
    channel - the index to write to, from 0 to BROADCAST_MAX_CHANNELS
    
    data - one int of data to write
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    See Also:
    
    broadcast(int channel, int data)
    
    Bytecode cost:
    10
  - readBroadcastInt
```
int readBroadcastInt(int channel)
              throws GameActionException
```
    Retrieves the int stored in the team-shared array at index channel.
    
    Parameters:
    
    channel - the index to query, from 0 to BROADCAST_MAX_CHANNELS
    
    Returns:
    
    the data currently stored on the channel, interpreted as an int.
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    See Also:
    
    readBroadcast(int channel)
    
    Bytecode cost:
    5
  - broadcastFloat
```
void broadcastFloat(int channel,
                    float data)
             throws GameActionException
```
    Broadcasts a float to the team-shared array at index channel. The data is not written until the end of the robot's turn.
    
    Parameters:
    
    channel - the index to write to, from 0 to BROADCAST_MAX_CHANNELS
    
    data - one float of data to write
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    Bytecode cost:
    10
  - readBroadcastFloat
```
float readBroadcastFloat(int channel)
                  throws GameActionException
```
    Retrieves the float stored in the team-shared array at index channel.
    
    Parameters:
    
    channel - the index to query, from 0 to BROADCAST_MAX_CHANNELS
    
    Returns:
    
    the data currently stored on the channel, interpreted as a float.
    
    Throws:
    
    GameActionException - if the channel is invalid
    
    Bytecode cost:
    5
  - hasRobotBuildRequirements
```
boolean hasRobotBuildRequirements(RobotType type)
```
    Tests whether you have the bullets and dependencies to build the given robot, and this robot is a valid builder for the target robot.
    
    Parameters:
    
    type - the type of robot to build
    
    Returns:
    
    true if the requirements to build the given robot are met; false otherwise.
    
    Bytecode cost:
    5
  - hasTreeBuildRequirements
```
boolean hasTreeBuildRequirements()
```
    Tests whether you have the bullets and dependencies to build a bullet tree, and this robot is a valid builder for a bullet tree.
    
    Returns:
    
    true if the requirements to plant a tree are met; false otherwise.
    
    Bytecode cost:
    5
  - canBuildRobot
```
boolean canBuildRobot(RobotType type,
                      Direction dir)
```
    Tests whether the robot can build a robot of the given type in the given direction. Checks cooldown turns remaining, bullet costs, whether the robot can build, and that the given direction is not blocked.
    
    Parameters:
    
    dir - the direction to build in
    
    type - the type of robot to build
    
    Returns:
    
    whether it is possible to build a robot of the given type in the given direction.
    
    Bytecode cost:
    10
  - buildRobot
```
void buildRobot(RobotType type,
                Direction dir)
         throws GameActionException
```
    Builds a robot of the given type in the given direction.
    
    Parameters:
    
    dir - the direction to spawn the unit
    
    type - the type of robot to build
    
    Throws:
    
    GameActionException - if you don't have enough bullets, if the robot is still in build cooldown, if the direction is not a good build direction, or if this robot is not of an appropriate type.
    
    Bytecode cost:
    0
  - canPlantTree
```
boolean canPlantTree(Direction dir)
```
    Tests whether the robot can build a bullet tree in the given direction. Checks cooldown turns remaining, bullet costs, whether the robot can plant, and that the given direction is not blocked
    
    Parameters:
    
    dir - the direction to build in
    
    Returns:
    
    whether it is possible to build a bullet tree in the given direction.
    
    Bytecode cost:
    10
  - plantTree
```
void plantTree(Direction dir)
        throws GameActionException
```
    Plants a bullet tree in the given direction.
    
    Parameters:
    
    dir - the direction to plant the bullet tree
    
    Throws:
    
    GameActionException - if you don't have enough bullets, if the robot is still in build cooldown, if the direction is not a good build direction, or if this robot is not of an appropriate type.
    
    Bytecode cost:
    0
  - canHireGardener
```
boolean canHireGardener(Direction dir)
```
    Tests whether the robot can hire a Gardener in the given direction. Checks cooldown turns remaining, bullet costs, whether the robot can hire, and that the given direction is not blocked.
    
    Parameters:
    
    dir - the direction to build in
    
    Returns:
    
    whether it is possible to hire a gardener in the given direction.
    
    Bytecode cost:
    10
  - hireGardener
```
void hireGardener(Direction dir)
           throws GameActionException
```
    Hires a Gardener in the given direction.
    
    Parameters:
    
    dir - the direction to spawn the Gardener
    
    Throws:
    
    GameActionException - if you don't have enough bullets, if the robot is still in build cooldown, if the direction is not a good build direction, or if this robot is not of an appropriate type.
    
    Bytecode cost:
    0
  - getVictoryPointCost
```
float getVictoryPointCost()
```
    Returns the current cost of a victory point in bullets. This varies based on the round number, and is equal to GameConstants.VP_BASE_COST + NumRounds * GameConstants.VP_INCREASE_PER_ROUND.
    
    Returns:
    
    the current cost of a victory point in bullets
    
    Bytecode cost:
    0
  - donate
```
void donate(float bullets)
     throws GameActionException
```
    Donates the given amount of bullets to the reforestation fund in exchange for one victory point per ten bullets donated. Note there are no fractions of victory points, meaning, for example, donating 11 bullets will only result in 1 victory point, not 1.1 victory points.
    
    Parameters:
    
    bullets - the amount of bullets you wish to donate
    
    Throws:
    
    GameActionException - if you have less bullets in your bullet supply than the amount of bullet you wish to donate.
    
    Bytecode cost:
    0
  - disintegrate
```
void disintegrate()
```
    Kills your robot and ends the current round. Never fails.
    
    Bytecode cost:
    0
  - resign
```
void resign()
```
    Causes your team to lose the game. It's like typing "gg."
    
    Bytecode cost:
    0
  - setIndicatorDot
```
void setIndicatorDot(MapLocation loc,
                     int red,
                     int green,
                     int blue)
```
    Draw a dot on the game map for debugging purposes.
    
    Parameters:
    
    loc - the location to draw the dot.
    
    red - the red component of the dot's color.
    
    green - the green component of the dot's color.
    
    blue - the blue component of the dot's color.
    
    Bytecode cost:
    0
  - setIndicatorLine
```
void setIndicatorLine(MapLocation startLoc,
                      MapLocation endLoc,
                      int red,
                      int green,
                      int blue)
```
    Draw a line on the game map for debugging purposes.
    
    Parameters:
    
    startLoc - the location to draw the line from.
    
    endLoc - the location to draw the line to.
    
    red - the red component of the line's color.
    
    green - the green component of the line's color.
    
    blue - the blue component of the line's color.
    
    Bytecode cost:
    0
  - 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:
    
    java.lang.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:
    0
  - 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:
    
    java.lang.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:
    0
  - 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)
    
    Bytecode cost:
    0
  - 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. To set these bits, you must run the client in lockstep mode and right click the units.
    
    Returns:
    
    this robot's control bits.
    
    Bytecode cost:
    0

Interface RobotController

Method Summary

Method Detail

getRoundLimit

getRoundNum

getTeamBullets

getTeamVictoryPoints

getOpponentVictoryPoints

getRobotCount

getTreeCount

getInitialArchonLocations

getID

getTeam

getType

getLocation

getHealth

getAttackCount

getMoveCount

onTheMap

onTheMap

canSenseBulletLocation

canSenseLocation

canSenseRadius

canSensePartOfCircle

canSenseAllOfCircle

isLocationOccupied

isLocationOccupiedByTree

isLocationOccupiedByRobot

isCircleOccupied

isCircleOccupiedExceptByThisRobot

senseTreeAtLocation

senseRobotAtLocation

canSenseTree

canSenseRobot

canSenseBullet

senseTree

senseRobot

senseBullet

senseNearbyRobots

senseNearbyRobots

senseNearbyRobots

senseNearbyRobots

senseNearbyTrees

senseNearbyTrees

senseNearbyTrees

senseNearbyTrees

senseNearbyBullets

senseNearbyBullets

senseNearbyBullets

senseBroadcastingRobotLocations

hasMoved

hasAttacked

isBuildReady

getBuildCooldownTurns

canMove

canMove

canMove

move

move

move

canStrike

strike

canFireSingleShot

canFireTriadShot

canFirePentadShot

fireSingleShot

fireTriadShot

firePentadShot

canChop

canChop

chop

chop

canShake

canShake

shake

shake

canWater

canWater

water

water