private static void archonMicro(RobotController rc, RobotInfo enemyArchon)
throws GameActionException {
if (rc.isCoreReady()) {
int dist = myLoc.distanceSquaredTo(enemyArchon.location);
// When not adjacent to the archon, walk/mine through to him.
if (dist > 2) {
Direction desired = myLoc.directionTo(enemyArchon.location);
Direction dir = Movement.getBestMoveableDirection(desired, rc, 2);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
// When adjacent to archon, rotate to the left/right when possible.
else {
Direction dir = myLoc.directionTo(enemyArchon.location);
if (rc.canMove(dir.rotateLeft())) {
rc.move(dir.rotateLeft());
} else if (rc.canMove(dir.rotateRight())) {
rc.move(dir.rotateRight());
}
}
}
if (rc.isWeaponReady()) {
if (rc.canAttackLocation(enemyArchon.location)) {
rc.attackLocation(enemyArchon.location);
}
}
}
private void tryClearRubble(Direction direction) throws GameActionException {
MapLocation nextLocation = rc.getLocation().add(direction);
double rubble = rc.senseRubble(nextLocation);
if (rubble > 100) {
rc.clearRubble(direction);
}
}
// move to a maplocation
public static void moveToLocation(MapLocation m) throws GameActionException {
MapLocation currentLoc = rc.getLocation();
Direction directionToM = currentLoc.directionTo(m);
Direction actualDirectionToMove = directionToM;
// deal with the slug trail - trim it to size
if (past10Locations.size() > 10) {
while (past10Locations.size() > 10) {
past10Locations.remove(past10Locations.size() - 1);
}
}
past10Locations.add(currentLoc);
MapLocation locationToMoveTo = currentLoc.add(directionToM);
if (canMoveThere(
actualDirectionToMove,
locationToMoveTo)) // make sure it's not part of the slug trail and it's not blocked by
// rubble and you can move there
{
moveInDirection(actualDirectionToMove);
} else {
// first, check if you should remove rubble. only if the surrounding squares are empty
// boolean shouldRemoveRubble = false;
int directionsWithRubble = 0;
for (Direction d : Direction.values()) {
MapLocation added = goal.add(d);
boolean isFullOfRubble = rc.senseRubble(added) > 50;
if (isFullOfRubble) {
directionsWithRubble++;
}
}
if (directionsWithRubble > 2) // if it's surrounded then dig
{
if (rc.isCoreReady()) {
if (actualDirectionToMove.equals(Direction.OMNI) == false) {
rc.clearRubble(actualDirectionToMove);
}
}
} else // if not, path around it
{
Direction right = actualDirectionToMove.rotateRight();
MapLocation rightLoc = currentLoc.add(right);
while (right.equals(actualDirectionToMove) == false) {
if (canMoveThere(right, rightLoc)) {
moveInDirection(right);
right = actualDirectionToMove;
} else {
right = right.rotateRight();
rightLoc = currentLoc.add(right);
}
}
}
}
}
public static void clear_rubble() throws GameActionException {
if (!rc.isCoreReady()) return;
if (Scanner.can_see_targets()) return;
if (Scanner.there_is_hidden_enemy()) return;
Direction direction_to_clear = current_location.directionTo(destination);
if (direction_to_clear == Direction.NONE || direction_to_clear == Direction.OMNI) return;
if (rc.senseRubble(current_location.add(direction_to_clear)) < 1) return;
rc.clearRubble(direction_to_clear);
rc.setIndicatorString(1, "Clearing: " + direction_to_clear.toString());
}
protected void tryMoveToward(MapLocation location) throws GameActionException {
MapLocation currentLocation = rc.getLocation();
Direction moveDirection = currentLocation.directionTo(location);
if (location.isAdjacentTo(currentLocation)) {
double rubble = rc.senseRubble(location);
if (rubble >= 100) {
rc.clearRubble(moveDirection);
return;
}
}
tryMove(moveDirection);
}
// move in a given direction
public static void moveInDirection(Direction d) throws GameActionException {
MapLocation m = rc.getLocation().add(d);
if (rc.senseRubble(m) < tooMuchRubble
|| Math.random() < probClearRubbleAnyways) // if it's less than 20, just move there
{
if (rc.isCoreReady() && rc.canMove(d)) {
rc.move(d);
}
} else // clear it
{
if (rc.isCoreReady()) {
rc.clearRubble(d);
}
}
}
/**
* Finds adjacent with lowest rubble (greater than 0) and clears it.
*
* @param rc
* @return
* @throws GameActionException
*/
private static void clearRubble(RobotController rc) throws GameActionException {
MapLocation myLocation = rc.getLocation();
MapLocation[] adjacentLocations =
MapLocation.getAllMapLocationsWithinRadiusSq(myLocation, ONE_SQUARE_RADIUS);
int lowestRubbleIndex = -1;
for (int i = 0; i < adjacentLocations.length; i++) {
double rubble = rc.senseRubble(adjacentLocations[i]);
if (lowestRubbleIndex == -1) {
lowestRubbleIndex = rubble > 0 ? i : lowestRubbleIndex;
} else {
lowestRubbleIndex =
rubble > 0 && rubble < rc.senseRubble(adjacentLocations[lowestRubbleIndex])
? i
: lowestRubbleIndex;
}
}
if (lowestRubbleIndex >= 0) {
Direction dir = myLocation.directionTo(adjacentLocations[lowestRubbleIndex]);
if (rc.isCoreReady() && !dir.equals(Direction.OMNI) && !dir.equals(Direction.NONE)) {
rc.clearRubble(dir);
}
}
}
public static void forwardishIfProtection(Direction movingDirection2) throws GameActionException {
boolean stationArchon = RobotPlayer.stationArchon;
// boolean tempRoamingArchon = RobotPlayer.tempRoamingArchon;
if (stationArchon) return; // or do other stuff
int id = RobotPlayer.id;
// System.out.println(Integer.toString(id));
// int waitTurns = 1;
RobotController rc = RobotPlayer.rc;
int waitTurns = rc.getType() == RobotType.ARCHON ? 1 : 1;
// if(rc.getRoundNum()%waitTurns ==0){// leader let the soldiers catch up
if (true) {
for (int i : possibleDirections) {
Direction candidateDirection = Direction.values()[(movingDirection2.ordinal() + i + 8) % 8];
MapLocation candidateLocation =
rc.getLocation().add(candidateDirection.dx, candidateDirection.dy);
if (patient > 0) {
// if (rc.getType() == RobotType.ARCHON)
// System.out.println("should be an archon moving now");
MapLocation oldLoc = rc.getLocation();
if (rc.canMove(candidateDirection)
&& !pastLocations.contains(candidateLocation)
&& enoughProtectionAhead(candidateLocation)) {
if (!pastLocations.contains(oldLoc)) {
pastLocations.add(rc.getLocation());
}
if (pastLocations.size() > 5) pastLocations.remove(0);
rc.move(candidateDirection);
if (rc.getType() == RobotType.ARCHON && !RobotPlayer.stationArchon) {
// System.out.println("Im getting this far");
// System.out.println("I should have moved in direction: "+
// candidateDirection.toString());
}
// if (rc.getType() == RobotTypse.ARCHON)
// System.out.println("should have moved an archon new location " +
// rc.getLocation().toString()+ "old : " + oldLoc) ;
patient = Math.min(patient + 1, 30);
return;
}
} else {
if (rc.canMove(candidateDirection) && enoughProtectionAhead(candidateLocation)) {
rc.move(candidateDirection);
patient = Math.min(patient + 1, 30);
return;
} else { // dig !
if (rc.senseRubble(candidateLocation) > GameConstants.RUBBLE_OBSTRUCTION_THRESH) {
rc.clearRubble(candidateDirection);
return;
}
}
}
}
patient = patient - 5;
}
}
private static void rushMicro(RobotController rc, RobotInfo[] hostiles)
throws GameActionException {
// Prioritizes attacking turrets.
RobotInfo bestEnemy = null;
boolean canAttackBestEnemy = false;
int bestEnemyDist = 10000; // only care if can't hit
for (RobotInfo hostile : hostiles) {
// Can attack this enemy.
int dist = myLoc.distanceSquaredTo(hostile.location);
// Summary:
// Prioritizes enemies over zombies.
// Prioritizes turret enemies over other enemies.
// Prioritizes lowest health enemy last
if (dist <= attackRadius) {
if (bestEnemy != null) {
if (bestEnemy.team == enemyTeam) { // best is already enemy
if (hostile.team == enemyTeam) { // found an enemy
if (countsAsTurret(bestEnemy.type)) {
if (countsAsTurret(hostile.type)) {
// Take lowest health
if (bestEnemy.health > hostile.health) bestEnemy = hostile;
}
} else {
if (countsAsTurret(hostile.type)) {
bestEnemy = hostile;
} else {
// Take lowest health
if (bestEnemy.health > hostile.health) bestEnemy = hostile;
}
}
}
} else { // best is not an enemy!
if (hostile.team == enemyTeam) { // found an enemy
bestEnemy = hostile;
} else {
// Take lowest health
if (bestEnemy.health > hostile.health) bestEnemy = hostile;
}
}
} else {
bestEnemy = hostile;
}
canAttackBestEnemy = true;
} else {
// Only update best enemy if you can't attack best enemy
if (!canAttackBestEnemy) {
if (bestEnemy != null) {
// Pick the closest one
if (bestEnemyDist > dist) {
bestEnemyDist = dist;
bestEnemy = hostile;
}
} else {
bestEnemyDist = dist;
bestEnemy = hostile;
}
}
}
}
rc.setIndicatorString(0, "Round: " + rc.getRoundNum() + ", Best enemy: " + bestEnemy);
if (rc.isCoreReady()) {
// If there is a best enemy, attack him.
if (bestEnemy != null) {
// Move closer only if blocking someone.
if (rc.canAttackLocation(bestEnemy.location)) {
if (isBlockingSomeone(rc, bestEnemy.location)) {
Direction desired = myLoc.directionTo(bestEnemy.location);
Direction dir = Movement.getBestMoveableDirection(desired, rc, 2);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
}
// If can't attack it, move closer!
else {
Direction desired = myLoc.directionTo(bestEnemy.location);
Direction dir = Movement.getBestMoveableDirection(desired, rc, 2);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(dir.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
}
// Otherwise move closer to destination
else {
if (currentDestination != null) {
RobotInfo info = null;
if (rc.canSenseLocation(currentDestination)) {
info = rc.senseRobotAtLocation(currentDestination);
}
if (info != null) {
// If can attack it, just only move closer if blocking someone behind.
if (rc.canAttackLocation(info.location)) {
if (isBlockingSomeone(rc, currentDestination)) {
Direction desired = myLoc.directionTo(currentDestination);
Direction dir = Movement.getBestMoveableDirection(desired, rc, 2);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
}
// If can't attack it, move closer!
else {
Direction desired = myLoc.directionTo(currentDestination);
Direction dir = Movement.getBestMoveableDirection(desired, rc, 2);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
}
// If not there, just move closer.
else {
Direction desired = myLoc.directionTo(currentDestination);
Direction dir = Movement.getBestMoveableDirection(desired, rc, 2);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
}
}
}
// Attack whenever you can.
if (bestEnemy != null) {
if (rc.isWeaponReady()) {
if (rc.canAttackLocation(bestEnemy.location)) {
broadcastingAttack(rc, bestEnemy);
}
}
}
}
public static void zombieMicro(RobotController rc) throws GameActionException {
boolean thereIsNonKitableZombie = false;
RobotInfo closestEnemy = null;
int closestDist = 10000;
for (RobotInfo hostile : nearbyEnemies) {
if (hostile.type == RobotType.FASTZOMBIE || hostile.type == RobotType.RANGEDZOMBIE) {
thereIsNonKitableZombie = true;
}
int dist = myLoc.distanceSquaredTo(hostile.location);
if (dist < closestDist) {
closestDist = dist;
closestEnemy = hostile;
}
}
Direction d = myLoc.directionTo(closestEnemy.location);
// if we're too close, move further away
if (myLoc.distanceSquaredTo(closestEnemy.location) < 5 && rc.isCoreReady()) {
Direction desired = d.opposite();
Direction dir = Movement.getBestMoveableDirection(desired, rc, 1);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
if (!thereIsNonKitableZombie) {
// Only move in closer if there is no non-kitable zombie
if (myLoc.distanceSquaredTo(closestEnemy.location) > attackRadius
&& rc.isCoreReady()) { // if we are too far, we want to move closer
// Desired direction is d.
Direction dir = Movement.getBestMoveableDirection(d, rc, 1);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, d)) {
rc.clearRubble(d);
} else if (shouldMine(rc, d.rotateLeft())) {
rc.clearRubble(d.rotateLeft());
} else if (shouldMine(rc, d.rotateRight())) {
rc.clearRubble(d.rotateRight());
} else { // probably meaning you are blocked by allies
if (closestEnemy.type == RobotType.ZOMBIEDEN) {
// It is likely that we wanted to go to that den, but possibly coincidence
// If not a coincidence, bug there.
if (bugging != null) {
if (bugging.destination.equals(closestEnemy.location)) {
bugging.turretAvoidMove(turretLocations);
// If coincidence, set new bugging.
} else {
bugging = new Bugging(rc, closestEnemy.location);
bugging.turretAvoidMove(turretLocations);
}
} else {
bugging = new Bugging(rc, closestEnemy.location);
bugging.turretAvoidMove(turretLocations);
}
}
}
}
}
if (rc.isWeaponReady() && rc.canAttackLocation(closestEnemy.location)) {
broadcastingAttack(rc, closestEnemy);
}
}
private static void luringMicro(RobotController rc) throws GameActionException {
boolean thereIsNonKitableZombie = false;
RobotInfo closestEnemy = null;
MapLocation closestOpponent = null;
int closestDist = 10000;
for (RobotInfo hostile : nearbyEnemies) {
if (hostile.type == RobotType.FASTZOMBIE || hostile.type == RobotType.RANGEDZOMBIE) {
thereIsNonKitableZombie = true;
}
int dist = myLoc.distanceSquaredTo(hostile.location);
if (dist < closestDist) {
closestDist = dist;
closestEnemy = hostile;
}
}
// try to get the closest place to lure zombie
for (MapLocation loc : turretLocations) {
if (closestOpponent == null) closestOpponent = loc;
else if (myLoc.distanceSquaredTo(loc) < myLoc.distanceSquaredTo(closestOpponent))
closestOpponent = null;
}
if (closestOpponent == null) closestOpponent = nearestEnemyLocation;
Direction d = null;
if (closestOpponent != null) d = myLoc.directionTo(closestOpponent);
else d = myLoc.directionTo(rc.getInitialArchonLocations(enemyTeam)[0]);
// if we are moving directly into the zombie, try to move to the side
Direction temp = myLoc.directionTo(closestEnemy.location);
if (d.equals(temp)) d = d.rotateLeft().rotateLeft();
else if (d.equals(temp.rotateLeft())) d = d.rotateLeft();
else if (d.equals(temp.rotateRight())) d = d.rotateRight();
// if we're too close, move further away towards the closest turret location or the closest
// enemy
if (myLoc.distanceSquaredTo(closestEnemy.location) < 10 && rc.isCoreReady()) {
Direction desired = d;
Direction dir = Movement.getBestMoveableDirection(desired, rc, 1);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, desired)) {
rc.clearRubble(desired);
} else if (shouldMine(rc, desired.rotateLeft())) {
rc.clearRubble(desired.rotateLeft());
} else if (shouldMine(rc, desired.rotateRight())) {
rc.clearRubble(desired.rotateRight());
}
}
if (!thereIsNonKitableZombie) {
// Only move in closer if there is no non-kitable zombie
if (myLoc.distanceSquaredTo(closestEnemy.location) > attackRadius
&& rc.isCoreReady()) { // if we are too far, we want to move closer
// Desired direction is d.
Direction dir = Movement.getBestMoveableDirection(d, rc, 1);
if (dir != Direction.NONE) {
rc.move(dir);
} else if (shouldMine(rc, d)) {
rc.clearRubble(d);
} else if (shouldMine(rc, d.rotateLeft())) {
rc.clearRubble(d.rotateLeft());
} else if (shouldMine(rc, d.rotateRight())) {
rc.clearRubble(d.rotateRight());
} else { // probably meaning you are blocked by allies
if (closestEnemy.type == RobotType.ZOMBIEDEN) {
// It is likely that we wanted to go to that den, but possibly coincidence
// If not a coincidence, bug there.
if (bugging != null) {
if (bugging.destination.equals(closestEnemy.location)) {
bugging.turretAvoidMove(turretLocations);
// If coincidence, set new bugging.
} else {
bugging = new Bugging(rc, closestOpponent);
bugging.turretAvoidMove(turretLocations);
}
} else {
bugging = new Bugging(rc, closestOpponent);
bugging.turretAvoidMove(turretLocations);
}
}
}
}
}
if (rc.isWeaponReady() && rc.canAttackLocation(closestEnemy.location)) {
broadcastingAttack(rc, closestEnemy);
}
}
public int bugMove(RobotController rc, MapLocation end) {
try {
MapLocation curLoc = rc.getLocation();
int dist = curLoc.distanceSquaredTo(end);
Direction dir = curLoc.directionTo(end);
for (int i = 0; i < prevDistanceN; i++) {
if (dist == prevDistanceN) {
if (rc.isCoreReady()) {
if (rc.senseRobotAtLocation(curLoc.add(dir)) == null) {
rc.clearRubble(dir);
for (int j = prevDistanceN - 1; j > 0; j--) {
prevDistance[j] = prevDistance[j - 1];
}
}
}
return dist;
}
}
for (int j = prevDistanceN - 1; j > 0; j--) {
prevDistance[j] = prevDistance[j - 1];
}
// Direction dir = start.directionTo(end);
int c = 0;
while (!rc.canMove(dir)) {
dir = dir.rotateRight();
if (c == 3) {
dir = dir.rotateRight();
c++;
}
if (c > 6) {
break;
}
c++;
}
if (c < 7) {
if (rc.isCoreReady()) {
rc.move(dir);
return dist;
}
} else {
if (rc.isCoreReady()) {
MapLocation nextLoc = curLoc.add(dir);
if (rc.onTheMap(nextLoc)) {
if (rc.senseRobotAtLocation(nextLoc) == null) {
rc.clearRubble(dir);
for (int j = prevDistanceN - 1; j > 0; j--) {
prevDistance[j] = prevDistance[j - 1];
}
}
}
}
return dist;
}
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
return 99999;
}
public static void run(RobotController rc) {
int myAttackRange = 0;
Random rand = new Random(rc.getID());
Team myTeam = rc.getTeam();
Team enemyTeam = myTeam.opponent();
try {
// Any code here gets executed exactly once at the beginning of the game.
myAttackRange = rc.getType().attackRadiusSquared;
} catch (Exception e) {
// Throwing an uncaught exception makes the robot die, so we need to catch exceptions.
// Caught exceptions will result in a bytecode penalty.
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
int fate = rand.nextInt(1000);
if (fate % 5 == 3) {
// Send a normal signal
rc.broadcastSignal(80);
}
boolean shouldAttack = false;
// If this robot type can attack, check for enemies within range and attack one
if (myAttackRange > 0) {
RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(myAttackRange, enemyTeam);
RobotInfo[] zombiesWithinRange = rc.senseNearbyRobots(myAttackRange, Team.ZOMBIE);
if (enemiesWithinRange.length > 0) {
shouldAttack = true;
// Check if weapon is ready
if (rc.isWeaponReady()) {
rc.attackLocation(
enemiesWithinRange[rand.nextInt(enemiesWithinRange.length)].location);
}
} else if (zombiesWithinRange.length > 0) {
shouldAttack = true;
// Check if weapon is ready
if (rc.isWeaponReady()) {
rc.attackLocation(
zombiesWithinRange[rand.nextInt(zombiesWithinRange.length)].location);
}
}
}
if (!shouldAttack) {
if (rc.isCoreReady()) {
if (fate < 600) {
// Choose a random direction to try to move in
Direction dirToMove = RobotPlayer.directions[fate % 8];
// Check the rubble in that direction
if (rc.senseRubble(rc.getLocation().add(dirToMove))
>= GameConstants.RUBBLE_OBSTRUCTION_THRESH) {
// Too much rubble, so I should clear it
rc.clearRubble(dirToMove);
// Check if I can move in this direction
} else if (rc.canMove(dirToMove)) {
// Move
rc.move(dirToMove);
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
/**
* run() is the method that is called when a robot is instantiated in the Battlecode world. If
* this method returns, the robot dies!
*/
@SuppressWarnings("unused")
public static void run(RobotController rc) {
// You can instantiate variables here.
Direction[] directions = {
Direction.NORTH,
Direction.NORTH_EAST,
Direction.EAST,
Direction.SOUTH_EAST,
Direction.SOUTH,
Direction.SOUTH_WEST,
Direction.WEST,
Direction.NORTH_WEST
};
RobotType[] robotTypes = {
RobotType.SCOUT,
RobotType.SOLDIER,
RobotType.SOLDIER,
RobotType.SOLDIER,
RobotType.GUARD,
RobotType.GUARD,
RobotType.VIPER,
RobotType.TURRET
};
Random rand = new Random(rc.getID());
int myAttackRange = 0;
Team myTeam = rc.getTeam();
Team enemyTeam = myTeam.opponent();
if (rc.getType() == RobotType.ARCHON) {
try {
// Any code here gets executed exactly once at the beginning of the game.
} catch (Exception e) {
// Throwing an uncaught exception makes the robot die, so we need to catch exceptions.
// Caught exceptions will result in a bytecode penalty.
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
/*
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
int fate = rand.nextInt(1000);
// Check if this ARCHON's core is ready
if (fate % 10 == 2) {
// Send a message signal containing the data (6370, 6147)
rc.broadcastMessageSignal(6370, 6147, 80);
}
Signal[] signals = rc.emptySignalQueue();
if (signals.length > 0) {
// Set an indicator string that can be viewed in the client
rc.setIndicatorString(0, "I received a signal this turn!");
} else {
rc.setIndicatorString(0, "I don't any signal buddies");
}
if (rc.isCoreReady()) {
if (fate < 800) {
// Choose a random direction to try to move in
Direction dirToMove = directions[fate % 8];
// Check the rubble in that direction
if (rc.senseRubble(rc.getLocation().add(dirToMove)) >= GameConstants.RUBBLE_OBSTRUCTION_THRESH) {
// Too much rubble, so I should clear it
rc.clearRubble(dirToMove);
// Check if I can move in this direction
} else if (rc.canMove(dirToMove)) {
// Move
rc.move(dirToMove);
}
} else {
// Choose a random unit to build
RobotType typeToBuild = robotTypes[fate % 8];
// Check for sufficient parts
if (rc.hasBuildRequirements(typeToBuild)) {
// Choose a random direction to try to build in
Direction dirToBuild = directions[rand.nextInt(8)];
for (int i = 0; i < 8; i++) {
// If possible, build in this direction
if (rc.canBuild(dirToBuild, typeToBuild)) {
rc.build(dirToBuild, typeToBuild);
break;
} else {
// Rotate the direction to try
dirToBuild = dirToBuild.rotateLeft();
}
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
*/
}
} else if (rc.getType() != RobotType.TURRET) {
try {
// Any code here gets executed exactly once at the beginning of the game.
myAttackRange = rc.getType().attackRadiusSquared;
} catch (Exception e) {
// Throwing an uncaught exception makes the robot die, so we need to catch exceptions.
// Caught exceptions will result in a bytecode penalty.
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
int fate = rand.nextInt(1000);
if (fate % 5 == 3) {
// Send a normal signal
rc.broadcastSignal(80);
}
boolean shouldAttack = false;
// If this robot type can attack, check for enemies within range and attack one
if (myAttackRange > 0) {
RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(myAttackRange, enemyTeam);
RobotInfo[] zombiesWithinRange = rc.senseNearbyRobots(myAttackRange, Team.ZOMBIE);
if (enemiesWithinRange.length > 0) {
shouldAttack = true;
// Check if weapon is ready
if (rc.isWeaponReady()) {
rc.attackLocation(
enemiesWithinRange[rand.nextInt(enemiesWithinRange.length)].location);
}
} else if (zombiesWithinRange.length > 0) {
shouldAttack = true;
// Check if weapon is ready
if (rc.isWeaponReady()) {
rc.attackLocation(
zombiesWithinRange[rand.nextInt(zombiesWithinRange.length)].location);
}
}
}
if (!shouldAttack) {
if (rc.isCoreReady()) {
if (fate < 600) {
// Choose a random direction to try to move in
Direction dirToMove = directions[fate % 8];
// Check the rubble in that direction
if (rc.senseRubble(rc.getLocation().add(dirToMove))
>= GameConstants.RUBBLE_OBSTRUCTION_THRESH) {
// Too much rubble, so I should clear it
rc.clearRubble(dirToMove);
// Check if I can move in this direction
} else if (rc.canMove(dirToMove)) {
// Move
rc.move(dirToMove);
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
} else if (rc.getType() == RobotType.TURRET) {
try {
myAttackRange = rc.getType().attackRadiusSquared;
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
// If this robot type can attack, check for enemies within range and attack one
if (rc.isWeaponReady()) {
RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(myAttackRange, enemyTeam);
RobotInfo[] zombiesWithinRange = rc.senseNearbyRobots(myAttackRange, Team.ZOMBIE);
if (enemiesWithinRange.length > 0) {
for (RobotInfo enemy : enemiesWithinRange) {
// Check whether the enemy is in a valid attack range (turrets have a minimum range)
if (rc.canAttackLocation(enemy.location)) {
rc.attackLocation(enemy.location);
break;
}
}
} else if (zombiesWithinRange.length > 0) {
for (RobotInfo zombie : zombiesWithinRange) {
if (rc.canAttackLocation(zombie.location)) {
rc.attackLocation(zombie.location);
break;
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
}
