Unit (jbwapi 2.1.0 API)

java.lang.Object
- bwapi.Unit

All Implemented Interfaces:

Comparable<Unit>
```
public class Unit
extends Object
implements Comparable<Unit>
```
The Unit class is used to get information about individual units as well as issue orders to units. Each unit in the game has a unique Unit object, and Unit objects are not deleted until the end of the match (so you don't need to worry about unit pointers becoming invalid).
Every Unit in the game is either accessible or inaccessible. To determine if an AI can access a particular unit, BWAPI checks to see if Flag.CompleteMapInformation is enabled. So there are two cases to consider - either the flag is enabled, or it is disabled:
If Flag.CompleteMapInformation is disabled, then a unit is accessible if and only if it is visible.
Some properties of visible enemy units will not be made available to the AI (such as the contents of visible enemy dropships). If a unit is not visible, exists() will return false, regardless of whether or not the unit exists. This is because absolutely no state information on invisible enemy units is made available to the AI. To determine if an enemy unit has been destroyed, the AI must watch for BWEventListener.onUnitDestroy(bwapi.Unit) messages from BWAPI, which is only called for visible units which get destroyed.
If Flag.CompleteMapInformation is enabled, then all units that exist in the game are accessible, and exists() is accurate for all units. Similarly BWEventListener.onUnitDestroy(bwapi.Unit) messages are generated for all units that get destroyed, not just visible ones.
If a Unit is not accessible, then only the getInitial__ functions will be available to the AI. However for units that were owned by the player, getPlayer() and getType() will continue to work for units that have been destroyed.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`attack(Position target)`
`boolean`	`attack(Position target, boolean shiftQueueCommand)` Orders the unit(s) to attack move to the specified position.
`boolean`	`attack(Unit target)`
`boolean`	`attack(Unit target, boolean shiftQueueCommand)`
`boolean`	`build(UnitType type)`
`boolean`	`build(UnitType type, TilePosition target)` Orders the worker unit(s) to construct a structure at a target position.
`boolean`	`buildAddon(UnitType type)` Orders the @Terran structure(s) to construct an add-on.
`boolean`	`burrow()` Orders the unit to burrow.
`boolean`	`canAttack()`
`boolean`	`canAttack(boolean checkCommandibility)`
`boolean`	`canAttack(Position target)`
`boolean`	`canAttack(Position target, boolean checkCanTargetUnit)`
`boolean`	`canAttack(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canAttack(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an attack command to attack-move or attack a unit.
`boolean`	`canAttack(Unit target)`
`boolean`	`canAttack(Unit target, boolean checkCanTargetUnit)`
`boolean`	`canAttack(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canAttack(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canAttackGrouped()`
`boolean`	`canAttackGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canAttackGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)`
`boolean`	`canAttackGrouped(Position target)`
`boolean`	`canAttackGrouped(Position target, boolean checkCanTargetUnit)`
`boolean`	`canAttackGrouped(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canAttackGrouped(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canAttackGrouped(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an attack command to attack-move or attack a unit, as part of a List.
`boolean`	`canAttackGrouped(Unit target)`
`boolean`	`canAttackGrouped(Unit target, boolean checkCanTargetUnit)`
`boolean`	`canAttackGrouped(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canAttackGrouped(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canAttackGrouped(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped, boolean checkCommandibility)`
`boolean`	`canAttackMove()`
`boolean`	`canAttackMove(boolean checkCommandibility)` Checks whether the unit is able to execute an attack command to attack-move.
`boolean`	`canAttackMoveGrouped()`
`boolean`	`canAttackMoveGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canAttackMoveGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)` Checks whether the unit is able to execute an attack command to attack-move, as part of a List.
`boolean`	`canAttackUnit()`
`boolean`	`canAttackUnit(boolean checkCommandibility)`
`boolean`	`canAttackUnit(Unit targetUnit)`
`boolean`	`canAttackUnit(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canAttackUnit(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canAttackUnit(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an attack command to attack a unit.
`boolean`	`canAttackUnitGrouped()`
`boolean`	`canAttackUnitGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canAttackUnitGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)`
`boolean`	`canAttackUnitGrouped(Unit targetUnit)`
`boolean`	`canAttackUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canAttackUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canAttackUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canAttackUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandTypeGrouped, boolean checkCommandibilityGrouped, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an attack command to attack a unit, as part of a List.
`boolean`	`canBuild()`
`boolean`	`canBuild(boolean checkCommandibility)`
`boolean`	`canBuild(UnitType uType)`
`boolean`	`canBuild(UnitType uType, boolean checkCanIssueCommandType)`
`boolean`	`canBuild(UnitType uType, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canBuild(UnitType uType, TilePosition tilePos)`
`boolean`	`canBuild(UnitType uType, TilePosition tilePos, boolean checkTargetUnitType)`
`boolean`	`canBuild(UnitType uType, TilePosition tilePos, boolean checkTargetUnitType, boolean checkCanIssueCommandType)`
`boolean`	`canBuild(UnitType uType, TilePosition tilePos, boolean checkTargetUnitType, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a build command.
`boolean`	`canBuildAddon()`
`boolean`	`canBuildAddon(boolean checkCommandibility)`
`boolean`	`canBuildAddon(UnitType uType)`
`boolean`	`canBuildAddon(UnitType uType, boolean checkCanIssueCommandType)`
`boolean`	`canBuildAddon(UnitType uType, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a buildAddon command.
`boolean`	`canBurrow()`
`boolean`	`canBurrow(boolean checkCommandibility)` Checks whether the unit is able to execute a burrow command.
`boolean`	`canCancelAddon()`
`boolean`	`canCancelAddon(boolean checkCommandibility)` Checks whether the unit is able to execute a cancelAddon command.
`boolean`	`canCancelConstruction()`
`boolean`	`canCancelConstruction(boolean checkCommandibility)` Checks whether the unit is able to execute a cancelConstruction command.
`boolean`	`canCancelMorph()`
`boolean`	`canCancelMorph(boolean checkCommandibility)` Checks whether the unit is able to execute a cancelMorph command.
`boolean`	`canCancelResearch()`
`boolean`	`canCancelResearch(boolean checkCommandibility)` Checks whether the unit is able to execute a cancelResearch command.
`boolean`	`canCancelTrain()`
`boolean`	`canCancelTrain(boolean checkCommandibility)` Checks whether the unit is able to execute a cancelTrain command for any slot.
`boolean`	`canCancelTrainSlot()`
`boolean`	`canCancelTrainSlot(boolean checkCommandibility)`
`boolean`	`canCancelTrainSlot(int slot)`
`boolean`	`canCancelTrainSlot(int slot, boolean checkCanIssueCommandType)`
`boolean`	`canCancelTrainSlot(int slot, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a cancelTrain command for an unspecified slot.
`boolean`	`canCancelUpgrade()`
`boolean`	`canCancelUpgrade(boolean checkCommandibility)` Checks whether the unit is able to execute a cancelUpgrade command.
`boolean`	`cancelAddon()` Orders this unit to cancel and refund an add-on that is being constructed.
`boolean`	`cancelConstruction()` Orders this unit to cancel and refund itself from begin constructed.
`boolean`	`cancelMorph()` Orders this unit to cancel and refund a unit that is morphing.
`boolean`	`cancelResearch()` Orders this unit to cancel and refund a research that is in progress.
`boolean`	`cancelTrain()`
`boolean`	`cancelTrain(int slot)` Orders the unit to remove the specified unit from its training queue.
`boolean`	`cancelUpgrade()` Orders this unit to cancel and refund an upgrade that is in progress.
`boolean`	`canCloak()`
`boolean`	`canCloak(boolean checkCommandibility)` Checks whether the unit is able to execute a cloak command.
`boolean`	`canCommand()` Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute any commands (eg the unit is stasised).
`boolean`	`canCommandGrouped()`
`boolean`	`canCommandGrouped(boolean checkCommandibility)` Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute any commands as part of a List (eg buildings, critters).
`boolean`	`canDecloak()`
`boolean`	`canDecloak(boolean checkCommandibility)` Checks whether the unit is able to execute a decloak command.
`boolean`	`canFollow()`
`boolean`	`canFollow(boolean checkCommandibility)`
`boolean`	`canFollow(Unit targetUnit)`
`boolean`	`canFollow(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canFollow(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canFollow(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a follow command.
`boolean`	`canGather()`
`boolean`	`canGather(boolean checkCommandibility)`
`boolean`	`canGather(Unit targetUnit)`
`boolean`	`canGather(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canGather(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canGather(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a gather command.
`boolean`	`canHaltConstruction()`
`boolean`	`canHaltConstruction(boolean checkCommandibility)` Checks whether the unit is able to execute a haltConstruction command.
`boolean`	`canHoldPosition()`
`boolean`	`canHoldPosition(boolean checkCommandibility)` Checks whether the unit is able to execute a holdPosition command.
`boolean`	`canIssueCommand(UnitCommand command)`
`boolean`	`canIssueCommand(UnitCommand command, boolean checkCanUseTechPositionOnPositions)`
`boolean`	`canIssueCommand(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits)`
`boolean`	`canIssueCommand(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanBuildUnitType)`
`boolean`	`canIssueCommand(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanBuildUnitType, boolean checkCanTargetUnit)`
`boolean`	`canIssueCommand(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanBuildUnitType, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canIssueCommand(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanBuildUnitType, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Checks whether the unit is able to execute the given command.
`boolean`	`canIssueCommandGrouped(UnitCommand command)`
`boolean`	`canIssueCommandGrouped(UnitCommand command, boolean checkCanUseTechPositionOnPositions)`
`boolean`	`canIssueCommandGrouped(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits)`
`boolean`	`canIssueCommandGrouped(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanTargetUnit)`
`boolean`	`canIssueCommandGrouped(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canIssueCommandGrouped(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canIssueCommandGrouped(UnitCommand command, boolean checkCanUseTechPositionOnPositions, boolean checkCanUseTechUnitOnUnits, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped, boolean checkCommandibility)` Checks whether the unit is able to execute the given command as part of a List (even if none of the units in the List are able to execute the command individually).
`boolean`	`canIssueCommandType(UnitCommandType ct)`
`boolean`	`canIssueCommandType(UnitCommandType ct, boolean checkCommandibility)` Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute the given command type (i.e.
`boolean`	`canIssueCommandTypeGrouped(UnitCommandType ct)`
`boolean`	`canIssueCommandTypeGrouped(UnitCommandType ct, boolean checkCommandibilityGrouped)`
`boolean`	`canIssueCommandTypeGrouped(UnitCommandType ct, boolean checkCommandibilityGrouped, boolean checkCommandibility)` Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute the given command type (i.e.
`boolean`	`canLand()`
`boolean`	`canLand(boolean checkCommandibility)`
`boolean`	`canLand(TilePosition target)`
`boolean`	`canLand(TilePosition target, boolean checkCanIssueCommandType)`
`boolean`	`canLand(TilePosition target, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a land command.
`boolean`	`canLift()`
`boolean`	`canLift(boolean checkCommandibility)` Checks whether the unit is able to execute a lift command.
`boolean`	`canLoad()`
`boolean`	`canLoad(boolean checkCommandibility)`
`boolean`	`canLoad(Unit targetUnit)`
`boolean`	`canLoad(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canLoad(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canLoad(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a load command.
`boolean`	`canMorph()`
`boolean`	`canMorph(boolean checkCommandibility)`
`boolean`	`canMorph(UnitType uType)`
`boolean`	`canMorph(UnitType uType, boolean checkCanIssueCommandType)`
`boolean`	`canMorph(UnitType uType, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a morph command.
`boolean`	`canMove()`
`boolean`	`canMove(boolean checkCommandibility)` Checks whether the unit is able to execute a move command.
`boolean`	`canMoveGrouped()`
`boolean`	`canMoveGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canMoveGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)` Checks whether the unit is able to execute a move command, as part of a List.
`boolean`	`canPatrol()`
`boolean`	`canPatrol(boolean checkCommandibility)` Checks whether the unit is able to execute a patrol command.
`boolean`	`canPatrolGrouped()`
`boolean`	`canPatrolGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canPatrolGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)` Checks whether the unit is able to execute a patrol command, as part of a List.
`boolean`	`canPlaceCOP()`
`boolean`	`canPlaceCOP(boolean checkCommandibility)`
`boolean`	`canPlaceCOP(TilePosition target)`
`boolean`	`canPlaceCOP(TilePosition target, boolean checkCanIssueCommandType)`
`boolean`	`canPlaceCOP(TilePosition target, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a placeCOP command.
`boolean`	`canRepair()`
`boolean`	`canRepair(boolean checkCommandibility)`
`boolean`	`canRepair(Unit targetUnit)`
`boolean`	`canRepair(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canRepair(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRepair(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a repair command.
`boolean`	`canResearch()`
`boolean`	`canResearch(boolean checkCommandibility)`
`boolean`	`canResearch(TechType type)`
`boolean`	`canResearch(TechType type, boolean checkCanIssueCommandType)` Cheap checks for whether the unit is able to execute a research command.
`boolean`	`canReturnCargo()`
`boolean`	`canReturnCargo(boolean checkCommandibility)` Checks whether the unit is able to execute a returnCargo command.
`boolean`	`canRightClick()`
`boolean`	`canRightClick(boolean checkCommandibility)`
`boolean`	`canRightClick(Position target)`
`boolean`	`canRightClick(Position target, boolean checkCanTargetUnit)`
`boolean`	`canRightClick(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRightClick(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a rightClick command to a position or unit.
`boolean`	`canRightClick(Unit target)`
`boolean`	`canRightClick(Unit target, boolean checkCanTargetUnit)`
`boolean`	`canRightClick(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRightClick(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canRightClickGrouped()`
`boolean`	`canRightClickGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canRightClickGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)`
`boolean`	`canRightClickGrouped(Position target)`
`boolean`	`canRightClickGrouped(Position target, boolean checkCanTargetUnit)`
`boolean`	`canRightClickGrouped(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRightClickGrouped(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canRightClickGrouped(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a rightClick command to a position or unit, as part of a List.
`boolean`	`canRightClickGrouped(Unit target)`
`boolean`	`canRightClickGrouped(Unit target, boolean checkCanTargetUnit)`
`boolean`	`canRightClickGrouped(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRightClickGrouped(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canRightClickGrouped(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandTypeGrouped, boolean checkCommandibilityGrouped, boolean checkCommandibility)`
`boolean`	`canRightClickPosition()`
`boolean`	`canRightClickPosition(boolean checkCommandibility)` Checks whether the unit is able to execute a rightClick command for a position.
`boolean`	`canRightClickPositionGrouped()`
`boolean`	`canRightClickPositionGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canRightClickPositionGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)` Checks whether the unit is able to execute a rightClick command for a position, as part of a List.
`boolean`	`canRightClickUnit()`
`boolean`	`canRightClickUnit(boolean checkCommandibility)`
`boolean`	`canRightClickUnit(Unit targetUnit)`
`boolean`	`canRightClickUnit(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canRightClickUnit(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRightClickUnit(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a rightClick command to a unit.
`boolean`	`canRightClickUnitGrouped()`
`boolean`	`canRightClickUnitGrouped(boolean checkCommandibilityGrouped)`
`boolean`	`canRightClickUnitGrouped(boolean checkCommandibilityGrouped, boolean checkCommandibility)`
`boolean`	`canRightClickUnitGrouped(Unit targetUnit)`
`boolean`	`canRightClickUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canRightClickUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canRightClickUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped)`
`boolean`	`canRightClickUnitGrouped(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibilityGrouped, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a rightClick command to a unit, as part of a List.
`boolean`	`canSetRallyPoint()`
`boolean`	`canSetRallyPoint(boolean checkCommandibility)`
`boolean`	`canSetRallyPoint(Position target)`
`boolean`	`canSetRallyPoint(Position target, boolean checkCanTargetUnit)`
`boolean`	`canSetRallyPoint(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canSetRallyPoint(Position target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a setRallyPoint command to a position or unit.
`boolean`	`canSetRallyPoint(Unit target)`
`boolean`	`canSetRallyPoint(Unit target, boolean checkCanTargetUnit)`
`boolean`	`canSetRallyPoint(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canSetRallyPoint(Unit target, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canSetRallyPosition()`
`boolean`	`canSetRallyPosition(boolean checkCommandibility)` Checks whether the unit is able to execute a setRallyPoint command to a position.
`boolean`	`canSetRallyUnit()`
`boolean`	`canSetRallyUnit(boolean checkCommandibility)`
`boolean`	`canSetRallyUnit(Unit targetUnit)`
`boolean`	`canSetRallyUnit(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canSetRallyUnit(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType)`
`boolean`	`canSetRallyUnit(Unit targetUnit, boolean checkCanTargetUnit, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a setRallyPoint command to a unit.
`boolean`	`canSiege()`
`boolean`	`canSiege(boolean checkCommandibility)` Checks whether the unit is able to execute a siege command.
`boolean`	`canStop()`
`boolean`	`canStop(boolean checkCommandibility)` Checks whether the unit is able to execute a stop command.
`boolean`	`canTargetUnit(Unit targetUnit)`
`boolean`	`canTargetUnit(Unit targetUnit, boolean checkCommandibility)` Performs some cheap checks to attempt to quickly detect whether the unit is unable to use the given unit as the target unit of an unspecified command.
`boolean`	`canTrain()`
`boolean`	`canTrain(boolean checkCommandibility)`
`boolean`	`canTrain(UnitType uType)`
`boolean`	`canTrain(UnitType uType, boolean checkCanIssueCommandType)`
`boolean`	`canTrain(UnitType uType, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a train command.
`boolean`	`canUnburrow()`
`boolean`	`canUnburrow(boolean checkCommandibility)` Checks whether the unit is able to execute an unburrow command.
`boolean`	`canUnload()`
`boolean`	`canUnload(boolean checkCommandibility)`
`boolean`	`canUnload(Unit targetUnit)`
`boolean`	`canUnload(Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canUnload(Unit targetUnit, boolean checkCanTargetUnit, boolean checkPosition)`
`boolean`	`canUnload(Unit targetUnit, boolean checkCanTargetUnit, boolean checkPosition, boolean checkCanIssueCommandType)`
`boolean`	`canUnload(Unit targetUnit, boolean checkCanTargetUnit, boolean checkPosition, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an unload command.
`boolean`	`canUnloadAll()`
`boolean`	`canUnloadAll(boolean checkCommandibility)` Checks whether the unit is able to execute an unloadAll command for the current position.
`boolean`	`canUnloadAllPosition()`
`boolean`	`canUnloadAllPosition(boolean checkCommandibility)`
`boolean`	`canUnloadAllPosition(Position targDropPos)`
`boolean`	`canUnloadAllPosition(Position targDropPos, boolean checkCanIssueCommandType)`
`boolean`	`canUnloadAllPosition(Position targDropPos, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an unloadAll command for a different position.
`boolean`	`canUnloadAtPosition(Position targDropPos)`
`boolean`	`canUnloadAtPosition(Position targDropPos, boolean checkCanIssueCommandType)`
`boolean`	`canUnloadAtPosition(Position targDropPos, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an unload command or unloadAll at current position command or unloadAll at a different position command, for a given position.
`boolean`	`canUnloadWithOrWithoutTarget()`
`boolean`	`canUnloadWithOrWithoutTarget(boolean checkCommandibility)` Cheap checks for whether the unit is able to execute an unload command or unloadAll at current position command or unloadAll at a different position command.
`boolean`	`canUnsiege()`
`boolean`	`canUnsiege(boolean checkCommandibility)` Checks whether the unit is able to execute an unsiege command.
`boolean`	`canUpgrade()`
`boolean`	`canUpgrade(boolean checkCommandibility)`
`boolean`	`canUpgrade(UpgradeType type)`
`boolean`	`canUpgrade(UpgradeType type, boolean checkCanIssueCommandType)` Cheap checks for whether the unit is able to execute an upgrade command.
`boolean`	`canUseTech(TechType tech)`
`boolean`	`canUseTech(TechType tech, Position target)`
`boolean`	`canUseTech(TechType tech, Position target, boolean checkCanTargetUnit)`
`boolean`	`canUseTech(TechType tech, Position target, boolean checkCanTargetUnit, boolean checkTargetsType)`
`boolean`	`canUseTech(TechType tech, Position target, boolean checkCanTargetUnit, boolean checkTargetsType, boolean checkCanIssueCommandType)`
`boolean`	`canUseTech(TechType tech, Position target, boolean checkCanTargetUnit, boolean checkTargetsType, boolean checkCanIssueCommandType, boolean checkCommandibility)` Checks whether the unit is able to execute a useTech command for a specified position or unit (only specify null if the TechType does not target another position/unit).
`boolean`	`canUseTech(TechType tech, Unit target)`
`boolean`	`canUseTech(TechType tech, Unit target, boolean checkCanTargetUnit)`
`boolean`	`canUseTech(TechType tech, Unit target, boolean checkCanTargetUnit, boolean checkTargetsType)`
`boolean`	`canUseTech(TechType tech, Unit target, boolean checkCanTargetUnit, boolean checkTargetsType, boolean checkCanIssueCommandType)`
`boolean`	`canUseTech(TechType tech, Unit target, boolean checkCanTargetUnit, boolean checkTargetsType, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canUseTechPosition(TechType tech)`
`boolean`	`canUseTechPosition(TechType tech, boolean checkCanIssueCommandType)`
`boolean`	`canUseTechPosition(TechType tech, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canUseTechPosition(TechType tech, Position target)`
`boolean`	`canUseTechPosition(TechType tech, Position target, boolean checkTargetsPositions)`
`boolean`	`canUseTechPosition(TechType tech, Position target, boolean checkTargetsPositions, boolean checkCanIssueCommandType)`
`boolean`	`canUseTechPosition(TechType tech, Position target, boolean checkTargetsPositions, boolean checkCanIssueCommandType, boolean checkCommandibility)` Checks whether the unit is able to execute a useTech command with an unspecified target position.
`boolean`	`canUseTechUnit(TechType tech)`
`boolean`	`canUseTechUnit(TechType tech, boolean checkCanIssueCommandType)`
`boolean`	`canUseTechUnit(TechType tech, boolean checkCanIssueCommandType, boolean checkCommandibility)`
`boolean`	`canUseTechUnit(TechType tech, Unit targetUnit)`
`boolean`	`canUseTechUnit(TechType tech, Unit targetUnit, boolean checkCanTargetUnit)`
`boolean`	`canUseTechUnit(TechType tech, Unit targetUnit, boolean checkCanTargetUnit, boolean checkTargetsUnits)`
`boolean`	`canUseTechUnit(TechType tech, Unit targetUnit, boolean checkCanTargetUnit, boolean checkTargetsUnits, boolean checkCanIssueCommandType)`
`boolean`	`canUseTechUnit(TechType tech, Unit targetUnit, boolean checkCanTargetUnit, boolean checkTargetsUnits, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a useTech command with an unspecified target unit.
`boolean`	`canUseTechWithOrWithoutTarget()`
`boolean`	`canUseTechWithOrWithoutTarget(boolean checkCommandibility)`
`boolean`	`canUseTechWithOrWithoutTarget(TechType tech)`
`boolean`	`canUseTechWithOrWithoutTarget(TechType tech, boolean checkCanIssueCommandType)`
`boolean`	`canUseTechWithOrWithoutTarget(TechType tech, boolean checkCanIssueCommandType, boolean checkCommandibility)` Cheap checks for whether the unit is able to execute a useTech command without a target or or a useTech command with a target position or a useTech command with a target unit.
`boolean`	`canUseTechWithoutTarget(TechType tech)`
`boolean`	`canUseTechWithoutTarget(TechType tech, boolean checkCanIssueCommandType)`
`boolean`	`canUseTechWithoutTarget(TechType tech, boolean checkCanIssueCommandType, boolean checkCommandibility)` Checks whether the unit is able to execute a useTech command without a target.
`boolean`	`cloak()` Orders the unit to cloak.
`int`	`compareTo(Unit other)`
`boolean`	`decloak()` Orders a cloaked unit to decloak.
`boolean`	`equals(Object o)`
`boolean`	`exists()` Checks if the Unit exists in the view of the BWAPI player.
`boolean`	`follow(Unit target)`
`boolean`	`follow(Unit target, boolean shiftQueueCommand)` Orders the unit to follow the specified unit.
`boolean`	`gather(Unit target)`
`boolean`	`gather(Unit target, boolean shiftQueueCommand)` Orders the unit to gather the specified unit (must be mineral or refinery type).
`int`	`getAcidSporeCount()` Retrieves the number of acid spores that this unit is inflicted with.
`Unit`	`getAddon()` Retrieves the add-on that is attached to this unit.
`int`	`getAirWeaponCooldown()` Retrieves the unit's air weapon cooldown.
`double`	`getAngle()` Retrieves the unit's facing direction in radians.
`int`	`getBottom()` Retrieves the Y coordinate of the unit's bottom boundary, measured in pixels from the top of the map.
`UnitType`	`getBuildType()` Retrieves the building type that a @worker is about to construct.
`Unit`	`getBuildUnit()` Retrieves the unit currently being trained, or the corresponding paired unit for @SCVs and @Terran structures, depending on the context.
`Unit`	`getCarrier()` Retrieves the parent @Carrier that owns this @Interceptor.
`int`	`getDefenseMatrixPoints()` Retrieves the amount of hit points remaining on the @matrix created by a @Science_Vessel.
`int`	`getDefenseMatrixTimer()` Retrieves the time, in frames, that the @matrix will remain active on the current unit.
`int`	`getDistance(Position target)` Retrieves the distance between this unit and a target position.
`int`	`getDistance(Unit target)`
`int`	`getEnergy()` Retrieves the unit's current Energy Points (Energy) as seen in the game.
`int`	`getEnsnareTimer()` Retrieves the time, in frames, that @ensnare will remain active on the current unit.
`int`	`getGroundWeaponCooldown()` Retrieves the unit's ground weapon cooldown.
`Unit`	`getHatchery()` Retrieves the parent @Hatchery, @Lair, or @Hive that owns this particular unit.
`int`	`getHitPoints()` Retrieves the unit's current Hit Points (HP) as seen in the game.
`int`	`getID()` Retrieves a unique identifier for this unit.
`int`	`getInitialHitPoints()` Retrieves the amount of hit points that this unit started off with at the beginning of the game.
`Position`	`getInitialPosition()` Retrieves the initial position of this unit.
`int`	`getInitialResources()` Retrieves the amount of resources contained in the unit at the beginning of the game.
`TilePosition`	`getInitialTilePosition()` Retrieves the initial build tile position of this unit.
`UnitType`	`getInitialType()` Retrieves the initial type of the unit.
`int`	`getInterceptorCount()` Retrieves the number of interceptors that this unit manages.
`List<Unit>`	`getInterceptors()` Retrieves the set of @Interceptors controlled by this unit.
`int`	`getIrradiateTimer()` Retrieves the time, in frames, that @irradiate will remain active on the current unit.
`int`	`getKillCount()` Retrieves the number of units that this unit has killed in total.
`List<Unit>`	`getLarva()` Retrieves the set of @Larvae that were spawned by this unit.
`Player`	`getLastAttackingPlayer()` Retrieves the `Player` that last attacked this unit.
`UnitCommand`	`getLastCommand()` Retrieves the last successful command that was sent to BWAPI.
`int`	`getLastCommandFrame()` Retrieves the frame number that sent the last successful command.
`int`	`getLeft()` Retrieves the X coordinate of the unit's left boundary, measured in pixels from the left side of the map.
`List<Unit>`	`getLoadedUnits()` Retrieves the set of units that are contained within this @Bunker or @Transport.
`int`	`getLockdownTimer()` Retrieves the time, in frames, that @lockdown will remain active on the current unit.
`int`	`getMaelstromTimer()` Retrieves the time, in frames, that @maelstrom will remain active on the current unit.
`Unit`	`getNydusExit()` Retrieves the @Nydus_Canal that is attached to this one.
`Order`	`getOrder()` Retrieves the primary Order that the unit is assigned.
`Unit`	`getOrderTarget()` Retrieves the unit's primary order target.
`Position`	`getOrderTargetPosition()` Retrieves the target position for the unit's order.
`int`	`getOrderTimer()` Retrieves an internal timer used for the primary order.
`int`	`getPlagueTimer()` Retrieves the time, in frames, that @plague will remain active on the current unit.
`Player`	`getPlayer()` Retrieves the player that owns this unit.
`Position`	`getPosition()` Retrieves the unit's position from the upper left corner of the map in pixels.
`Unit`	`getPowerUp()` Retrieves the power-up that the worker unit is holding.
`Position`	`getRallyPosition()` Retrieves the position the structure is rallying units to once they are completed.
`Unit`	`getRallyUnit()` Retrieves the unit the structure is rallying units to once they are completed.
`Region`	`getRegion()` Retrieves the `Region` that the center of the unit is in.
`int`	`getRemainingBuildTime()` Retrieves the remaining build time for a unit or structure that is being trained or constructed.
`int`	`getRemainingResearchTime()` Retrieves the amount of time until the unit is done researching its currently assigned `TechType`.
`int`	`getRemainingTrainTime()` Retrieves the remaining time, in frames, of the unit that is currently being trained.
`int`	`getRemainingUpgradeTime()` Retrieves the amount of time until the unit is done upgrading its current upgrade.
`int`	`getRemoveTimer()` Retrieves the time, in frames, until this temporary unit is destroyed or removed.
`int`	`getReplayID()` Retrieves the unit identifier for this unit as seen in replay data.
`int`	`getResourceGroup()` Retrieves a grouping index from a resource container.
`int`	`getResources()` Retrieves the resource amount from a resource container, such as a Mineral Field and Vespene Geyser.
`int`	`getRight()` Retrieves the X coordinate of the unit's right boundary, measured in pixels from the left side of the map.
`int`	`getScarabCount()` Retrieves the number of scarabs that this unit has for use.
`Order`	`getSecondaryOrder()` Retrieves the secondary Order that the unit is assigned.
`int`	`getShields()` Retrieves the unit's current Shield Points (Shields) as seen in the game.
`int`	`getSpaceRemaining()` Retrieves the remaining unit-space available for @Bunkers and @Transports.
`int`	`getSpellCooldown()` Retrieves the unit's ability cooldown.
`int`	`getSpiderMineCount()` Retrieves the amount of @mines this unit has available.
`int`	`getStasisTimer()` Retrieves the time, in frames, that @stasis will remain active on the current unit.
`int`	`getStimTimer()` Retrieves the time, in frames, that @stim will remain active on the current unit.
`Unit`	`getTarget()` Generally returns the appropriate target unit after issuing an order that accepts a target unit (i.e.
`Position`	`getTargetPosition()` Retrieves the target position the unit is moving to, provided a valid path to the target position exists.
`TechType`	`getTech()` Retrieves the technology that this unit is currently researching.
`TilePosition`	`getTilePosition()` Retrieves the unit's build position from the upper left corner of the map in tiles.
`int`	`getTop()` Retrieves the Y coordinate of the unit's top boundary, measured in pixels from the top of the map.
`List<UnitType>`	`getTrainingQueue()` Retrieves the list of unit types queued up to be trained.
`UnitType`	`getTrainingQueueAt(int i)` Retrieves a unit type from a specific index in the queue of units this unit is training.
`int`	`getTrainingQueueCount()` Retrieves the number of units in this unit's training queue.
`Unit`	`getTransport()` Retrieves the @Transport or @Bunker unit that has this unit loaded inside of it.
`UnitType`	`getType()` Retrieves the unit's type.
`List<Unit>`	`getUnitsInRadius(int radius)`
`List<Unit>`	`getUnitsInRadius(int radius, UnitFilter pred)` Retrieves the set of all units in a given radius of the current unit.
`List<Unit>`	`getUnitsInWeaponRange(WeaponType weapon)`
`List<Unit>`	`getUnitsInWeaponRange(WeaponType weapon, UnitFilter pred)` Obtains the set of units within weapon range of this unit.
`UpgradeType`	`getUpgrade()` Retrieves the upgrade that this unit is currently upgrading.
`double`	`getVelocityX()` Retrieves the x component of the unit's velocity, measured in pixels per frame.
`double`	`getVelocityY()` Retrieves the y component of the unit's velocity, measured in pixels per frame.
`int`	`getX()`
`int`	`getY()`
`boolean`	`haltConstruction()` Orders a @SCV to stop constructing a structure.
`int`	`hashCode()`
`boolean`	`hasNuke()` Checks if the current unit is housing a @Nuke.
`boolean`	`hasPath(Position target)` Using data provided by Starcraft, checks if there is a path available from this unit to the given target.
`boolean`	`hasPath(Unit target)`
`boolean`	`holdPosition()`
`boolean`	`holdPosition(boolean shiftQueueCommand)` Orders the unit to hold its position.
`boolean`	`isAccelerating()` Checks if the current unit is accelerating.
`boolean`	`isAttackFrame()` Checks if this unit is currently playing an attack animation.
`boolean`	`isAttacking()` Checks if this unit is currently attacking something.
`boolean`	`isBeingConstructed()` Checks if the current unit is being constructed.
`boolean`	`isBeingGathered()` Checks this @Mineral_Field or @Refinery is currently being gathered from.
`boolean`	`isBeingHealed()` Checks if this unit is currently being healed by a @Medic or repaired by a @SCV.
`boolean`	`isBlind()` Checks if this unit is currently blinded by a @Medic 's @Optical_Flare ability.
`boolean`	`isBraking()` Checks if the current unit is slowing down to come to a stop.
`boolean`	`isBurrowed()` Checks if the current unit is burrowed, either using the @Burrow ability, or is an armed @Spider_Mine.
`boolean`	`isCarrying()`
`boolean`	`isCarryingGas()` Checks if this worker unit is carrying some vespene gas.
`boolean`	`isCarryingMinerals()` Checks if this worker unit is carrying some minerals.
`boolean`	`isCloaked()` Checks if this unit is currently @cloaked.
`boolean`	`isCompleted()` Checks if this unit has finished being constructed, trained, morphed, or warped in, and can now receive orders.
`boolean`	`isConstructing()` Checks if a unit is either constructing something or moving to construct something.
`boolean`	`isDefenseMatrixed()` Checks if this unit has the @matrix effect.
`boolean`	`isDetected()` Checks if this unit is visible or revealed by a detector unit.
`boolean`	`isEnsnared()` Checks if the @Queen ability @Ensnare has been used on this unit.
`boolean`	`isFlying()` This macro function checks if this unit is in the air.
`boolean`	`isFollowing()` Checks if this unit is following another unit.
`boolean`	`isGatheringGas()` Checks if this unit is currently gathering gas.
`boolean`	`isGatheringMinerals()` Checks if this unit is currently harvesting minerals.
`boolean`	`isHallucination()` Checks if this unit is a hallucination.
`boolean`	`isHoldingPosition()` Checks if the unit is currently holding position.
`boolean`	`isIdle()` Checks if this unit is running an idle order.
`boolean`	`isInterruptible()` Checks if the unit can be interrupted.
`boolean`	`isInvincible()` Checks the invincibility state for this unit.
`boolean`	`isInWeaponRange(Unit target)` Checks if the target unit can immediately be attacked by this unit in the current frame.
`boolean`	`isIrradiated()` Checks if this unit is irradiated by a @Science_Vessel 's @Irradiate ability.
`boolean`	`isLifted()` Checks if this unit is a @Terran building and lifted off the ground.
`boolean`	`isLoaded()` Checks if this unit is currently loaded into another unit such as a @Transport.
`boolean`	`isLockedDown()` Checks if this unit is currently @locked by a @Ghost.
`boolean`	`isMaelstrommed()` Checks if this unit has been @Maelstrommed by a @Dark_Archon.
`boolean`	`isMorphing()` Finds out if the current unit is morphing or not.
`boolean`	`isMoving()` Checks if this unit is currently moving.
`boolean`	`isParasited()` Checks if this unit has been parasited by some other player.
`boolean`	`isPatrolling()` Checks if this unit is patrolling between two positions.
`boolean`	`isPlagued()` Checks if this unit has been been @plagued by a @defiler.
`boolean`	`isPowered()` Checks if this unit has power.
`boolean`	`isRepairing()` Checks if this unit is repairing or moving to @repair another unit.
`boolean`	`isResearching()` Checks if this unit is a structure that is currently researching a technology.
`boolean`	`isSelected()` Checks if this unit has been selected in the user interface.
`boolean`	`isSieged()` Checks if this unit is currently @sieged.
`boolean`	`isStartingAttack()` Checks if the unit is starting to attack.
`boolean`	`isStasised()` Checks if this unit is inflicted with @Stasis by an @Arbiter.
`boolean`	`isStimmed()` Checks if this unit is currently under the influence of a @Stim_Pack.
`boolean`	`isStuck()` Checks if this unit is currently trying to resolve a collision by randomly moving around.
`boolean`	`issueCommand(UnitCommand command)` This function issues a command to the unit(s), however it is used for interfacing only, and is recommended to use one of the more specific command functions when writing an AI.
`boolean`	`isTargetable()` Performs some cheap checks to attempt to quickly detect whether the unit is unable to be targetted as the target unit of an unspecified command.
`boolean`	`isTraining()` Checks if this unit is training a new unit.
`boolean`	`isUnderAttack()` Checks if the current unit is being attacked.
`boolean`	`isUnderDarkSwarm()` Checks if this unit is under the cover of a @Dark_Swarm.
`boolean`	`isUnderDisruptionWeb()` Checks if this unit is currently being affected by a @Disruption_Web.
`boolean`	`isUnderStorm()` Checks if this unit is currently taking damage from a @Psi_Storm.
`boolean`	`isUpgrading()` Checks if this unit is a structure that is currently upgrading an upgrade.
`boolean`	`isVisible()`
`boolean`	`isVisible(Player player)` Checks if this unit is visible.
`boolean`	`land(TilePosition target)` Orders the unit to land.
`boolean`	`lift()` Orders the unit to lift.
`boolean`	`load(Unit target)`
`boolean`	`load(Unit target, boolean shiftQueueCommand)` Orders the unit to load the target unit.
`boolean`	`morph(UnitType type)` Orders the unit(s) to morph into a different `UnitType`.
`boolean`	`move(Position target)`
`boolean`	`move(Position target, boolean shiftQueueCommand)` Orders the unit to move from its current position to the specified position.
`boolean`	`patrol(Position target)`
`boolean`	`patrol(Position target, boolean shiftQueueCommand)` Orders the unit to patrol between its current position and the specified position.
`boolean`	`placeCOP(TilePosition target)` Moves a @Flag_Beacon to a different location.
`boolean`	`repair(Unit target)`
`boolean`	`repair(Unit target, boolean shiftQueueCommand)` Orders the unit to repair the specified unit.
`boolean`	`research(TechType tech)` Orders the unit to research the given tech type.
`boolean`	`returnCargo()`
`boolean`	`returnCargo(boolean shiftQueueCommand)` Orders the unit to return its cargo to a nearby resource depot such as a Command Center.
`boolean`	`rightClick(Position target)`
`boolean`	`rightClick(Position target, boolean shiftQueueCommand)` Performs a right click action as it would work in StarCraft.
`boolean`	`rightClick(Unit target)`
`boolean`	`rightClick(Unit target, boolean shiftQueueCommand)`
`boolean`	`setRallyPoint(Position target)` Orders the unit to set its rally position.
`boolean`	`setRallyPoint(Unit target)`
`boolean`	`siege()` Orders the unit to siege.
`boolean`	`stop()`
`boolean`	`stop(boolean shiftQueueCommand)` Orders the unit to stop.
`boolean`	`train(UnitType type)` Orders the unit(s) to add a UnitType to its training queue, or morphs into the `UnitType` if it is @Zerg.
`boolean`	`unburrow()` Orders a burrowed unit to unburrow.
`boolean`	`unload(Unit target)` Orders the unit to unload the target unit.
`boolean`	`unloadAll()`
`boolean`	`unloadAll(boolean shiftQueueCommand)`
`boolean`	`unloadAll(Position target)`
`boolean`	`unloadAll(Position target, boolean shiftQueueCommand)` Orders the unit to unload all loaded units at the unit's current position.
`boolean`	`unsiege()` Orders the unit to unsiege.
`boolean`	`upgrade(UpgradeType upgrade)` Orders the unit to upgrade the given upgrade type.
`boolean`	`useTech(TechType tech)`
`boolean`	`useTech(TechType tech, Position target)` Orders the unit to use a technology.
`boolean`	`useTech(TechType tech, Unit target)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getID
```
public int getID()
```
    Retrieves a unique identifier for this unit.
    
    Returns:
    
    An integer containing the unit's identifier.
    
    See Also:
    
    getReplayID()
  - exists
```
public boolean exists()
```
    Checks if the Unit exists in the view of the BWAPI player.
    This is used primarily to check if BWAPI has access to a specific unit, or if the unit is alive. This function is more general and would be synonymous to an isAlive function if such a function were necessary.
    
    Returns:
    
    true If the unit exists on the map and is visible according to BWAPI, false If the unit is not accessible or the unit is dead.
    In the event that this function returns false, there are two cases to consider: 1. You own the unit. This means the unit is dead. 2. Another player owns the unit. This could either mean that you don't have access to the unit or that the unit has died. You can specifically identify dead units by polling onUnitDestroy.
    
    See Also:
    
    isVisible(), isCompleted()
  - getReplayID
```
public int getReplayID()
```
    Retrieves the unit identifier for this unit as seen in replay data.
    This is only available if Flag.CompleteMapInformation is enabled.
    
    Returns:
    
    An integer containing the replay unit identifier.
    
    See Also:
    
    getID()
  - getPlayer
```
public Player getPlayer()
```
    Retrieves the player that owns this unit.
    
    Returns:
    
    The owning Player object. Returns Game.neutral() If the unit is a neutral unit or inaccessible.
  - getType
```
public UnitType getType()
```
    Retrieves the unit's type.
    
    Returns:
    
    A UnitType objects representing the unit's type. Returns UnitType.Unknown if this unit is inaccessible or cannot be determined.
    
    See Also:
    
    getInitialType()
  - getPosition
```
public Position getPosition()
```
    Retrieves the unit's position from the upper left corner of the map in pixels. The position returned is roughly the center if the unit.
    The unit bounds are defined as this value plus/minus the values of UnitType.dimensionLeft(), UnitType.dimensionUp(), UnitType.dimensionRight(), and UnitType.dimensionDown(), which is conveniently expressed in getLeft(), getTop(), getRight(), and getBottom() respectively.
    
    Returns:
    
    Position object representing the unit's current position. Returns Position.Unknown if this unit is inaccessible.
    
    See Also:
    
    getTilePosition(), getInitialPosition(), getLeft(), getTop()
  - getX
```
public int getX()
```
  - getY
```
public int getY()
```
  - getTilePosition
```
public TilePosition getTilePosition()
```
    Retrieves the unit's build position from the upper left corner of the map in tiles.
    This tile position is the tile that is at the top left corner of the structure.
    
    Returns:
    
    TilePosition object representing the unit's current tile position. Returns TilePosition.Unknown if this unit is inaccessible.
    
    See Also:
    
    getPosition(), getInitialTilePosition()
  - getAngle
```
public double getAngle()
```
    Retrieves the unit's facing direction in radians.
    A value of 0.0 means the unit is facing east.
    
    Returns:
    
    A double with the angle measure in radians.
  - getVelocityX
```
public double getVelocityX()
```
    Retrieves the x component of the unit's velocity, measured in pixels per frame.
    
    Returns:
    
    A double that represents the velocity's x component.
    
    See Also:
    
    getVelocityY()
  - getVelocityY
```
public double getVelocityY()
```
    Retrieves the y component of the unit's velocity, measured in pixels per frame.
    
    Returns:
    
    A double that represents the velocity's y component.
    
    See Also:
    
    getVelocityX()
  - getRegion
```
public Region getRegion()
```
    Retrieves the Region that the center of the unit is in.
    
    Returns:
    
    The Region object that contains this unit. Returns null if the unit is inaccessible.
  - getLeft
```
public int getLeft()
```
    Retrieves the X coordinate of the unit's left boundary, measured in pixels from the left side of the map.
    
    Returns:
    
    An integer representing the position of the left side of the unit.
    
    See Also:
    
    getTop(), getRight(), getBottom()
  - getTop
```
public int getTop()
```
    Retrieves the Y coordinate of the unit's top boundary, measured in pixels from the top of the map.
    
    Returns:
    
    An integer representing the position of the top side of the unit.
    
    See Also:
    
    getLeft(), getRight(), getBottom()
  - getRight
```
public int getRight()
```
    Retrieves the X coordinate of the unit's right boundary, measured in pixels from the left side of the map.
    
    Returns:
    
    An integer representing the position of the right side of the unit.
    
    See Also:
    
    getLeft(), getTop(), getBottom()
  - getBottom
```
public int getBottom()
```
    Retrieves the Y coordinate of the unit's bottom boundary, measured in pixels from the top of the map.
    
    Returns:
    
    An integer representing the position of the bottom side of the unit.
    
    See Also:
    
    getLeft(), getTop(), getRight()
  - getHitPoints
```
public int getHitPoints()
```
    Retrieves the unit's current Hit Points (HP) as seen in the game.
    
    Returns:
    
    An integer representing the amount of hit points a unit currently has.
    In Starcraft, a unit usually dies when its HP reaches 0. It is possible however, to have abnormal HP values in the Use Map Settings game type and as the result of a hack over Battle.net. Such values include units that have 0 HP (can't be killed conventionally) or even negative HP (death in one hit).
    
    See Also:
    
    UnitType.maxHitPoints(), getShields(), getInitialHitPoints()
  - getShields
```
public int getShields()
```
    Retrieves the unit's current Shield Points (Shields) as seen in the game.
    
    Returns:
    
    An integer representing the amount of shield points a unit currently has.
    
    See Also:
    
    UnitType.maxShields(), getHitPoints()
  - getEnergy
```
public int getEnergy()
```
    Retrieves the unit's current Energy Points (Energy) as seen in the game.
    
    Returns:
    
    An integer representing the amount of energy points a unit currently has.
    Energy is required in order for units to use abilities.
    
    See Also:
    
    UnitType.maxEnergy()
  - getResources
```
public int getResources()
```
    Retrieves the resource amount from a resource container, such as a Mineral Field and Vespene Geyser. If the unit is inaccessible, then the last known resource amount is returned.
    
    Returns:
    
    An integer representing the last known amount of resources remaining in this resource.
    
    See Also:
    
    getInitialResources()
  - getResourceGroup
```
public int getResourceGroup()
```
    Retrieves a grouping index from a resource container. Other resource containers of the same value are considered part of one expansion location (group of resources that are close together).
    This grouping method is explicitly determined by Starcraft itself and is used only by the internal AI.
    
    Returns:
    
    An integer with an identifier between 0 and 250 that determine which resources are grouped together to form an expansion.
  - getDistance
```
public int getDistance(Position target)
```
    Retrieves the distance between this unit and a target position.
    Distance is calculated from the edge of this unit, using Starcraft's own distance algorithm. Ignores collisions.
    
    Parameters:
    
    target - A Position to calculate the distance to.
    
    Returns:
    
    An integer representation of the number of pixels between this unit and the target.
  - getDistance
```
public int getDistance(Unit target)
```
  - hasPath
```
public boolean hasPath(Position target)
```
    Using data provided by Starcraft, checks if there is a path available from this unit to the given target.
    This function only takes into account the terrain data, and does not include buildings when determining if a path is available. However, the complexity of this function is constant ( O(1) ), and no extensive calculations are necessary.
    If the current unit is an air unit, then this function will always return true.
    If the unit somehow gets stuck in unwalkable terrain, then this function may still return true if one of the unit's corners is on walkable terrain (i.e. if the unit is expected to return to the walkable terrain).
    
    Parameters:
    
    target - A Position or a Unit that is used to determine if this unit has a path to the target.
    
    Returns:
    
    true If there is a path between this unit and the target position, otherwise it will return false.
    
    See Also:
    
    Game.hasPath(bwapi.Position, bwapi.Position)
  - hasPath
```
public boolean hasPath(Unit target)
```
  - getLastCommandFrame
```
public int getLastCommandFrame()
```
    Retrieves the frame number that sent the last successful command.
    This value is comparable to Game.getFrameCount().
    
    Returns:
    
    The frame number that sent the last successfully processed command to BWAPI.
    
    See Also:
    
    Game.getFrameCount(), getLastCommand()
  - getLastCommand
```
public UnitCommand getLastCommand()
```
    Retrieves the last successful command that was sent to BWAPI.
    
    Returns:
    
    A UnitCommand object containing information about the command that was processed.
    
    See Also:
    
    getLastCommandFrame()
  - getLastAttackingPlayer
```
public Player getLastAttackingPlayer()
```
    Retrieves the Player that last attacked this unit.
    
    Returns:
    
    Player object representing the player that last attacked this unit. Returns null if this unit was not attacked.
  - getInitialType
```
public UnitType getInitialType()
```
    Retrieves the initial type of the unit. This is the type that the unit starts as in the beginning of the game. This is used to access the types of static neutral units such as mineral fields when they are not visible.
    
    Returns:
    
    UnitType of this unit as it was when it was created. Returns UnitType.Unknown if this unit was not a static neutral unit in the beginning of the game.
  - getInitialPosition
```
public Position getInitialPosition()
```
    Retrieves the initial position of this unit. This is the position that the unit starts at in the beginning of the game. This is used to access the positions of static neutral units such as mineral fields when they are not visible.
    
    Returns:
    
    Position indicating the unit's initial position when it was created. Returns Position.Unknown if this unit was not a static neutral unit in the beginning of the game.
  - getInitialTilePosition
```
public TilePosition getInitialTilePosition()
```
    Retrieves the initial build tile position of this unit. This is the tile position that the unit starts at in the beginning of the game. This is used to access the tile positions of static neutral units such as mineral fields when they are not visible. The build tile position corresponds to the upper left corner of the unit.
    
    Returns:
    
    TilePosition indicating the unit's initial tile position when it was created. Returns TilePosition.Unknown if this unit was not a static neutral unit in the beginning of the game.
  - getInitialHitPoints
```
public int getInitialHitPoints()
```
    Retrieves the amount of hit points that this unit started off with at the beginning of the game. The unit must be neutral.
    
    Returns:
    
    Number of hit points that this unit started with. Returns 0 if this unit was not a neutral unit at the beginning of the game.
    It is possible for the unit's initial hit points to differ from the maximum hit points.
    
    See Also:
    
    Game.getStaticNeutralUnits()
  - getInitialResources
```
public int getInitialResources()
```
    Retrieves the amount of resources contained in the unit at the beginning of the game. The unit must be a neutral resource container.
    
    Returns:
    
    Amount of resources that this unit started with. Returns 0 if this unit was not a neutral unit at the beginning of the game, or if this unit does not contain resources. It is possible that the unit simply contains 0 resources.
    
    See Also:
    
    Game.getStaticNeutralUnits()
  - getKillCount
```
public int getKillCount()
```
    Retrieves the number of units that this unit has killed in total.
    The maximum amount of recorded kills per unit is 255.
    
    Returns:
    
    integer indicating this unit's kill count.
  - getAcidSporeCount
```
public int getAcidSporeCount()
```
    Retrieves the number of acid spores that this unit is inflicted with.
    
    Returns:
    
    Number of acid spores on this unit.
  - getInterceptorCount
```
public int getInterceptorCount()
```
    Retrieves the number of interceptors that this unit manages. This function is only for the @Carrier and its hero.
    This number may differ from the number of units returned from #getInterceptors. This occurs for cases in which you can see the number of enemy interceptors in the Carrier HUD, but don't actually have access to the individual interceptors.
    
    Returns:
    
    Number of interceptors in this unit.
    
    See Also:
    
    getInterceptors()
  - getScarabCount
```
public int getScarabCount()
```
    Retrieves the number of scarabs that this unit has for use. This function is only for the @Reaver.
    
    Returns:
    
    Number of scarabs this unit has ready.
  - getSpiderMineCount
```
public int getSpiderMineCount()
```
    Retrieves the amount of @mines this unit has available. This function is only for the @Vulture.
    
    Returns:
    
    Number of spider mines available for placement.
  - getGroundWeaponCooldown
```
public int getGroundWeaponCooldown()
```
    Retrieves the unit's ground weapon cooldown. This value decreases every frame, until it reaches 0. When the value is 0, this indicates that the unit is capable of using its ground weapon, otherwise it must wait until it reaches 0.
    This value will vary, because Starcraft adds an additional random value between (-1) and (+2) to the unit's weapon cooldown.
    
    Returns:
    
    Number of frames needed for the unit's ground weapon to become available again.
  - getAirWeaponCooldown
```
public int getAirWeaponCooldown()
```
    Retrieves the unit's air weapon cooldown. This value decreases every frame, until it reaches 0. When the value is 0, this indicates that the unit is capable of using its air weapon, otherwise it must wait until it reaches 0.
    This value will vary, because Starcraft adds an additional random value between (-1) and (+2) to the unit's weapon cooldown.
    
    Returns:
    
    Number of frames needed for the unit's air weapon to become available again.
  - getSpellCooldown
```
public int getSpellCooldown()
```
    Retrieves the unit's ability cooldown. This value decreases every frame, until it reaches 0. When the value is 0, this indicates that the unit is capable of using one of its special abilities, otherwise it must wait until it reaches 0.
    This value will vary, because Starcraft adds an additional random value between (-1) and (+2) to the unit's ability cooldown.
    
    Returns:
    
    Number of frames needed for the unit's abilities to become available again.
  - getDefenseMatrixPoints
```
public int getDefenseMatrixPoints()
```
    Retrieves the amount of hit points remaining on the @matrix created by a @Science_Vessel. The @matrix ability starts with 250 hit points when it is used.
    
    Returns:
    
    Number of hit points remaining on this unit's @matrix.
    
    See Also:
    
    getDefenseMatrixTimer(), isDefenseMatrixed()
  - getDefenseMatrixTimer
```
public int getDefenseMatrixTimer()
```
    Retrieves the time, in frames, that the @matrix will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    getDefenseMatrixPoints(), isDefenseMatrixed()
  - getEnsnareTimer
```
public int getEnsnareTimer()
```
    Retrieves the time, in frames, that @ensnare will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isEnsnared()
  - getIrradiateTimer
```
public int getIrradiateTimer()
```
    Retrieves the time, in frames, that @irradiate will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isIrradiated()
  - getLockdownTimer
```
public int getLockdownTimer()
```
    Retrieves the time, in frames, that @lockdown will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isLockedDown()
  - getMaelstromTimer
```
public int getMaelstromTimer()
```
    Retrieves the time, in frames, that @maelstrom will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isMaelstrommed()
  - getOrderTimer
```
public int getOrderTimer()
```
    Retrieves an internal timer used for the primary order. Its use is specific to the order type that is currently assigned to the unit.
    
    Returns:
    
    A value used as a timer for the primary order.
    
    See Also:
    
    getOrder()
  - getPlagueTimer
```
public int getPlagueTimer()
```
    Retrieves the time, in frames, that @plague will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isPlagued()
  - getRemoveTimer
```
public int getRemoveTimer()
```
    Retrieves the time, in frames, until this temporary unit is destroyed or removed. This is used to determine the remaining time for the following units that were created by abilities: - @hallucination - @broodling - @swarm - @dweb - @scanner . Once this value reaches 0, the unit is destroyed.
  - getStasisTimer
```
public int getStasisTimer()
```
    Retrieves the time, in frames, that @stasis will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isPlagued()
  - getStimTimer
```
public int getStimTimer()
```
    Retrieves the time, in frames, that @stim will remain active on the current unit.
    
    Returns:
    
    Number of frames remaining until the effect is removed.
    
    See Also:
    
    isPlagued()
  - getBuildType
```
public UnitType getBuildType()
```
    Retrieves the building type that a @worker is about to construct. If the unit is morphing or is an incomplete structure, then this returns the UnitType that it will become when it has completed morphing/constructing.
    
    Returns:
    
    UnitType indicating the type that a @worker is about to construct, or an incomplete unit will be when completed.
  - getTrainingQueue
```
public List<UnitType> getTrainingQueue()
```
    Retrieves the list of unit types queued up to be trained.
    
    Returns:
    
    a List containing all the types that are in this factory's training queue, from oldest to most recent.
    
    See Also:
    
    train(bwapi.UnitType), cancelTrain(), isTraining()
  - getTrainingQueueAt
```
public UnitType getTrainingQueueAt(int i)
```
    Retrieves a unit type from a specific index in the queue of units this unit is training. This method does not have a direct analog in the BWAPI client API. It exists as a more performant alternative to getTrainingQueue().
  - getTrainingQueueCount
```
public int getTrainingQueueCount()
```
    Retrieves the number of units in this unit's training queue. This method does not have a direct analog in the BWAPI client API. It exists as a more performant alternative to getTrainingQueue().
  - getTech
```
public TechType getTech()
```
    Retrieves the technology that this unit is currently researching.
    
    Returns:
    
    TechType indicating the technology being researched by this unit. Returns TechType.None if this unit is not researching anything.
    
    See Also:
    
    research(bwapi.TechType), cancelResearch(), isResearching(), getRemainingResearchTime()
  - getUpgrade
```
public UpgradeType getUpgrade()
```
    Retrieves the upgrade that this unit is currently upgrading.
    
    Returns:
    
    UpgradeType indicating the upgrade in progress by this unit. Returns UpgradeType.None if this unit is not upgrading anything.
    
    See Also:
    
    upgrade(bwapi.UpgradeType), cancelUpgrade(), isUpgrading(), getRemainingUpgradeTime()
  - getRemainingBuildTime
```
public int getRemainingBuildTime()
```
    Retrieves the remaining build time for a unit or structure that is being trained or constructed.
    
    Returns:
    
    Number of frames remaining until the unit's completion.
  - getRemainingTrainTime
```
public int getRemainingTrainTime()
```
    Retrieves the remaining time, in frames, of the unit that is currently being trained.
    If the unit is a @Hatchery, @Lair, or @Hive, this retrieves the amount of time until the next larva spawns.
    
    Returns:
    
    Number of frames remaining until the current training unit becomes completed, or the number of frames remaining until the next larva spawns. Returns 0 if the unit is not training or has three larvae.
    + @see #train
    
    See Also:
    
    getTrainingQueue()
  - getRemainingResearchTime
```
public int getRemainingResearchTime()
```
    Retrieves the amount of time until the unit is done researching its currently assigned TechType.
    
    Returns:
    
    The remaining research time, in frames, for the current technology being researched by this unit. Returns 0 if the unit is not researching anything.
    
    See Also:
    
    research(bwapi.TechType), cancelResearch(), isResearching(), getTech()
  - getRemainingUpgradeTime
```
public int getRemainingUpgradeTime()
```
    Retrieves the amount of time until the unit is done upgrading its current upgrade.
    
    Returns:
    
    The remaining upgrade time, in frames, for the current upgrade. Returns 0 if the unit is not upgrading anything.
    
    See Also:
    
    upgrade(bwapi.UpgradeType), cancelUpgrade(), isUpgrading(), getUpgrade()
  - getBuildUnit
```
public Unit getBuildUnit()
```
    Retrieves the unit currently being trained, or the corresponding paired unit for @SCVs and @Terran structures, depending on the context. For example, if this unit is a @Factory under construction, this function will return the @SCV that is constructing it. If this unit is a @SCV, then it will return the structure it is currently constructing. If this unit is a @Nexus, and it is training a @Probe, then the probe will be returned.
    BUG: This will return an incorrect unit when called on @Reavers.
    
    Returns:
    
    Paired build unit that is either constructing this unit, structure being constructed by this unit, or the unit that is being trained by this structure. Returns null if there is no unit constructing this one, or this unit is not constructing another unit.
  - getTarget
```
public Unit getTarget()
```
    Generally returns the appropriate target unit after issuing an order that accepts a target unit (i.e. attack, repair, gather, etc.). To get a target that has been acquired automatically without issuing an order, use getOrderTarget().
    
    Returns:
    
    Unit that is currently being targeted by this unit.
    
    See Also:
    
    getOrderTarget()
  - getTargetPosition
```
public Position getTargetPosition()
```
    Retrieves the target position the unit is moving to, provided a valid path to the target position exists.
    
    Returns:
    
    Target position of a movement action.
  - getOrder
```
public Order getOrder()
```
    Retrieves the primary Order that the unit is assigned. Primary orders are distinct actions such as Order.AttackUnit and Order.PlayerGuard.
    
    Returns:
    
    The primary Order that the unit is executing.
  - getSecondaryOrder
```
public Order getSecondaryOrder()
```
    Retrieves the secondary Order that the unit is assigned. Secondary orders are run in the background as a sub-order. An example would be Order.TrainFighter, because a @Carrier can move and train fighters at the same time.
    
    Returns:
    
    The secondary Order that the unit is executing.
  - getOrderTarget
```
public Unit getOrderTarget()
```
    Retrieves the unit's primary order target. This is usually set when the low level unit AI acquires a new target automatically. For example if an enemy @Probe comes in range of your @Marine, the @Marine will start attacking it, and getOrderTarget will be set in this case, but not getTarget.
    
    Returns:
    
    The Unit that this unit is currently targetting.
    
    See Also:
    
    getTarget(), getOrder()
  - getOrderTargetPosition
```
public Position getOrderTargetPosition()
```
    Retrieves the target position for the unit's order. For example, when Order.Move is assigned, getTargetPosition() returns the end of the unit's path, but this returns the location that the unit is trying to move to.
    
    Returns:
    
    Position that this unit is currently targetting.
    
    See Also:
    
    getTargetPosition(), getOrder()
  - getRallyPosition
```
public Position getRallyPosition()
```
    Retrieves the position the structure is rallying units to once they are completed.
    
    Returns:
    
    Position that a completed unit coming from this structure will travel to. Returns Position.None If this building does not produce units.
    If getRallyUnit() is valid, then this value is ignored.
    
    See Also:
    
    setRallyPoint(bwapi.Position), getRallyUnit()
  - getRallyUnit
```
public Unit getRallyUnit()
```
    Retrieves the unit the structure is rallying units to once they are completed. Units will then follow the targetted unit.
    
    Returns:
    
    Unit that a completed unit coming from this structure will travel to. Returns null if the structure is not rallied to a unit or it does not produce units.
    A rallied unit takes precedence over a rallied position. That is if the return value is valid(non-null), then getRallyPosition is ignored.
    
    See Also:
    
    setRallyPoint(bwapi.Position), getRallyPosition()
  - getAddon
```
public Unit getAddon()
```
    Retrieves the add-on that is attached to this unit.
    
    Returns:
    
    Unit interface that represents the add-on that is attached to this unit. Returns null if this unit does not have an add-on.
  - getNydusExit
```
public Unit getNydusExit()
```
    Retrieves the @Nydus_Canal that is attached to this one. Every @Nydus_Canal can place a "Nydus Exit" which, when connected, can be travelled through by @Zerg units.
    
    Returns:
    
    Unit object representing the @Nydus_Canal connected to this one. Returns null if the unit is not a @Nydus_Canal, is not owned, or has not placed a Nydus Exit.
  - getPowerUp
```
public Unit getPowerUp()
```
    Retrieves the power-up that the worker unit is holding. Power-ups are special units such as the @Flag in the @CTF game type, which can be picked up by worker units.
    If your bot is strictly melee/1v1, then this method is not necessary.
    
    Returns:
    
    The Unit object that represents the power-up. Returns null if the unit is not carrying anything.
  - getTransport
```
public Unit getTransport()
```
    Retrieves the @Transport or @Bunker unit that has this unit loaded inside of it.
    
    Returns:
    
    Unit object representing the @Transport containing this unit. Returns null if this unit is not in a @Transport.
  - getLoadedUnits
```
public List<Unit> getLoadedUnits()
```
    Retrieves the set of units that are contained within this @Bunker or @Transport.
    
    Returns:
    
    A List object containing all of the units that are loaded inside of the current unit.
  - getSpaceRemaining
```
public int getSpaceRemaining()
```
    Retrieves the remaining unit-space available for @Bunkers and @Transports.
    
    Returns:
    
    The number of spots available to transport a unit.
    
    See Also:
    
    getLoadedUnits()
  - getCarrier
```
public Unit getCarrier()
```
    Retrieves the parent @Carrier that owns this @Interceptor.
    
    Returns:
    
    The parent @Carrier unit that has ownership of this one. Returns null if the current unit is not an @Interceptor.
  - getInterceptors
```
public List<Unit> getInterceptors()
```
    Retrieves the set of @Interceptors controlled by this unit. This is intended for @Carriers and its hero.
    
    Returns:
    
    List containing @Interceptor units owned by this carrier.
    
    See Also:
    
    getInterceptorCount()
  - getHatchery
```
public Unit getHatchery()
```
    Retrieves the parent @Hatchery, @Lair, or @Hive that owns this particular unit. This is intended for @Larvae.
    
    Returns:
    
    Hatchery unit that has ownership of this larva. Returns null if the current unit is not a @Larva or has no parent.
    
    See Also:
    
    getLarva()
  - getLarva
```
public List<Unit> getLarva()
```
    Retrieves the set of @Larvae that were spawned by this unit. Only @Hatcheries, @Lairs, and @Hives are capable of spawning @Larvae. This is like clicking the "Select Larva" button and getting the selection of @Larvae.
    
    Returns:
    
    List containing @Larva units owned by this unit. The set will be empty if there are none.
    
    See Also:
    
    getHatchery()
  - getUnitsInRadius
```
public List<Unit> getUnitsInRadius(int radius)
```
  - getUnitsInRadius
```
public List<Unit> getUnitsInRadius(int radius,
                                   UnitFilter pred)
```
    Retrieves the set of all units in a given radius of the current unit.
    Takes into account this unit's dimensions. Can optionally specify a filter that is composed using BWAPI Filter semantics to include only specific units (such as only ground units, etc.)
    
    Parameters:
    
    radius - The radius, in pixels, to search for units.
    
    pred - The composed function predicate to include only specific (desired) units in the set. Defaults to null, which means no filter.
    
    Returns:
    
    A List containing the set of units that match the given criteria.
    
    See Also:
    
    Game.getClosestUnit(bwapi.Position), getUnitsInWeaponRange(bwapi.WeaponType), Game.getUnitsInRadius(int, int, int), Game.getUnitsInRectangle(int, int, int, int)
  - getUnitsInWeaponRange
```
public List<Unit> getUnitsInWeaponRange(WeaponType weapon)
```
  - getUnitsInWeaponRange
```
public List<Unit> getUnitsInWeaponRange(WeaponType weapon,
                                        UnitFilter pred)
```
    Obtains the set of units within weapon range of this unit.
    
    Parameters:
    
    weapon - The weapon type to use as a filter for distance and units that can be hit by it.
    
    pred - A predicate used as an additional filter. If omitted, no additional filter is used.
    
    See Also:
    
    getUnitsInRadius(int), Game.getClosestUnit(bwapi.Position), Game.getUnitsInRadius(int, int, int), Game.getUnitsInRectangle(int, int, int, int)
  - hasNuke
```
public boolean hasNuke()
```
    Checks if the current unit is housing a @Nuke. This is only available for @Silos.
    
    Returns:
    
    true if this unit has a @Nuke ready, and false if there is no @Nuke.
  - isAccelerating
```
public boolean isAccelerating()
```
    Checks if the current unit is accelerating.
    
    Returns:
    
    true if this unit is accelerating, and false otherwise
  - isAttacking
```
public boolean isAttacking()
```
    Checks if this unit is currently attacking something.
    
    Returns:
    
    true if this unit is attacking another unit, and false if it is not.
  - isAttackFrame
```
public boolean isAttackFrame()
```
    Checks if this unit is currently playing an attack animation. Issuing commands while this returns true may interrupt the unit's next attack sequence.
    
    Returns:
    
    true if this unit is currently running an attack frame, and false if interrupting the unit is feasible.
    This function is only available to some unit types, specifically those that play special animations when they attack.
  - isBeingConstructed
```
public boolean isBeingConstructed()
```
    Checks if the current unit is being constructed. This is mostly applicable to Terran structures which require an SCV to be constructing a structure.
    
    Returns:
    
    true if this is either a Protoss structure, Zerg structure, or Terran structure being constructed by an attached SCV. false if this is either completed, not a structure, or has no SCV constructing it
    
    See Also:
    
    build(bwapi.UnitType), cancelConstruction(), haltConstruction(), isConstructing()
  - isBeingGathered
```
public boolean isBeingGathered()
```
    Checks this @Mineral_Field or @Refinery is currently being gathered from.
    
    Returns:
    
    true if this unit is a resource container and being harvested by a worker, and false otherwise
  - isBeingHealed
```
public boolean isBeingHealed()
```
    Checks if this unit is currently being healed by a @Medic or repaired by a @SCV.
    
    Returns:
    
    true if this unit is being healed, and false otherwise.
  - isBlind
```
public boolean isBlind()
```
    Checks if this unit is currently blinded by a @Medic 's @Optical_Flare ability. Blinded units have reduced sight range and cannot detect other units.
    
    Returns:
    
    true if this unit is blind, and false otherwise
  - isBraking
```
public boolean isBraking()
```
    Checks if the current unit is slowing down to come to a stop.
    
    Returns:
    
    true if this unit is breaking, false if it has stopped or is still moving at full speed.
  - isBurrowed
```
public boolean isBurrowed()
```
    Checks if the current unit is burrowed, either using the @Burrow ability, or is an armed @Spider_Mine.
    
    Returns:
    
    true if this unit is burrowed, and false otherwise
    
    See Also:
    
    burrow(), unburrow()
  - isCarrying
```
public boolean isCarrying()
```
  - isCarryingGas
```
public boolean isCarryingGas()
```
    Checks if this worker unit is carrying some vespene gas.
    
    Returns:
    
    true if this is a worker unit carrying vespene gas, and false if it is either not a worker, or not carrying gas.
    
    See Also:
    
    returnCargo(), isGatheringGas(), isCarryingMinerals()
  - isCarryingMinerals
```
public boolean isCarryingMinerals()
```
    Checks if this worker unit is carrying some minerals.
    
    Returns:
    
    true if this is a worker unit carrying minerals, and false if it is either not a worker, or not carrying minerals.
    
    See Also:
    
    returnCargo(), isGatheringMinerals(), isCarryingMinerals()
  - isCloaked
```
public boolean isCloaked()
```
    Checks if this unit is currently @cloaked.
    
    Returns:
    
    true if this unit is cloaked, and false if it is visible.
    
    See Also:
    
    cloak(), decloak()
  - isCompleted
```
public boolean isCompleted()
```
    Checks if this unit has finished being constructed, trained, morphed, or warped in, and can now receive orders.
    
    Returns:
    
    true if this unit is completed, and false if it is under construction or inaccessible.
  - isConstructing
```
public boolean isConstructing()
```
    Checks if a unit is either constructing something or moving to construct something.
    
    Returns:
    
    true when a unit has been issued an order to build a structure and is moving to the build location, or is currently constructing something.
    
    See Also:
    
    isBeingConstructed(), build(bwapi.UnitType), cancelConstruction(), haltConstruction()
  - isDefenseMatrixed
```
public boolean isDefenseMatrixed()
```
    Checks if this unit has the @matrix effect.
    
    Returns:
    
    true if the @matrix ability was used on this unit, and false otherwise.
  - isDetected
```
public boolean isDetected()
```
    Checks if this unit is visible or revealed by a detector unit. If this is false and #isVisible is true, then the unit is only partially visible and requires a detector in order to be targetted.
    
    Returns:
    
    true if this unit is detected, and false if it needs a detector unit nearby in order to see it.
  - isEnsnared
```
public boolean isEnsnared()
```
    Checks if the @Queen ability @Ensnare has been used on this unit.
    
    Returns:
    
    true if the unit is ensnared, and false if it is not
  - isFlying
```
public boolean isFlying()
```
    This macro function checks if this unit is in the air. That is, the unit is either a flyer or a flying building.
    
    Returns:
    
    true if this unit is in the air, and false if it is on the ground
    
    See Also:
    
    UnitType.isFlyer(), isLifted()
  - isFollowing
```
public boolean isFollowing()
```
    Checks if this unit is following another unit. When a unit is following another unit, it simply moves where the other unit does, and does not attack enemies when it is following.
    
    Returns:
    
    true if this unit is following another unit, and false if it is not
    
    See Also:
    
    follow(bwapi.Unit), getTarget()
  - isGatheringGas
```
public boolean isGatheringGas()
```
    Checks if this unit is currently gathering gas. That is, the unit is either moving to a refinery, waiting to enter a refinery, harvesting from the refinery, or returning gas to a resource depot.
    
    Returns:
    
    true if this unit is harvesting gas, and false if it is not
    
    See Also:
    
    isCarryingGas()
  - isGatheringMinerals
```
public boolean isGatheringMinerals()
```
    Checks if this unit is currently harvesting minerals. That is, the unit is either moving to a @mineral_field, waiting to mine, mining minerals, or returning minerals to a resource depot.
    
    Returns:
    
    true if this unit is gathering minerals, and false if it is not
    
    See Also:
    
    isCarryingMinerals()
  - isHallucination
```
public boolean isHallucination()
```
    Checks if this unit is a hallucination. Hallucinations are created by the @High_Templar using the @Hallucination ability. Enemy hallucinations are unknown if Flag.CompleteMapInformation is disabled. Hallucinations have a time limit until they are destroyed (see getRemoveTimer()).
    
    Returns:
    
    true if the unit is a hallucination and false otherwise.
    
    See Also:
    
    getRemoveTimer()
  - isHoldingPosition
```
public boolean isHoldingPosition()
```
    Checks if the unit is currently holding position. A unit that is holding position will attack other units, but will not chase after them.
    
    Returns:
    
    true if this unit is holding position, and false if it is not.
    
    See Also:
    
    holdPosition()
  - isIdle
```
public boolean isIdle()
```
    Checks if this unit is running an idle order. This function is particularly useful when checking for units that aren't doing any tasks that you assigned.
    A unit is considered idle if it is not doing any of the following: - Training - Constructing - Morphing - Researching - Upgrading
    In addition to running one of the following orders: - Order.PlayerGuard: Player unit idle. - Order.Guard: Generic unit idle. - Order.Stop - Order.PickupIdle - Order.Nothing: Structure/generic idle. - Order.Medic: Medic idle. - Order.Carrier: Carrier idle. - Order.Reaver: Reaver idle. - Order.Critter: Critter idle. - Order.Neutral: Neutral unit idle. - Order.TowerGuard: Turret structure idle. - Order.Burrowed: Burrowed unit idle. - Order.NukeTrain - Order.Larva: Larva idle.
    
    Returns:
    
    true if this unit is idle, and false if this unit is performing any action, such as moving or attacking
    
    See Also:
    
    stop()
  - isInterruptible
```
public boolean isInterruptible()
```
    Checks if the unit can be interrupted.
    
    Returns:
    
    true if this unit can be interrupted, or false if this unit is uninterruptable
  - isInvincible
```
public boolean isInvincible()
```
    Checks the invincibility state for this unit.
    
    Returns:
    
    true if this unit is currently invulnerable, and false if it is vulnerable
  - isInWeaponRange
```
public boolean isInWeaponRange(Unit target)
```
    Checks if the target unit can immediately be attacked by this unit in the current frame.
    
    Parameters:
    
    target - The target unit to use in this check.
    
    Returns:
    
    true if target is within weapon range of this unit's appropriate weapon, and false otherwise. Returns false if target is invalid, inaccessible, too close, too far, or this unit does not have a weapon that can attack target.
  - isIrradiated
```
public boolean isIrradiated()
```
    Checks if this unit is irradiated by a @Science_Vessel 's @Irradiate ability.
    
    Returns:
    
    true if this unit is irradiated, and false otherwise
    
    See Also:
    
    getIrradiateTimer()
  - isLifted
```
public boolean isLifted()
```
    Checks if this unit is a @Terran building and lifted off the ground. This function generally implies getType().isBuilding() and isCompleted() both return true.
    
    Returns:
    
    true if this unit is a @Terran structure lifted off the ground.
    
    See Also:
    
    isFlying()
  - isLoaded
```
public boolean isLoaded()
```
    Checks if this unit is currently loaded into another unit such as a @Transport.
    
    Returns:
    
    true if this unit is loaded in another one, and false otherwise
    
    See Also:
    
    load(bwapi.Unit), unload(bwapi.Unit), unloadAll()
  - isLockedDown
```
public boolean isLockedDown()
```
    Checks if this unit is currently @locked by a @Ghost.
    
    Returns:
    
    true if this unit is locked down, and false otherwise
    
    See Also:
    
    getLockdownTimer()
  - isMaelstrommed
```
public boolean isMaelstrommed()
```
    Checks if this unit has been @Maelstrommed by a @Dark_Archon.
    
    Returns:
    
    true if this unit is maelstrommed, and false otherwise
    
    See Also:
    
    getMaelstromTimer()
  - isMorphing
```
public boolean isMorphing()
```
    Finds out if the current unit is morphing or not. @Zerg units and structures often have the ability to #morph into different types of units. This function allows you to identify when this process is occurring.
    
    Returns:
    
    true if the unit is currently morphing, false if the unit is not morphing
    
    See Also:
    
    morph(bwapi.UnitType), cancelMorph(), getBuildType(), getRemainingBuildTime()
  - isMoving
```
public boolean isMoving()
```
    Checks if this unit is currently moving.
    
    Returns:
    
    true if this unit is moving, and false if it is not
    
    See Also:
    
    stop()
  - isParasited
```
public boolean isParasited()
```
    Checks if this unit has been parasited by some other player.
    
    Returns:
    
    true if this unit is inflicted with @parasite, and false if it is clean
  - isPatrolling
```
public boolean isPatrolling()
```
    Checks if this unit is patrolling between two positions.
    
    Returns:
    
    true if this unit is patrolling and false if it is not
    
    See Also:
    
    patrol(bwapi.Position)
  - isPlagued
```
public boolean isPlagued()
```
    Checks if this unit has been been @plagued by a @defiler.
    
    Returns:
    
    true if this unit is inflicted with @plague and is taking damage, and false if it is clean
    
    See Also:
    
    getPlagueTimer()
  - isRepairing
```
public boolean isRepairing()
```
    Checks if this unit is repairing or moving to @repair another unit. This is only applicable to @SCVs.
    
    Returns:
    
    true if this unit is currently repairing or moving to @repair another unit, and false if it is not
  - isResearching
```
public boolean isResearching()
```
    Checks if this unit is a structure that is currently researching a technology. See TechTypes for a complete list of technologies in Broodwar.
    
    Returns:
    
    true if this structure is researching a technology, false otherwise
    
    See Also:
    
    research(bwapi.TechType), cancelResearch(), getTech(), getRemainingResearchTime()
  - isSelected
```
public boolean isSelected()
```
    Checks if this unit has been selected in the user interface. This function is only available if the flag Flag#UserInput is enabled.
    
    Returns:
    
    true if this unit is currently selected, and false if this unit is not selected
    
    See Also:
    
    Game.getSelectedUnits()
  - isSieged
```
public boolean isSieged()
```
    Checks if this unit is currently @sieged. This is only applicable to @Siege_Tanks.
    
    Returns:
    
    true if the unit is in siege mode, and false if it is either not in siege mode or not a @Siege_Tank
    
    See Also:
    
    siege(), unsiege()
  - isStartingAttack
```
public boolean isStartingAttack()
```
    Checks if the unit is starting to attack.
    
    Returns:
    
    true if this unit is starting an attack.
    
    See Also:
    
    attack(bwapi.Position), getGroundWeaponCooldown(), getAirWeaponCooldown()
  - isStasised
```
public boolean isStasised()
```
    Checks if this unit is inflicted with @Stasis by an @Arbiter.
    
    Returns:
    
    true if this unit is locked in a @Stasis and is unable to move, and false if it is free.
    This function does not necessarily imply that the unit is invincible, since there is a feature in the @UMS game type that allows stasised units to be vulnerable.
    
    See Also:
    
    getStasisTimer()
  - isStimmed
```
public boolean isStimmed()
```
    Checks if this unit is currently under the influence of a @Stim_Pack.
    
    Returns:
    
    true if this unit has used a stim pack, false otherwise
    
    See Also:
    
    getStimTimer()
  - isStuck
```
public boolean isStuck()
```
    Checks if this unit is currently trying to resolve a collision by randomly moving around.
    
    Returns:
    
    true if this unit is currently stuck and trying to resolve a collision, and false if this unit is free
  - isTraining
```
public boolean isTraining()
```
    Checks if this unit is training a new unit. For example, a @Barracks training a @Marine.
    It is possible for a unit to remain in the training queue with no progress. In that case, this function will return false because of supply or unit count limitations.
    
    Returns:
    
    true if this unit is currently training another unit, and false otherwise.
    
    See Also:
    
    train(bwapi.UnitType), getTrainingQueue(), cancelTrain(), getRemainingTrainTime()
  - isUnderAttack
```
public boolean isUnderAttack()
```
    Checks if the current unit is being attacked. Has a small delay before this returns false again when the unit is no longer being attacked.
    
    Returns:
    
    true if this unit has been attacked within the past few frames, and false if it has not
  - isUnderDarkSwarm
```
public boolean isUnderDarkSwarm()
```
    Checks if this unit is under the cover of a @Dark_Swarm.
    
    Returns:
    
    true if this unit is protected by a @Dark_Swarm, and false if it is not
  - isUnderDisruptionWeb
```
public boolean isUnderDisruptionWeb()
```
    Checks if this unit is currently being affected by a @Disruption_Web.
    
    Returns:
    
    true if this unit is under the effects of @Disruption_Web.
  - isUnderStorm
```
public boolean isUnderStorm()
```
    Checks if this unit is currently taking damage from a @Psi_Storm.
    
    Returns:
    
    true if this unit is losing hit points from a @Psi_Storm, and false otherwise.
  - isPowered
```
public boolean isPowered()
```
    Checks if this unit has power. Most structures are powered by default, but @Protoss structures require a @Pylon to be powered and functional.
    
    Returns:
    
    true if this unit has power or is inaccessible, and false if this unit is unpowered.
    
    Since:
    
    4.0.1 Beta (previously isUnpowered)
  - isUpgrading
```
public boolean isUpgrading()
```
    Checks if this unit is a structure that is currently upgrading an upgrade. See UpgradeTypes for a full list of upgrades in Broodwar.
    
    Returns:
    
    true if this structure is upgrading, false otherwise
    
    See Also:
    
    upgrade(bwapi.UpgradeType), cancelUpgrade(), getUpgrade(), getRemainingUpgradeTime()
  - isVisible
```
public boolean isVisible()
```
  - isVisible
```
public boolean isVisible(Player player)
```
    Checks if this unit is visible.
    
    Parameters:
    
    player - The player to check visibility for. If this parameter is omitted, then the BWAPI player obtained from Game.self() will be used.
    
    Returns:
    
    true if this unit is visible to the specified player, and false if it is not.
    If the Flag.CompleteMapInformation flag is enabled, existing units hidden by the fog of war will be accessible, but isVisible will still return false.
    
    See Also:
    
    exists()
  - isTargetable
```
public boolean isTargetable()
```
    Performs some cheap checks to attempt to quickly detect whether the unit is unable to be targetted as the target unit of an unspecified command.
    
    Returns:
    
    true if BWAPI was unable to determine whether the unit can be a target, false if an error occurred and the unit can not be a target.
    
    See Also:
    
    canTargetUnit(bwapi.Unit)
  - issueCommand
```
public boolean issueCommand(UnitCommand command)
```
    This function issues a command to the unit(s), however it is used for interfacing only, and is recommended to use one of the more specific command functions when writing an AI.
    
    Parameters:
    
    command - A UnitCommand containing command parameters such as the type, position, target, etc.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    UnitCommandType, canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean)
  - attack
```
public boolean attack(Position target)
```
  - attack
```
public boolean attack(Unit target)
```
  - attack
```
public boolean attack(Position target,
                      boolean shiftQueueCommand)
```
    Orders the unit(s) to attack move to the specified position.
    
    Parameters:
    
    target - A Position to designate as the target. The unit will perform an Attack Move command.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    A @Medic will use Heal Move instead of attack.
    
    See Also:
    
    canAttack()
  - attack
```
public boolean attack(Unit target,
                      boolean shiftQueueCommand)
```
  - build
```
public boolean build(UnitType type)
```
  - build
```
public boolean build(UnitType type,
                     TilePosition target)
```
    Orders the worker unit(s) to construct a structure at a target position.
    
    Parameters:
    
    type - The UnitType to build.
    
    target - A TilePosition to specify the build location, specifically the upper-left corner of the location. If the target is not specified, then the function call will be redirected to the train command.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    You must have sufficient resources and meet the necessary requirements in order to build a structure.
    
    See Also:
    
    train(bwapi.UnitType), cancelConstruction(), canBuild()
  - buildAddon
```
public boolean buildAddon(UnitType type)
```
    Orders the @Terran structure(s) to construct an add-on.
    
    Parameters:
    
    type - The add-on UnitType to construct.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    You must have sufficient resources and meet the necessary requirements in order to build a structure.
    
    See Also:
    
    build(bwapi.UnitType), cancelAddon(), canBuildAddon()
  - train
```
public boolean train(UnitType type)
```
    Orders the unit(s) to add a UnitType to its training queue, or morphs into the UnitType if it is @Zerg.
    
    Parameters:
    
    type - The UnitType to train.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    You must have sufficient resources, supply, and meet the necessary requirements in order to train a unit.
    This command is also used for training @Interceptors and @Scarabs. If you call this using a @Hatchery, @Lair, or @Hive, then it will automatically pass the command to one of its @Larvae.
    
    See Also:
    
    build(bwapi.UnitType), morph(bwapi.UnitType), cancelTrain(), isTraining(), canTrain()
  - morph
```
public boolean morph(UnitType type)
```
    Orders the unit(s) to morph into a different UnitType.
    
    Parameters:
    
    type - The UnitType to morph into.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    build(bwapi.UnitType), morph(bwapi.UnitType), canMorph()
  - research
```
public boolean research(TechType tech)
```
    Orders the unit to research the given tech type.
    
    Parameters:
    
    tech - The TechType to research.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    cancelResearch(), isResearching(), getRemainingResearchTime(), getTech(), canResearch()
  - upgrade
```
public boolean upgrade(UpgradeType upgrade)
```
    Orders the unit to upgrade the given upgrade type.
    
    Parameters:
    
    upgrade - The UpgradeType to upgrade.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    cancelUpgrade(), isUpgrading(), getRemainingUpgradeTime(), getUpgrade(), canUpgrade()
  - setRallyPoint
```
public boolean setRallyPoint(Position target)
```
    Orders the unit to set its rally position.
    
    Parameters:
    
    target - The target position that this structure will rally completed units to.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    getRallyPosition(), getRallyUnit(), canSetRallyPoint(), canSetRallyPosition(), canSetRallyUnit()
  - setRallyPoint
```
public boolean setRallyPoint(Unit target)
```
  - move
```
public boolean move(Position target)
```
  - move
```
public boolean move(Position target,
                    boolean shiftQueueCommand)
```
    Orders the unit to move from its current position to the specified position.
    
    Parameters:
    
    target - The target position to move to.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail. There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isMoving(), canMove()
  - patrol
```
public boolean patrol(Position target)
```
  - patrol
```
public boolean patrol(Position target,
                      boolean shiftQueueCommand)
```
    Orders the unit to patrol between its current position and the specified position. While patrolling, units will attack and chase enemy units that they encounter, and then return to its patrol route. @Medics will automatically heal units and then return to their patrol route.
    
    Parameters:
    
    target - The position to patrol to.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isPatrolling(), canPatrol()
  - holdPosition
```
public boolean holdPosition()
```
  - holdPosition
```
public boolean holdPosition(boolean shiftQueueCommand)
```
    Orders the unit to hold its position.
    
    Parameters:
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    canHoldPosition(), isHoldingPosition()
  - stop
```
public boolean stop()
```
  - stop
```
public boolean stop(boolean shiftQueueCommand)
```
    Orders the unit to stop.
    
    Parameters:
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    canStop(), isIdle()
  - follow
```
public boolean follow(Unit target)
```
  - follow
```
public boolean follow(Unit target,
                      boolean shiftQueueCommand)
```
    Orders the unit to follow the specified unit. Units that are following other units will not perform any other actions such as attacking. They will ignore attackers.
    
    Parameters:
    
    target - The target unit to start following.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isFollowing(), canFollow(), getOrderTarget()
  - gather
```
public boolean gather(Unit target)
```
  - gather
```
public boolean gather(Unit target,
                      boolean shiftQueueCommand)
```
    Orders the unit to gather the specified unit (must be mineral or refinery type).
    
    Parameters:
    
    target - The target unit to gather from.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isGatheringGas(), isGatheringMinerals(), canGather()
  - returnCargo
```
public boolean returnCargo()
```
  - returnCargo
```
public boolean returnCargo(boolean shiftQueueCommand)
```
    Orders the unit to return its cargo to a nearby resource depot such as a Command Center. Only workers that are carrying minerals or gas can be ordered to return cargo.
    
    Parameters:
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isCarryingGas(), isCarryingMinerals(), canReturnCargo()
  - repair
```
public boolean repair(Unit target)
```
  - repair
```
public boolean repair(Unit target,
                      boolean shiftQueueCommand)
```
    Orders the unit to repair the specified unit. Only Terran SCVs can be ordered to repair, and the target must be a mechanical @Terran unit or building.
    
    Parameters:
    
    target - The unit to repair.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isRepairing(), canRepair()
  - burrow
```
public boolean burrow()
```
    Orders the unit to burrow. Either the unit must be a @Lurker, or the unit must be a @Zerg ground unit that is capable of @Burrowing, and @Burrow technology must be researched.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail. There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    unburrow(), isBurrowed(), canBurrow()
  - unburrow
```
public boolean unburrow()
```
    Orders a burrowed unit to unburrow.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    burrow(), isBurrowed(), canUnburrow()
  - cloak
```
public boolean cloak()
```
    Orders the unit to cloak.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    decloak(), isCloaked(), canCloak()
  - decloak
```
public boolean decloak()
```
    Orders a cloaked unit to decloak.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    cloak(), isCloaked(), canDecloak()
  - siege
```
public boolean siege()
```
    Orders the unit to siege. Only works for @Siege_Tanks.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    unsiege(), isSieged(), canSiege()
  - unsiege
```
public boolean unsiege()
```
    Orders the unit to unsiege. Only works for sieged @Siege_Tanks.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    siege(), isSieged(), canUnsiege()
  - lift
```
public boolean lift()
```
    Orders the unit to lift. Only works for liftable @Terran structures.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    land(bwapi.TilePosition), isLifted(), canLift()
  - land
```
public boolean land(TilePosition target)
```
    Orders the unit to land. Only works for @Terran structures that are currently lifted.
    
    Parameters:
    
    target - The tile position to land this structure at.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    lift(), isLifted(), canLand()
  - load
```
public boolean load(Unit target)
```
  - load
```
public boolean load(Unit target,
                    boolean shiftQueueCommand)
```
    Orders the unit to load the target unit. Only works if this unit is a @Transport or @Bunker type.
    
    Parameters:
    
    target - The target unit to load into this @Transport or @Bunker.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    unload(bwapi.Unit), unloadAll(), getLoadedUnits(), isLoaded()
  - unload
```
public boolean unload(Unit target)
```
    Orders the unit to unload the target unit. Only works for @Transports and @Bunkers.
    
    Parameters:
    
    target - Unloads the target unit from this @Transport or @Bunker.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    load(bwapi.Unit), unloadAll(), getLoadedUnits(), isLoaded(), canUnload(), canUnloadAtPosition(bwapi.Position, boolean)
  - unloadAll
```
public boolean unloadAll()
```
  - unloadAll
```
public boolean unloadAll(boolean shiftQueueCommand)
```
  - unloadAll
```
public boolean unloadAll(Position target)
```
  - unloadAll
```
public boolean unloadAll(Position target,
                         boolean shiftQueueCommand)
```
    Orders the unit to unload all loaded units at the unit's current position. Only works for @Transports and @Bunkers.
    
    Parameters:
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    load(bwapi.Unit), unload(bwapi.Unit), getLoadedUnits(), isLoaded(), canUnloadAll(), canUnloadAtPosition(bwapi.Position, boolean)
  - rightClick
```
public boolean rightClick(Position target)
```
  - rightClick
```
public boolean rightClick(Unit target)
```
  - rightClick
```
public boolean rightClick(Position target,
                          boolean shiftQueueCommand)
```
    Performs a right click action as it would work in StarCraft.
    
    Parameters:
    
    target - The target position to right click.
    
    shiftQueueCommand - If this value is true, then the order will be queued instead of immediately executed. If this value is omitted, then the order will be executed immediately by default.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    canRightClick(), canRightClickPosition(), canRightClickUnit()
  - rightClick
```
public boolean rightClick(Unit target,
                          boolean shiftQueueCommand)
```
  - haltConstruction
```
public boolean haltConstruction()
```
    Orders a @SCV to stop constructing a structure. This leaves the structure in an incomplete state until it is either cancelled, razed, or completed by another @SCV.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isConstructing(), canHaltConstruction()
  - cancelConstruction
```
public boolean cancelConstruction()
```
    Orders this unit to cancel and refund itself from begin constructed.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    isBeingConstructed(), build(bwapi.UnitType), canCancelConstruction()
  - cancelAddon
```
public boolean cancelAddon()
```
    Orders this unit to cancel and refund an add-on that is being constructed.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    canCancelAddon(), buildAddon(bwapi.UnitType)
  - cancelTrain
```
public boolean cancelTrain()
```
  - cancelTrain
```
public boolean cancelTrain(int slot)
```
    Orders the unit to remove the specified unit from its training queue.
    
    Parameters:
    
    slot - Identifies the slot that will be cancelled. If the specified value is at least 0, then the unit in the corresponding slot from the list provided by getTrainingQueue() will be cancelled. If the value is either omitted or -2, then the last slot is cancelled.
    The value of slot is passed directly to Broodwar. Other negative values have no effect.
    
    See Also:
    
    train(bwapi.UnitType), cancelTrain(), isTraining(), getTrainingQueue(), canCancelTrain(), canCancelTrainSlot()
  - cancelMorph
```
public boolean cancelMorph()
```
    Orders this unit to cancel and refund a unit that is morphing.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    morph(bwapi.UnitType), isMorphing(), canCancelMorph()
  - cancelResearch
```
public boolean cancelResearch()
```
    Orders this unit to cancel and refund a research that is in progress.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    research(bwapi.TechType), isResearching(), getTech(), canCancelResearch()
  - cancelUpgrade
```
public boolean cancelUpgrade()
```
    Orders this unit to cancel and refund an upgrade that is in progress.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    
    See Also:
    
    upgrade(bwapi.UpgradeType), isUpgrading(), getUpgrade(), canCancelUpgrade()
  - useTech
```
public boolean useTech(TechType tech)
```
  - useTech
```
public boolean useTech(TechType tech,
                       Position target)
```
    Orders the unit to use a technology.
    
    Parameters:
    
    tech - The technology type to use.
    
    target - If specified, indicates the target location to use the tech on.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    
    See Also:
    
    canUseTechWithOrWithoutTarget(), canUseTech(bwapi.TechType, bwapi.Position, boolean, boolean, boolean), canUseTechWithoutTarget(bwapi.TechType, boolean), canUseTechUnit(bwapi.TechType, boolean), canUseTechPosition(bwapi.TechType, boolean), TechType
  - useTech
```
public boolean useTech(TechType tech,
                       Unit target)
```
  - placeCOP
```
public boolean placeCOP(TilePosition target)
```
    Moves a @Flag_Beacon to a different location. This is only used for @CTF or @UMS game types.
    
    Parameters:
    
    target - The target tile position to place the @Flag_Beacon.
    
    Returns:
    
    true if the command was passed to Broodwar, and false if BWAPI determined that the command would fail.
    There is a small chance for a command to fail after it has been passed to Broodwar.
    This command is only available for the first 10 minutes of the game, as in Broodwar.
    
    See Also:
    
    canPlaceCOP()
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command,
                               boolean checkCanUseTechPositionOnPositions,
                               boolean checkCanUseTechUnitOnUnits,
                               boolean checkCanBuildUnitType,
                               boolean checkCanTargetUnit,
                               boolean checkCanIssueCommandType)
```
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command,
                               boolean checkCanUseTechPositionOnPositions,
                               boolean checkCanUseTechUnitOnUnits,
                               boolean checkCanBuildUnitType,
                               boolean checkCanTargetUnit)
```
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command,
                               boolean checkCanUseTechPositionOnPositions,
                               boolean checkCanUseTechUnitOnUnits,
                               boolean checkCanBuildUnitType)
```
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command,
                               boolean checkCanUseTechPositionOnPositions,
                               boolean checkCanUseTechUnitOnUnits)
```
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command,
                               boolean checkCanUseTechPositionOnPositions)
```
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command)
```
  - canIssueCommand
```
public boolean canIssueCommand(UnitCommand command,
                               boolean checkCanUseTechPositionOnPositions,
                               boolean checkCanUseTechUnitOnUnits,
                               boolean checkCanBuildUnitType,
                               boolean checkCanTargetUnit,
                               boolean checkCanIssueCommandType,
                               boolean checkCommandibility)
```
    Checks whether the unit is able to execute the given command. If you are calling this function repeatedly (e.g. to generate a collection of valid commands), you can avoid repeating the same kinds of checks by specifying false for some of the optional boolean arguments. Make sure that the state hasn't changed since the check was done though (eg a new frame/event, or a command issued). Also see the more specific functions.
    
    Parameters:
    
    command - A UnitCommand to check.
    
    checkCanUseTechPositionOnPositions - Only used if the command type is UnitCommandType.Use_Tech_Position. A boolean for whether to perform cheap checks for whether the unit is unable to target any positions using the command's TechType (i.e. regardless of what the other command parameters are). You can set this to false if you know this check has already just been performed.
    
    checkCanUseTechUnitOnUnits - Only used if the command type is UnitCommandType.Use_Tech_Unit. A boolean for whether to perform cheap checks for whether the unit is unable to target any units using the command's TechType (i.e. regardless of what the other command parameters are). You can set this to false if you know this check has already just been performed.
    
    checkCanBuildUnitType - Only used if the command type is UnitCommandType.Build. A boolean for whether to perform cheap checks for whether the unit is unable to build the specified UnitType (i.e. regardless of what the other command parameters are). You can set this to false if you know this check has already just been performed.
    
    checkCanTargetUnit - Only used for command types that can target a unit. A boolean for whether to perform canTargetUnit(bwapi.Unit) as a check. You can set this to false if you know this check has already just been performed.
    
    checkCanIssueCommandType - A boolean for whether to perform canIssueCommandType(bwapi.UnitCommandType) as a check. You can set this to false if you know this check has already just been performed.
    
    checkCommandibility - A boolean for whether to perform canCommand() as a check. You can set this to false if you know this check has already just been performed.
    
    Returns:
    
    true if BWAPI determined that the command is valid, false if an error occurred and the command is invalid.
    
    See Also:
    
    UnitCommandType, canCommand(), canIssueCommandType(bwapi.UnitCommandType), canTargetUnit(bwapi.Unit)
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command,
                                      boolean checkCanUseTechPositionOnPositions,
                                      boolean checkCanUseTechUnitOnUnits,
                                      boolean checkCanTargetUnit,
                                      boolean checkCanIssueCommandType,
                                      boolean checkCommandibilityGrouped)
```
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command,
                                      boolean checkCanUseTechPositionOnPositions,
                                      boolean checkCanUseTechUnitOnUnits,
                                      boolean checkCanTargetUnit,
                                      boolean checkCanIssueCommandType)
```
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command,
                                      boolean checkCanUseTechPositionOnPositions,
                                      boolean checkCanUseTechUnitOnUnits,
                                      boolean checkCanTargetUnit)
```
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command,
                                      boolean checkCanUseTechPositionOnPositions,
                                      boolean checkCanUseTechUnitOnUnits)
```
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command,
                                      boolean checkCanUseTechPositionOnPositions)
```
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command)
```
  - canIssueCommandGrouped
```
public boolean canIssueCommandGrouped(UnitCommand command,
                                      boolean checkCanUseTechPositionOnPositions,
                                      boolean checkCanUseTechUnitOnUnits,
                                      boolean checkCanTargetUnit,
                                      boolean checkCanIssueCommandType,
                                      boolean checkCommandibilityGrouped,
                                      boolean checkCommandibility)
```
    Checks whether the unit is able to execute the given command as part of a List (even if none of the units in the List are able to execute the command individually). The reason this function exists is because some commands are valid for an individual unit but not for those individuals as a group (e.g. buildings, critters) and some commands are only valid for a unit if it is commanded as part of a unit group, e.g.: 1. attackMove/attackUnit for a List, some of which can't attack, e.g. @High_Templar. This is supported simply for consistency with BW's behaviour - you could issue move command(s) individually instead. 2. attackMove/move/patrol/rightClickPosition for air unit(s) + e.g. @Larva, as part of the air stacking technique. This is supported simply for consistency with BW's behaviour - you could issue move/patrol/rightClickPosition command(s) for them individually instead.
    BWAPI allows the following special cases to command a unit individually (rather than only allowing it to be commanded as part of a List). These commands are not available to a user in BW when commanding units individually, but BWAPI allows them for convenience: - attackMove for @Medic, which is equivalent to Heal Move. - holdPosition for burrowed @Lurker, for ambushes. - stop for @Larva, to move it to a different side of the @Hatchery / @Lair / @Hive (e.g. so that @Drones morphed later morph nearer to minerals/gas).
    
    See Also:
    
    UnitCommandType, canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canCommandGrouped(), canIssueCommandTypeGrouped(bwapi.UnitCommandType, boolean), canTargetUnit(bwapi.Unit)
  - canCommand
```
public boolean canCommand()
```
    Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute any commands (eg the unit is stasised).
    
    Returns:
    
    true if BWAPI was unable to determine whether the unit can be commanded, false if an error occurred and the unit can not be commanded.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean)
  - canCommandGrouped
```
public boolean canCommandGrouped()
```
  - canCommandGrouped
```
public boolean canCommandGrouped(boolean checkCommandibility)
```
    Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute any commands as part of a List (eg buildings, critters).
    
    Returns:
    
    true if BWAPI was unable to determine whether the unit can be commanded grouped, false if an error occurred and the unit can not be commanded grouped.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean)
  - canIssueCommandType
```
public boolean canIssueCommandType(UnitCommandType ct)
```
  - canIssueCommandType
```
public boolean canIssueCommandType(UnitCommandType ct,
                                   boolean checkCommandibility)
```
    Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute the given command type (i.e. regardless of what other possible command parameters could be).
    
    Parameters:
    
    ct - A UnitCommandType.
    
    checkCommandibility - A boolean for whether to perform canCommand() as a check. You can set this to false if you know this check has already just been performed.
    
    Returns:
    
    true if BWAPI was unable to determine whether the command type is invalid, false if an error occurred and the command type is invalid.
    
    See Also:
    
    UnitCommandType, canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean)
  - canIssueCommandTypeGrouped
```
public boolean canIssueCommandTypeGrouped(UnitCommandType ct,
                                          boolean checkCommandibilityGrouped)
```
  - canIssueCommandTypeGrouped
```
public boolean canIssueCommandTypeGrouped(UnitCommandType ct)
```
  - canIssueCommandTypeGrouped
```
public boolean canIssueCommandTypeGrouped(UnitCommandType ct,
                                          boolean checkCommandibilityGrouped,
                                          boolean checkCommandibility)
```
    Performs some cheap checks to attempt to quickly detect whether the unit is unable to execute the given command type (i.e. regardless of what other possible command parameters could be) as part of a List.
    
    Parameters:
    
    ct - A UnitCommandType.
    
    checkCommandibilityGrouped - A boolean for whether to perform canCommandGrouped() as a check. You can set this to false if you know this check has already just been performed.
    
    checkCommandibility - A boolean for whether to perform canCommand() as a check. You can set this to false if you know this check has already just been performed.
    
    Returns:
    
    true if BWAPI was unable to determine whether the command type is invalid, false if an error occurred and the command type is invalid.
    
    See Also:
    
    UnitCommandType, canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean)
  - canTargetUnit
```
public boolean canTargetUnit(Unit targetUnit)
```
  - canTargetUnit
```
public boolean canTargetUnit(Unit targetUnit,
                             boolean checkCommandibility)
```
    Performs some cheap checks to attempt to quickly detect whether the unit is unable to use the given unit as the target unit of an unspecified command.
    
    Parameters:
    
    targetUnit - A target unit for an unspecified command.
    
    checkCommandibility - A boolean for whether to perform canCommand() as a check. You can set this to false if you know this check has already just been performed.
    
    Returns:
    
    true if BWAPI was unable to determine whether the unit can target the given unit, false if an error occurred and the unit can not target the given unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), isTargetable()
  - canAttack
```
public boolean canAttack()
```
  - canAttack
```
public boolean canAttack(boolean checkCommandibility)
```
  - canAttack
```
public boolean canAttack(Position target,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType)
```
  - canAttack
```
public boolean canAttack(Unit target,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType)
```
  - canAttack
```
public boolean canAttack(Position target,
                         boolean checkCanTargetUnit)
```
  - canAttack
```
public boolean canAttack(Unit target,
                         boolean checkCanTargetUnit)
```
  - canAttack
```
public boolean canAttack(Position target)
```
  - canAttack
```
public boolean canAttack(Unit target)
```
  - canAttack
```
public boolean canAttack(Position target,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType,
                         boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an attack command to attack-move or attack a unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), attack(bwapi.Position), canAttackMove(), canAttackUnit()
  - canAttack
```
public boolean canAttack(Unit target,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType,
                         boolean checkCommandibility)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(boolean checkCommandibilityGrouped)
```
  - canAttackGrouped
```
public boolean canAttackGrouped()
```
  - canAttackGrouped
```
public boolean canAttackGrouped(boolean checkCommandibilityGrouped,
                                boolean checkCommandibility)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Position target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType,
                                boolean checkCommandibilityGrouped)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Unit target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType,
                                boolean checkCommandibilityGrouped)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Position target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Unit target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Position target,
                                boolean checkCanTargetUnit)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Unit target,
                                boolean checkCanTargetUnit)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Position target)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Unit target)
```
  - canAttackGrouped
```
public boolean canAttackGrouped(Position target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType,
                                boolean checkCommandibilityGrouped,
                                boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an attack command to attack-move or attack a unit, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canAttack()
  - canAttackGrouped
```
public boolean canAttackGrouped(Unit target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType,
                                boolean checkCommandibilityGrouped,
                                boolean checkCommandibility)
```
  - canAttackMove
```
public boolean canAttackMove()
```
  - canAttackMove
```
public boolean canAttackMove(boolean checkCommandibility)
```
    Checks whether the unit is able to execute an attack command to attack-move.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), attack(bwapi.Position)
  - canAttackMoveGrouped
```
public boolean canAttackMoveGrouped(boolean checkCommandibilityGrouped)
```
  - canAttackMoveGrouped
```
public boolean canAttackMoveGrouped()
```
  - canAttackMoveGrouped
```
public boolean canAttackMoveGrouped(boolean checkCommandibilityGrouped,
                                    boolean checkCommandibility)
```
    Checks whether the unit is able to execute an attack command to attack-move, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canAttackMove()
  - canAttackUnit
```
public boolean canAttackUnit()
```
  - canAttackUnit
```
public boolean canAttackUnit(boolean checkCommandibility)
```
  - canAttackUnit
```
public boolean canAttackUnit(Unit targetUnit,
                             boolean checkCanTargetUnit,
                             boolean checkCanIssueCommandType)
```
  - canAttackUnit
```
public boolean canAttackUnit(Unit targetUnit,
                             boolean checkCanTargetUnit)
```
  - canAttackUnit
```
public boolean canAttackUnit(Unit targetUnit)
```
  - canAttackUnit
```
public boolean canAttackUnit(Unit targetUnit,
                             boolean checkCanTargetUnit,
                             boolean checkCanIssueCommandType,
                             boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an attack command to attack a unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), attack(bwapi.Position)
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(boolean checkCommandibilityGrouped)
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped()
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(boolean checkCommandibilityGrouped,
                                    boolean checkCommandibility)
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(Unit targetUnit,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType,
                                    boolean checkCommandibilityGrouped)
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(Unit targetUnit,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType)
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(Unit targetUnit,
                                    boolean checkCanTargetUnit)
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(Unit targetUnit)
```
  - canAttackUnitGrouped
```
public boolean canAttackUnitGrouped(Unit targetUnit,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandTypeGrouped,
                                    boolean checkCommandibilityGrouped,
                                    boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an attack command to attack a unit, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canAttackUnit()
  - canBuild
```
public boolean canBuild()
```
  - canBuild
```
public boolean canBuild(boolean checkCommandibility)
```
  - canBuild
```
public boolean canBuild(UnitType uType,
                        boolean checkCanIssueCommandType)
```
  - canBuild
```
public boolean canBuild(UnitType uType)
```
  - canBuild
```
public boolean canBuild(UnitType uType,
                        boolean checkCanIssueCommandType,
                        boolean checkCommandibility)
```
  - canBuild
```
public boolean canBuild(UnitType uType,
                        TilePosition tilePos,
                        boolean checkTargetUnitType,
                        boolean checkCanIssueCommandType)
```
  - canBuild
```
public boolean canBuild(UnitType uType,
                        TilePosition tilePos,
                        boolean checkTargetUnitType)
```
  - canBuild
```
public boolean canBuild(UnitType uType,
                        TilePosition tilePos)
```
  - canBuild
```
public boolean canBuild(UnitType uType,
                        TilePosition tilePos,
                        boolean checkTargetUnitType,
                        boolean checkCanIssueCommandType,
                        boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a build command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), build(bwapi.UnitType)
  - canBuildAddon
```
public boolean canBuildAddon()
```
  - canBuildAddon
```
public boolean canBuildAddon(boolean checkCommandibility)
```
  - canBuildAddon
```
public boolean canBuildAddon(UnitType uType,
                             boolean checkCanIssueCommandType)
```
  - canBuildAddon
```
public boolean canBuildAddon(UnitType uType)
```
  - canBuildAddon
```
public boolean canBuildAddon(UnitType uType,
                             boolean checkCanIssueCommandType,
                             boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a buildAddon command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), buildAddon(bwapi.UnitType)
  - canTrain
```
public boolean canTrain()
```
  - canTrain
```
public boolean canTrain(boolean checkCommandibility)
```
  - canTrain
```
public boolean canTrain(UnitType uType,
                        boolean checkCanIssueCommandType)
```
  - canTrain
```
public boolean canTrain(UnitType uType)
```
  - canTrain
```
public boolean canTrain(UnitType uType,
                        boolean checkCanIssueCommandType,
                        boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a train command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), train(bwapi.UnitType)
  - canMorph
```
public boolean canMorph()
```
  - canMorph
```
public boolean canMorph(boolean checkCommandibility)
```
  - canMorph
```
public boolean canMorph(UnitType uType,
                        boolean checkCanIssueCommandType)
```
  - canMorph
```
public boolean canMorph(UnitType uType)
```
  - canMorph
```
public boolean canMorph(UnitType uType,
                        boolean checkCanIssueCommandType,
                        boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a morph command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), morph(bwapi.UnitType)
  - canResearch
```
public boolean canResearch()
```
  - canResearch
```
public boolean canResearch(boolean checkCommandibility)
```
  - canResearch
```
public boolean canResearch(TechType type)
```
  - canResearch
```
public boolean canResearch(TechType type,
                           boolean checkCanIssueCommandType)
```
    Cheap checks for whether the unit is able to execute a research command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), research(bwapi.TechType)
  - canUpgrade
```
public boolean canUpgrade()
```
  - canUpgrade
```
public boolean canUpgrade(boolean checkCommandibility)
```
  - canUpgrade
```
public boolean canUpgrade(UpgradeType type)
```
  - canUpgrade
```
public boolean canUpgrade(UpgradeType type,
                          boolean checkCanIssueCommandType)
```
    Cheap checks for whether the unit is able to execute an upgrade command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), upgrade(bwapi.UpgradeType)
  - canSetRallyPoint
```
public boolean canSetRallyPoint()
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(boolean checkCommandibility)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Position target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Unit target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Position target,
                                boolean checkCanTargetUnit)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Unit target,
                                boolean checkCanTargetUnit)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Position target)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Unit target)
```
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Position target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType,
                                boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a setRallyPoint command to a position or unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), setRallyPoint(bwapi.Position), canSetRallyPosition(), canSetRallyUnit()
  - canSetRallyPoint
```
public boolean canSetRallyPoint(Unit target,
                                boolean checkCanTargetUnit,
                                boolean checkCanIssueCommandType,
                                boolean checkCommandibility)
```
  - canSetRallyPosition
```
public boolean canSetRallyPosition()
```
  - canSetRallyPosition
```
public boolean canSetRallyPosition(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a setRallyPoint command to a position.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), setRallyPoint(bwapi.Position)
  - canSetRallyUnit
```
public boolean canSetRallyUnit()
```
  - canSetRallyUnit
```
public boolean canSetRallyUnit(boolean checkCommandibility)
```
  - canSetRallyUnit
```
public boolean canSetRallyUnit(Unit targetUnit,
                               boolean checkCanTargetUnit,
                               boolean checkCanIssueCommandType)
```
  - canSetRallyUnit
```
public boolean canSetRallyUnit(Unit targetUnit,
                               boolean checkCanTargetUnit)
```
  - canSetRallyUnit
```
public boolean canSetRallyUnit(Unit targetUnit)
```
  - canSetRallyUnit
```
public boolean canSetRallyUnit(Unit targetUnit,
                               boolean checkCanTargetUnit,
                               boolean checkCanIssueCommandType,
                               boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a setRallyPoint command to a unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), setRallyPoint(bwapi.Position)
  - canMove
```
public boolean canMove()
```
  - canMove
```
public boolean canMove(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a move command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), move(bwapi.Position)
  - canMoveGrouped
```
public boolean canMoveGrouped(boolean checkCommandibilityGrouped)
```
  - canMoveGrouped
```
public boolean canMoveGrouped()
```
  - canMoveGrouped
```
public boolean canMoveGrouped(boolean checkCommandibilityGrouped,
                              boolean checkCommandibility)
```
    Checks whether the unit is able to execute a move command, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canMove()
  - canPatrol
```
public boolean canPatrol()
```
  - canPatrol
```
public boolean canPatrol(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a patrol command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), patrol(bwapi.Position)
  - canPatrolGrouped
```
public boolean canPatrolGrouped(boolean checkCommandibilityGrouped)
```
  - canPatrolGrouped
```
public boolean canPatrolGrouped()
```
  - canPatrolGrouped
```
public boolean canPatrolGrouped(boolean checkCommandibilityGrouped,
                                boolean checkCommandibility)
```
    Checks whether the unit is able to execute a patrol command, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canPatrol()
  - canFollow
```
public boolean canFollow()
```
  - canFollow
```
public boolean canFollow(boolean checkCommandibility)
```
  - canFollow
```
public boolean canFollow(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType)
```
  - canFollow
```
public boolean canFollow(Unit targetUnit,
                         boolean checkCanTargetUnit)
```
  - canFollow
```
public boolean canFollow(Unit targetUnit)
```
  - canFollow
```
public boolean canFollow(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType,
                         boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a follow command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), follow(bwapi.Unit)
  - canGather
```
public boolean canGather()
```
  - canGather
```
public boolean canGather(boolean checkCommandibility)
```
  - canGather
```
public boolean canGather(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType)
```
  - canGather
```
public boolean canGather(Unit targetUnit,
                         boolean checkCanTargetUnit)
```
  - canGather
```
public boolean canGather(Unit targetUnit)
```
  - canGather
```
public boolean canGather(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType,
                         boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a gather command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), gather(bwapi.Unit)
  - canReturnCargo
```
public boolean canReturnCargo()
```
  - canReturnCargo
```
public boolean canReturnCargo(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a returnCargo command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), returnCargo()
  - canHoldPosition
```
public boolean canHoldPosition()
```
  - canHoldPosition
```
public boolean canHoldPosition(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a holdPosition command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), holdPosition()
  - canStop
```
public boolean canStop()
```
  - canStop
```
public boolean canStop(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a stop command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), stop()
  - canRepair
```
public boolean canRepair()
```
  - canRepair
```
public boolean canRepair(boolean checkCommandibility)
```
  - canRepair
```
public boolean canRepair(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType)
```
  - canRepair
```
public boolean canRepair(Unit targetUnit,
                         boolean checkCanTargetUnit)
```
  - canRepair
```
public boolean canRepair(Unit targetUnit)
```
  - canRepair
```
public boolean canRepair(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkCanIssueCommandType,
                         boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a repair command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), repair(bwapi.Unit)
  - canBurrow
```
public boolean canBurrow()
```
  - canBurrow
```
public boolean canBurrow(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a burrow command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), burrow()
  - canUnburrow
```
public boolean canUnburrow()
```
  - canUnburrow
```
public boolean canUnburrow(boolean checkCommandibility)
```
    Checks whether the unit is able to execute an unburrow command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unburrow()
  - canCloak
```
public boolean canCloak()
```
  - canCloak
```
public boolean canCloak(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cloak command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cloak()
  - canDecloak
```
public boolean canDecloak()
```
  - canDecloak
```
public boolean canDecloak(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a decloak command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), decloak()
  - canSiege
```
public boolean canSiege()
```
  - canSiege
```
public boolean canSiege(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a siege command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), siege()
  - canUnsiege
```
public boolean canUnsiege()
```
  - canUnsiege
```
public boolean canUnsiege(boolean checkCommandibility)
```
    Checks whether the unit is able to execute an unsiege command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unsiege()
  - canLift
```
public boolean canLift()
```
  - canLift
```
public boolean canLift(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a lift command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), lift()
  - canLand
```
public boolean canLand()
```
  - canLand
```
public boolean canLand(boolean checkCommandibility)
```
  - canLand
```
public boolean canLand(TilePosition target,
                       boolean checkCanIssueCommandType)
```
  - canLand
```
public boolean canLand(TilePosition target)
```
  - canLand
```
public boolean canLand(TilePosition target,
                       boolean checkCanIssueCommandType,
                       boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a land command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), land(bwapi.TilePosition)
  - canLoad
```
public boolean canLoad()
```
  - canLoad
```
public boolean canLoad(boolean checkCommandibility)
```
  - canLoad
```
public boolean canLoad(Unit targetUnit,
                       boolean checkCanTargetUnit,
                       boolean checkCanIssueCommandType)
```
  - canLoad
```
public boolean canLoad(Unit targetUnit,
                       boolean checkCanTargetUnit)
```
  - canLoad
```
public boolean canLoad(Unit targetUnit)
```
  - canLoad
```
public boolean canLoad(Unit targetUnit,
                       boolean checkCanTargetUnit,
                       boolean checkCanIssueCommandType,
                       boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a load command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), load(bwapi.Unit)
  - canUnloadWithOrWithoutTarget
```
public boolean canUnloadWithOrWithoutTarget()
```
  - canUnloadWithOrWithoutTarget
```
public boolean canUnloadWithOrWithoutTarget(boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an unload command or unloadAll at current position command or unloadAll at a different position command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unload(bwapi.Unit), unloadAll()
  - canUnloadAtPosition
```
public boolean canUnloadAtPosition(Position targDropPos,
                                   boolean checkCanIssueCommandType)
```
  - canUnloadAtPosition
```
public boolean canUnloadAtPosition(Position targDropPos)
```
  - canUnloadAtPosition
```
public boolean canUnloadAtPosition(Position targDropPos,
                                   boolean checkCanIssueCommandType,
                                   boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an unload command or unloadAll at current position command or unloadAll at a different position command, for a given position.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unload(bwapi.Unit), unloadAll()
  - canUnload
```
public boolean canUnload()
```
  - canUnload
```
public boolean canUnload(boolean checkCommandibility)
```
  - canUnload
```
public boolean canUnload(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkPosition,
                         boolean checkCanIssueCommandType)
```
  - canUnload
```
public boolean canUnload(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkPosition)
```
  - canUnload
```
public boolean canUnload(Unit targetUnit,
                         boolean checkCanTargetUnit)
```
  - canUnload
```
public boolean canUnload(Unit targetUnit)
```
  - canUnload
```
public boolean canUnload(Unit targetUnit,
                         boolean checkCanTargetUnit,
                         boolean checkPosition,
                         boolean checkCanIssueCommandType,
                         boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an unload command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unload(bwapi.Unit)
  - canUnloadAll
```
public boolean canUnloadAll()
```
  - canUnloadAll
```
public boolean canUnloadAll(boolean checkCommandibility)
```
    Checks whether the unit is able to execute an unloadAll command for the current position.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unloadAll()
  - canUnloadAllPosition
```
public boolean canUnloadAllPosition()
```
  - canUnloadAllPosition
```
public boolean canUnloadAllPosition(boolean checkCommandibility)
```
  - canUnloadAllPosition
```
public boolean canUnloadAllPosition(Position targDropPos,
                                    boolean checkCanIssueCommandType)
```
  - canUnloadAllPosition
```
public boolean canUnloadAllPosition(Position targDropPos)
```
  - canUnloadAllPosition
```
public boolean canUnloadAllPosition(Position targDropPos,
                                    boolean checkCanIssueCommandType,
                                    boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute an unloadAll command for a different position.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), unloadAll()
  - canRightClick
```
public boolean canRightClick()
```
  - canRightClick
```
public boolean canRightClick(boolean checkCommandibility)
```
  - canRightClick
```
public boolean canRightClick(Position target,
                             boolean checkCanTargetUnit,
                             boolean checkCanIssueCommandType)
```
  - canRightClick
```
public boolean canRightClick(Unit target,
                             boolean checkCanTargetUnit,
                             boolean checkCanIssueCommandType)
```
  - canRightClick
```
public boolean canRightClick(Position target,
                             boolean checkCanTargetUnit)
```
  - canRightClick
```
public boolean canRightClick(Unit target,
                             boolean checkCanTargetUnit)
```
  - canRightClick
```
public boolean canRightClick(Position target)
```
  - canRightClick
```
public boolean canRightClick(Unit target)
```
  - canRightClick
```
public boolean canRightClick(Position target,
                             boolean checkCanTargetUnit,
                             boolean checkCanIssueCommandType,
                             boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a rightClick command to a position or unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), rightClick(bwapi.Position), canRightClickPosition(), canRightClickUnit()
  - canRightClick
```
public boolean canRightClick(Unit target,
                             boolean checkCanTargetUnit,
                             boolean checkCanIssueCommandType,
                             boolean checkCommandibility)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(boolean checkCommandibilityGrouped)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped()
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(boolean checkCommandibilityGrouped,
                                    boolean checkCommandibility)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Position target,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType,
                                    boolean checkCommandibilityGrouped)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Unit target,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType,
                                    boolean checkCommandibilityGrouped)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Position target,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Unit target,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Position target,
                                    boolean checkCanTargetUnit)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Unit target,
                                    boolean checkCanTargetUnit)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Position target)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Unit target)
```
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Position target,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandType,
                                    boolean checkCommandibilityGrouped,
                                    boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a rightClick command to a position or unit, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canRightClickUnit()
  - canRightClickGrouped
```
public boolean canRightClickGrouped(Unit target,
                                    boolean checkCanTargetUnit,
                                    boolean checkCanIssueCommandTypeGrouped,
                                    boolean checkCommandibilityGrouped,
                                    boolean checkCommandibility)
```
  - canRightClickPosition
```
public boolean canRightClickPosition()
```
  - canRightClickPosition
```
public boolean canRightClickPosition(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a rightClick command for a position.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), rightClick(bwapi.Position)
  - canRightClickPositionGrouped
```
public boolean canRightClickPositionGrouped(boolean checkCommandibilityGrouped)
```
  - canRightClickPositionGrouped
```
public boolean canRightClickPositionGrouped()
```
  - canRightClickPositionGrouped
```
public boolean canRightClickPositionGrouped(boolean checkCommandibilityGrouped,
                                            boolean checkCommandibility)
```
    Checks whether the unit is able to execute a rightClick command for a position, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canRightClick()
  - canRightClickUnit
```
public boolean canRightClickUnit()
```
  - canRightClickUnit
```
public boolean canRightClickUnit(boolean checkCommandibility)
```
  - canRightClickUnit
```
public boolean canRightClickUnit(Unit targetUnit,
                                 boolean checkCanTargetUnit,
                                 boolean checkCanIssueCommandType)
```
  - canRightClickUnit
```
public boolean canRightClickUnit(Unit targetUnit,
                                 boolean checkCanTargetUnit)
```
  - canRightClickUnit
```
public boolean canRightClickUnit(Unit targetUnit)
```
  - canRightClickUnit
```
public boolean canRightClickUnit(Unit targetUnit,
                                 boolean checkCanTargetUnit,
                                 boolean checkCanIssueCommandType,
                                 boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a rightClick command to a unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), rightClick(bwapi.Position)
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(boolean checkCommandibilityGrouped)
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped()
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(boolean checkCommandibilityGrouped,
                                        boolean checkCommandibility)
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(Unit targetUnit,
                                        boolean checkCanTargetUnit,
                                        boolean checkCanIssueCommandType,
                                        boolean checkCommandibilityGrouped)
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(Unit targetUnit,
                                        boolean checkCanTargetUnit,
                                        boolean checkCanIssueCommandType)
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(Unit targetUnit,
                                        boolean checkCanTargetUnit)
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(Unit targetUnit)
```
  - canRightClickUnitGrouped
```
public boolean canRightClickUnitGrouped(Unit targetUnit,
                                        boolean checkCanTargetUnit,
                                        boolean checkCanIssueCommandType,
                                        boolean checkCommandibilityGrouped,
                                        boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a rightClick command to a unit, as part of a List.
    
    See Also:
    
    canIssueCommandGrouped(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), canRightClickUnit()
  - canHaltConstruction
```
public boolean canHaltConstruction()
```
  - canHaltConstruction
```
public boolean canHaltConstruction(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a haltConstruction command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), haltConstruction()
  - canCancelConstruction
```
public boolean canCancelConstruction()
```
  - canCancelConstruction
```
public boolean canCancelConstruction(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cancelConstruction command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelConstruction()
  - canCancelAddon
```
public boolean canCancelAddon()
```
  - canCancelAddon
```
public boolean canCancelAddon(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cancelAddon command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelAddon()
  - canCancelTrain
```
public boolean canCancelTrain()
```
  - canCancelTrain
```
public boolean canCancelTrain(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cancelTrain command for any slot.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelTrain()
  - canCancelTrainSlot
```
public boolean canCancelTrainSlot()
```
  - canCancelTrainSlot
```
public boolean canCancelTrainSlot(boolean checkCommandibility)
```
  - canCancelTrainSlot
```
public boolean canCancelTrainSlot(int slot,
                                  boolean checkCanIssueCommandType)
```
  - canCancelTrainSlot
```
public boolean canCancelTrainSlot(int slot)
```
  - canCancelTrainSlot
```
public boolean canCancelTrainSlot(int slot,
                                  boolean checkCanIssueCommandType,
                                  boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a cancelTrain command for an unspecified slot.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelTrain()
  - canCancelMorph
```
public boolean canCancelMorph()
```
  - canCancelMorph
```
public boolean canCancelMorph(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cancelMorph command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelMorph()
  - canCancelResearch
```
public boolean canCancelResearch()
```
  - canCancelResearch
```
public boolean canCancelResearch(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cancelResearch command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelResearch()
  - canCancelUpgrade
```
public boolean canCancelUpgrade()
```
  - canCancelUpgrade
```
public boolean canCancelUpgrade(boolean checkCommandibility)
```
    Checks whether the unit is able to execute a cancelUpgrade command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), cancelUpgrade()
  - canUseTechWithOrWithoutTarget
```
public boolean canUseTechWithOrWithoutTarget()
```
  - canUseTechWithOrWithoutTarget
```
public boolean canUseTechWithOrWithoutTarget(boolean checkCommandibility)
```
  - canUseTechWithOrWithoutTarget
```
public boolean canUseTechWithOrWithoutTarget(TechType tech,
                                             boolean checkCanIssueCommandType)
```
  - canUseTechWithOrWithoutTarget
```
public boolean canUseTechWithOrWithoutTarget(TechType tech)
```
  - canUseTechWithOrWithoutTarget
```
public boolean canUseTechWithOrWithoutTarget(TechType tech,
                                             boolean checkCanIssueCommandType,
                                             boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a useTech command without a target or or a useTech command with a target position or a useTech command with a target unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), useTech(bwapi.TechType)
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Position target,
                          boolean checkCanTargetUnit,
                          boolean checkTargetsType,
                          boolean checkCanIssueCommandType)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Unit target,
                          boolean checkCanTargetUnit,
                          boolean checkTargetsType,
                          boolean checkCanIssueCommandType)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Position target,
                          boolean checkCanTargetUnit,
                          boolean checkTargetsType)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Unit target,
                          boolean checkCanTargetUnit,
                          boolean checkTargetsType)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Position target,
                          boolean checkCanTargetUnit)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Unit target,
                          boolean checkCanTargetUnit)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Position target)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Unit target)
```
  - canUseTech
```
public boolean canUseTech(TechType tech)
```
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Position target,
                          boolean checkCanTargetUnit,
                          boolean checkTargetsType,
                          boolean checkCanIssueCommandType,
                          boolean checkCommandibility)
```
    Checks whether the unit is able to execute a useTech command for a specified position or unit (only specify null if the TechType does not target another position/unit).
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), useTech(bwapi.TechType), canUseTechWithoutTarget(bwapi.TechType, boolean), canUseTechUnit(bwapi.TechType, boolean), canUseTechPosition(bwapi.TechType, boolean)
  - canUseTech
```
public boolean canUseTech(TechType tech,
                          Unit target,
                          boolean checkCanTargetUnit,
                          boolean checkTargetsType,
                          boolean checkCanIssueCommandType,
                          boolean checkCommandibility)
```
  - canUseTechWithoutTarget
```
public boolean canUseTechWithoutTarget(TechType tech,
                                       boolean checkCanIssueCommandType)
```
  - canUseTechWithoutTarget
```
public boolean canUseTechWithoutTarget(TechType tech)
```
  - canUseTechWithoutTarget
```
public boolean canUseTechWithoutTarget(TechType tech,
                                       boolean checkCanIssueCommandType,
                                       boolean checkCommandibility)
```
    Checks whether the unit is able to execute a useTech command without a target.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), useTech(bwapi.TechType)
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              boolean checkCanIssueCommandType)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              boolean checkCanIssueCommandType,
                              boolean checkCommandibility)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              Unit targetUnit,
                              boolean checkCanTargetUnit,
                              boolean checkTargetsUnits,
                              boolean checkCanIssueCommandType)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              Unit targetUnit,
                              boolean checkCanTargetUnit,
                              boolean checkTargetsUnits)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              Unit targetUnit,
                              boolean checkCanTargetUnit)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              Unit targetUnit)
```
  - canUseTechUnit
```
public boolean canUseTechUnit(TechType tech,
                              Unit targetUnit,
                              boolean checkCanTargetUnit,
                              boolean checkTargetsUnits,
                              boolean checkCanIssueCommandType,
                              boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a useTech command with an unspecified target unit.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), useTech(bwapi.TechType)
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech,
                                  boolean checkCanIssueCommandType)
```
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech)
```
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech,
                                  boolean checkCanIssueCommandType,
                                  boolean checkCommandibility)
```
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech,
                                  Position target,
                                  boolean checkTargetsPositions,
                                  boolean checkCanIssueCommandType)
```
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech,
                                  Position target,
                                  boolean checkTargetsPositions)
```
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech,
                                  Position target)
```
  - canUseTechPosition
```
public boolean canUseTechPosition(TechType tech,
                                  Position target,
                                  boolean checkTargetsPositions,
                                  boolean checkCanIssueCommandType,
                                  boolean checkCommandibility)
```
    Checks whether the unit is able to execute a useTech command with an unspecified target position.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), useTech(bwapi.TechType)
  - canPlaceCOP
```
public boolean canPlaceCOP()
```
  - canPlaceCOP
```
public boolean canPlaceCOP(boolean checkCommandibility)
```
  - canPlaceCOP
```
public boolean canPlaceCOP(TilePosition target,
                           boolean checkCanIssueCommandType)
```
  - canPlaceCOP
```
public boolean canPlaceCOP(TilePosition target)
```
  - canPlaceCOP
```
public boolean canPlaceCOP(TilePosition target,
                           boolean checkCanIssueCommandType,
                           boolean checkCommandibility)
```
    Cheap checks for whether the unit is able to execute a placeCOP command.
    
    See Also:
    
    canIssueCommand(bwapi.UnitCommand, boolean, boolean, boolean, boolean, boolean), placeCOP(bwapi.TilePosition)
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - compareTo
```
public int compareTo(Unit other)
```
    Specified by:
    
    compareTo in interface Comparable<Unit>

Class Unit

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getID

exists

getReplayID

getPlayer

getType

getPosition

getX

getY

getTilePosition

getAngle

getVelocityX

getVelocityY

getRegion

getLeft

getTop

getRight

getBottom

getHitPoints

getShields

getEnergy

getResources

getResourceGroup

getDistance

getDistance

hasPath

hasPath

getLastCommandFrame

getLastCommand

getLastAttackingPlayer

getInitialType

getInitialPosition

getInitialTilePosition

getInitialHitPoints

getInitialResources

getKillCount

getAcidSporeCount

getInterceptorCount

getScarabCount

getSpiderMineCount

getGroundWeaponCooldown

getAirWeaponCooldown

getSpellCooldown

getDefenseMatrixPoints

getDefenseMatrixTimer

getEnsnareTimer

getIrradiateTimer

getLockdownTimer

getMaelstromTimer

getOrderTimer

getPlagueTimer

getRemoveTimer

getStasisTimer

getStimTimer

getBuildType

getTrainingQueue

getTrainingQueueAt

getTrainingQueueCount

getTech

getUpgrade

getRemainingBuildTime

getRemainingTrainTime

getRemainingResearchTime

getRemainingUpgradeTime

getBuildUnit

getTarget

getTargetPosition

getOrder

getSecondaryOrder

getOrderTarget

getOrderTargetPosition

getRallyPosition

getRallyUnit

getAddon

getNydusExit

getPowerUp

getTransport