private boolean spawn() throws GameActionException {
Direction dir = rc.getLocation().directionTo(rc.senseEnemyHQLocation());
// Need to do this first so the termination check works
if (rc.canMove(dir)) {
rc.spawn(dir);
return true;
}
// Spawn as close to the desired direction as possible
Direction dirLeft = dir;
Direction dirRight = dir;
do {
dirLeft = dirLeft.rotateLeft();
if (rc.canMove(dirLeft)) {
rc.spawn(dirLeft);
return true;
}
dirRight = dirRight.rotateRight();
if (rc.canMove(dirRight)) {
rc.spawn(dirRight);
return true;
}
} while (dirRight != dirLeft);
return false;
}
private boolean isOpen(
MapLocation currentLoc,
Direction currentDir,
Direction nextDir,
Direction desDir,
boolean cw) {
if (desDir == Direction.OMNI) {
return true;
}
if (!isTraversable(currentLoc.add(currentDir))) return false;
if (cw) {
while (currentDir != nextDir) {
if (currentDir == desDir) return true;
currentDir = currentDir.rotateRight();
}
} else {
while (currentDir != nextDir) {
if (currentDir == desDir) return true;
currentDir = currentDir.rotateLeft();
}
}
return (nextDir == desDir);
}
private static void doMinerMove() {
// If there is an available adjacent tile with twice as much ore we are better off moving
Direction startDir = directions[rand.nextInt(directions.length)];
Direction d = startDir;
Direction best = Direction.NONE;
double mostOre = rc.senseOre(myLoc) * 2; // Only move if there is twice as much ore
boolean done = false;
while (!done) {
if (rc.canMove(d)) {
MapLocation adj = rc.getLocation().add(d);
double ore = rc.senseOre(adj);
if ((ore > mostOre
|| (ore == mostOre
&& ore > 0
&& adj.distanceSquaredTo(myHQ) > myLoc.distanceSquaredTo(myHQ)))
&& !threats.isThreatened(adj)) {
mostOre = rc.senseOre(adj);
best = d;
}
}
d = d.rotateRight();
done = (d == startDir);
}
if (best != Direction.NONE) {
rc.setIndicatorString(2, "Mining - better ore " + d);
try {
rc.move(best);
} catch (GameActionException e) {
System.out.println("Miner move exception");
// e.printStackTrace();
}
}
}
private MapLocation traceNext(MapLocation currentLoc, Direction faceDir, boolean cw) {
// Put isTraversable first so that the second while loop will rotate the
// direction to walkable position
// Try code reuse in the future
int step = 0;
if (cw) {
while (isTraversable(currentLoc.add(faceDir)) && step < 8) {
faceDir = faceDir.rotateRight();
step++;
}
step = 0;
while (!isTraversable(currentLoc.add(faceDir)) && step < 8) {
faceDir = faceDir.rotateLeft();
step++;
}
} else {
while (isTraversable(currentLoc.add(faceDir)) && step < 8) {
faceDir = faceDir.rotateLeft();
step++;
}
step = 0;
while (!isTraversable(currentLoc.add(faceDir)) && step < 8) {
faceDir = faceDir.rotateRight();
step++;
}
}
return currentLoc.add(faceDir);
}
private boolean moveToPath() throws GameActionException {
if (dstar == null) {
dstar = new DStar(outPath, distances, currentLocation);
}
if (!dstar.arrived(currentLocation)) {
dstar.compute(7000);
}
if (!RC.isActive()) return true;
Direction dir = Direction.NORTH, best = null;
int min = Integer.MAX_VALUE;
for (int i = 0; i < 8; i++) {
int d = RC.canMove(dir) ? dstar.getDistance(currentLocation.add(dir)) : Integer.MAX_VALUE;
if (d < min) {
min = d;
best = dir;
}
dir = dir.rotateRight();
}
if (best != null && move(best)) {
RC.setIndicatorString(1, "Moving to outPath");
return true;
} else {
return false;
}
}
private static void shootRandomly() throws GameActionException {
if (rc.getRoundNum() > 500) {
Direction trueAway = alpha.directionTo(here);
Direction away = trueAway;
MapLocation enemyLocation = here;
int count = 0;
while (count < 4 || rc.canAttackLocation(enemyLocation.add(away))) {
enemyLocation = enemyLocation.add(away);
away =
(new Direction[] {
trueAway,
trueAway.rotateLeft(),
trueAway.rotateRight(),
trueAway.rotateLeft().rotateLeft(),
trueAway.rotateRight().rotateRight()
})
[rand.nextInt(5)];
count++;
if (rc.canSenseLocation(enemyLocation) && !rc.onTheMap(enemyLocation)) {
return;
}
}
if (rc.canAttackLocation(enemyLocation)) {
rc.attackLocation(enemyLocation);
return;
}
}
}
public static void HqCommand() throws GameActionException {
if (rc.getType() == RobotType.HQ) {
// if (rc.isActive()) {
// Spawn a soldier
int[] directionOffSets = {0, 1, -1, 2, -2};
// Team mineSpawn = rc.senseMine(rc.getLocation().add(spawnDir));
Direction dir =
rc.getLocation().directionTo(rc.senseEnemyHQLocation()); // this does not work!
Direction spawnDir = dir;
// spawn robots in the direction of the enemy
if (rc.senseMine(rc.getLocation().add(dir)) != null) {
lookForDir:
for (int d : directionOffSets) {
spawnDir = Direction.values()[(dir.ordinal() + d + 8) % 8];
if (rc.canMove(spawnDir) && rc.senseMine(rc.getLocation().add(spawnDir)) != null) {
rc.spawn(Direction.SOUTH);
rc.spawn(spawnDir);
break lookForDir;
}
}
}
if (rc.canMove(dir)) {
rc.spawn(dir);
}
// }
}
}
// In this function the HQ spawns a soldier ideally toward the enemy base but in any direction
// otherwise
public static void SpawnSoldiers(RobotController rc) {
try {
if (rc.isActive() && rc.getType() == RobotType.HQ) {
Direction toEnemy = rc.getLocation().directionTo(rc.senseEnemyHQLocation());
if (rc.senseObjectAtLocation(rc.getLocation().add(toEnemy)) == null) {
} else {
for (int i = 0; i < 7; i++) {
toEnemy = toEnemy.rotateLeft();
if (rc.senseObjectAtLocation(rc.getLocation().add(toEnemy)) == null) {
i = 47;
} else if (i == 6) {
toEnemy = Direction.NONE;
}
}
}
if (toEnemy != Direction.NONE) {
if (rc.isActive()) {
if (rc.getType() == RobotType.HQ) {
rc.spawn(toEnemy);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("Utility Exception");
}
}
/**
* Attempts to build a robot of the given type in a random direction (attempts all directions).
* Only attempts building if rc has no core delay and has more parts than the threshold.
*
* @param rc RobotController from which to build
* @param buildType type of robot to build
* @return true if buildType is built else false
* @throws GameActionException
*/
private static boolean tryToBuild(RobotController rc, RobotType buildType)
throws GameActionException {
if (rc.isCoreReady()) {
Direction buildDir = getRandomDirection();
for (int i = 0; i < 8; i++) {
if (rc.canBuild(buildDir, buildType)) {
rc.build(buildDir, buildType);
rc.broadcastMessageSignal(SENDING_MODE, currentMode, ONE_SQUARE_RADIUS);
if (!turtleCorner.equals(LOCATION_NONE)) {
rc.broadcastMessageSignal(SENDING_TURTLE_X, turtleCorner.x, ONE_SQUARE_RADIUS);
rc.broadcastMessageSignal(SENDING_TURTLE_Y, turtleCorner.y, ONE_SQUARE_RADIUS);
}
if (buildType.equals(RobotType.SCOUT)) {
for (MapLocation scoutKitingLoc : SCOUT_KITING_LOCATIONS) {
rc.broadcastMessageSignal(
SENDING_SCOUT_KITING_LOCATION_X, scoutKitingLoc.x, ONE_SQUARE_RADIUS);
rc.broadcastMessageSignal(
SENDING_SCOUT_KITING_LOCATION_Y, scoutKitingLoc.y, ONE_SQUARE_RADIUS);
}
}
return true;
}
buildDir = buildDir.rotateRight(); // try all directions clockwise
}
}
return false;
}
public static void go_towards_destination() throws GameActionException {
if (!rc.isCoreReady()) return;
if (destination == null || destination.equals(current_location)) {
dig(destination);
return;
}
combat_mode = false;
if (life_insurance_policy == Safety.KITE) combat_mode = true;
// TODO alter try directions so we use non-diagonal if possible.
Direction direction_to_head = current_location.directionTo(destination);
for (int offset : (combat_mode ? combat_directions : try_directions)) {
Direction try_to_walk = Direction.values()[(direction_to_head.ordinal() + offset + 8) % 8];
if (rc.canMove(try_to_walk)) {
if (life_insurance_policy.says_this_move_will_shorten_your_life(
current_location.add(try_to_walk))) continue;
previous_location = current_location;
if (rc.canMove(try_to_walk)) {
rc.move(try_to_walk);
} else {
System.out.println("Running over byte limit");
}
return;
}
}
dig(destination);
}
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);
}
}
}
public static void moveCloserFavorNoMines() throws GameActionException {
Direction dir = rc.getLocation().directionTo(destination);
double distance = rc.getLocation().distanceSquaredTo(destination);
double currDist;
if (rc.canMove(dir) && !hasBadMine(rc.getLocation().add(dir))) {
rc.move(dir);
} else {
Direction bestDir = dir;
Direction currentDir = dir;
for (int directionOffset : directionOffsets) {
if (directionOffset != 0) {
currentDir = Direction.values()[(dir.ordinal() + directionOffset + 8) % 8];
if (rc.canMove(currentDir) && !hasBadMine(rc.getLocation().add(currentDir))) {
currDist = rc.getLocation().add(currentDir).distanceSquaredTo(destination);
if (currDist < distance) {
distance = currDist;
bestDir = currentDir;
}
}
}
}
NavSystem.moveOrDefuse(bestDir);
}
}
/**
* @param whereToGo
* @throws GameActionException The original/old version of progressMove.
*/
@SuppressWarnings("unused")
private void progressMoveOld(MapLocation whereToGo) throws GameActionException {
rc.setIndicatorString(1, "Swarm target: " + whereToGo.toString());
int dist = rc.getLocation().distanceSquaredTo(whereToGo);
if (dist > 0 && rc.isActive()) {
Direction toTarget = rc.getLocation().directionTo(whereToGo);
int[] directionOffsets = {0, 1, -1, 2, -2};
Direction move;
MapLocation ahead;
for (int offset : directionOffsets) {
move = Direction.values()[(toTarget.ordinal() + offset + 8) % 8];
ahead = rc.getLocation().add(move);
Team mine = rc.senseMine(ahead);
int move_num = move.ordinal();
if (rc.canMove(move)
&& (mine == rc.getTeam() || mine == null)
&& move_num != (previousMove + 4) % 8) {
previousMove = move_num;
rc.move(move);
return;
}
}
previousMove = -1;
if (rc.canMove(toTarget) || rc.senseMine(rc.getLocation()) == rc.getTeam()) {
moveOrDefuse(toTarget);
}
}
}
public int evalDirection(
MapLocation currentLocation,
Direction dir,
MapLocation goal,
Direction dirToGoal,
int currentMovesToGoal) {
boolean hasDefusion = rc.hasUpgrade(Upgrade.DEFUSION);
MapLocation square = currentLocation.add(dir);
int directionPenalty;
int dirDiff = Math.abs(dir.ordinal() - dirToGoal.ordinal());
if (dirDiff <= 2) {
directionPenalty = this.movesAway(square, goal) - currentMovesToGoal;
} else {
directionPenalty = hasDefusion ? 5 : 12;
}
int minePenalty;
if (hasDefusion) {
minePenalty = this.mineHazard(square) ? 5 : 0;
} else {
minePenalty = this.mineHazard(square) ? 12 : 0;
}
int visitPenalty = 2 * this.mapIntDistribution[square.x][square.y] * (hasDefusion ? 5 : 12);
return directionPenalty + minePenalty + visitPenalty;
}
public static boolean goToLocation(MapLocation whereToGo, boolean defuseMines)
throws GameActionException {
int dist = mRC.getLocation().distanceSquaredTo(whereToGo);
// TODO if its an hq and stuff is in the way you gotta kill it
if (mRC.isActive() && dist > 0) {
Direction dir = mRC.getLocation().directionTo(whereToGo);
for (int d : Constants.testDirOrderFrontSide) {
Direction lookingAtCurrently = Direction.values()[(dir.ordinal() + d + NUM_DIR) % NUM_DIR];
MapLocation newLoc = mRC.getLocation().add(lookingAtCurrently);
Team mineOwner = mRC.senseMine(newLoc);
boolean shouldDefuseEnemyMine = Math.random() < CHANCE_OF_DEFUSING_ENEMY_MINE;
if (mRC.canMove(lookingAtCurrently)
&& (defuseMines || !isMineDir(mRC.getLocation(), lookingAtCurrently, true))) {
if (mineOwner != null && mineOwner != mRC.getTeam()) {
mRC.defuseMine(newLoc);
} else {
mRC.move(lookingAtCurrently);
}
return true;
} else if (mRC.canMove(lookingAtCurrently)
&& isMineDir(mRC.getLocation(), lookingAtCurrently, true)
&& mineOwner == mRC.getTeam().opponent()
&& shouldDefuseEnemyMine) {
mRC.defuseMine(newLoc);
return true;
}
}
}
return false;
}
private static void goToLocation(MapLocation whereToGo) throws GameActionException {
// if (rc.isActive()) {
// if(encampmentLocationArray == null){ // find encampments
// encampmentLocationArray = rc.senseAllEncampmentSquares();
// }
// if (counter < 10 && rc.senseMine(rc.getLocation()) == null) { // lay mines behind robots
// if(rc.senseMine(rc.getLocation())==null)
// rc.layMine();
// Send all robots to the passed in argument.
int dist = rc.getLocation().distanceSquaredTo(whereToGo);
if (dist > 0) { // dist > 0 && rc.isActive()
Direction dir = rc.getLocation().directionTo(whereToGo);
Direction curDir = dir;
int[] directionOffSets = {0, 1, -1, 2, -2};
lookForDir:
for (int d : directionOffSets) {
curDir = Direction.values()[(dir.ordinal() + d + 8) % 8];
if (rc.canMove(curDir)) {
break lookForDir;
}
}
Team mine = rc.senseMine(rc.getLocation().add(curDir));
if (mine != null && mine != rc.getTeam()) {
rc.defuseMine(rc.getLocation().add(curDir));
} else {
rc.move(curDir);
rc.setIndicatorString(0, "Last direction moved: " + dir.toString());
}
}
}
/**
* Goes through a list of adjacent locations. If a wall is detected, robot tries to move away from
* it.
*
* @param rc
* @throws GameActionException
*/
private static void moveAwayFromWalls(RobotController rc) throws GameActionException {
MapLocation myLocation = rc.getLocation();
for (Direction dir : DIRECTIONS) {
if (!rc.onTheMap(myLocation.add(dir)) && rc.isCoreReady()) {
moveTowards(rc, dir.opposite());
}
}
}
public static void goToGoal(
Direction movingDirection, boolean greaterAttackForce, int numAllAllies)
throws GameActionException {
// forwardish(randomDirection());
if (RobotPlayer.soldierLeader) {
RobotPlayer.rc.setIndicatorString(2, "I am a leader about to move");
if (numAllAllies > 7 && greaterAttackForce) {
RobotPlayer.rc.setIndicatorString(2, "I am a leader with a strong force");
forwardish(movingDirection);
} else if (greaterAttackForce) {
// TODO what to do with small groups?
RobotPlayer.rc.setIndicatorString(2, "I am a leader with a larger force");
if (RobotPlayer.rc.getRoundNum() % 8 == 0) forwardish(movingDirection);
} else {
RobotPlayer.rc.setIndicatorString(2, "greater attack force? " + greaterAttackForce);
if (RobotPlayer.rc.getRoundNum() % 5 == 0) {
RobotPlayer.movingDirection = movingDirection.rotateRight();
forwardish(RobotPlayer.movingDirection);
}
}
} else if (RobotPlayer.rc.getType() == RobotType.SOLDIER) {
if (greaterAttackForce || RobotPlayer.haveLeader) {
forwardish(movingDirection); // keep going where we are going
} else {
forwardish(
movingDirection
.rotateRight()); // wiat for leader, turn (should i go in random direction?)
}
} else if (RobotPlayer.rc.getType() == RobotType.GUARD) {
if (greaterAttackForce || RobotPlayer.haveLeader) {
forwardish(movingDirection); // keep going where we are going
} else {
forwardish(
movingDirection
.rotateRight()); // wiat for leader, turn (should i go in random direction?)
}
}
// else {
//
// if (greaterAttackForce){
// forwardish(movingDirection);//keep going where we are going
// }
//
// forwardish(randomDirection());//wiat for leader, go in random direction
//// forwardish(movingDirection);
// }
// // else if(RobotPlayer.haveLeader){
// //
// // }else{
//
//
//
// //}
}
public static Direction[] bestDir(Direction dir) {
Direction[] bestDir = {
dir,
dir.rotateLeft(),
dir.rotateRight(),
dir.rotateLeft().rotateLeft(),
dir.rotateRight().rotateRight()
};
return bestDir;
}
protected void forwardish(Direction ahead) throws GameActionException {
// System.out.println(ahead);
for (int i : RobotConstants.posDirs) {
Direction candidateDir = Direction.values()[(ahead.ordinal() + i + 8) % 8];
if (rc.canMove(candidateDir)) {
rc.move(candidateDir);
break;
}
}
}
public static void spawnRobot() throws GameActionException {
Direction tempDir = null;
for (int i = 0; i < NUM_DIR; ++i) {
tempDir = Direction.values()[(enHQDir.ordinal() + i + NUM_DIR) % NUM_DIR];
if (mRC.canMove(tempDir)) {
mRC.spawn(tempDir);
break;
}
}
}
public Direction Bug(MapLocation s, MapLocation t, int tolerance) {
// arrive the destination
if (s.distanceSquaredTo(t) <= tolerance) {
reset();
return Direction.OMNI;
}
Direction nextDir;
Direction faceDir = controllers.myRC.getDirection();
// if target is not traversable, back-tracing the destination
while (!isTraversable(t)) {
nextDir = s.directionTo(t);
t = t.subtract(nextDir);
// beside the source
if (s.distanceSquaredTo(t) <= tolerance) {
reset();
return Direction.OMNI;
}
}
modifiedDes = t;
Direction desDir = s.directionTo(t);
MapLocation nextLoc;
if (isTracing) {
Direction startTracingDir =
isCW ? faceDir.rotateRight().rotateRight() : faceDir.rotateLeft().rotateLeft();
nextLoc = traceNext(s, startTracingDir, isCW);
nextDir = s.directionTo(nextLoc);
// The way is open
if (isOpen(s, faceDir, nextDir, desDir, isCW) && isTraversable(s.add(desDir))) {
isTracing = false;
return desDir;
}
return nextDir;
} else {
if (isTraversable(s.add(desDir))) {
return desDir;
} else {
isTracing = true;
isCW = betterTracingWay(s, t);
nextLoc = traceNext(s, desDir, isCW);
return s.directionTo(nextLoc);
}
}
}
public static Direction getBestMoveableDirection(Direction dir, RobotController rc, int fan) {
int ordinal = dir.ordinal();
for (int i = 0; i < 2 * fan + 1; i++) {
int disp = ((i % 2) * 2 - 1) * (i + 1) / 2;
Direction testDir = Direction.values()[mod8(ordinal + disp)];
if (rc.canMove(testDir)) {
return testDir;
}
}
return Direction.NONE;
}
private Direction getSpawnDir() {
Direction directDir = this.getDirectSpawnDir();
int[] spawningOffsets = {0, 1, -1, 2, -2, 3, -3, 4};
for (int offset : spawningOffsets) {
Direction potentialSpawnDir = Direction.values()[(directDir.ordinal() + offset + 8) % 8];
MapLocation potentialSpawnLocation = this.currentLocation.add(potentialSpawnDir);
if (rc.canMove(potentialSpawnDir) && !this.mineHazard(potentialSpawnLocation)) {
return potentialSpawnDir;
}
}
return null;
}
private static void runMissile() {
int lastTurn = Clock.getRoundNum() + GameConstants.MISSILE_LIFESPAN;
int[] damageRange = {0, 8, 15, 24, 35, 48};
MapLocation target = null;
boolean targetMoves = true;
while (true) {
myLoc = rc.getLocation();
int turns = lastTurn - Clock.getRoundNum();
if (targetMoves) { // Re-acquire the target's location
RobotInfo[] inRange = rc.senseNearbyRobots(damageRange[turns], enemyTeam);
if (inRange.length > 0) { // No units to target
target = inRange[0].location;
targetMoves = inRange[0].type.canMove();
rc.setIndicatorString(0, "Missile targetting " + inRange[0].type + "@" + target);
} else {
targetMoves = false; // Pick a tower or the HQ
MapLocation[] enemyTowers = rc.senseEnemyTowerLocations();
for (MapLocation t : enemyTowers) {
if (myLoc.distanceSquaredTo(t) <= damageRange[turns]) {
target = t;
rc.setIndicatorString(0, "Missile targetting Tower @" + target);
break;
}
}
if (target == null) {
target = rc.senseEnemyHQLocation();
rc.setIndicatorString(0, "Missile targetting HQ @" + target);
}
}
}
try {
if (target != null) {
if (myLoc.distanceSquaredTo(target) <= GameConstants.MISSILE_RADIUS_SQUARED) rc.explode();
else {
Direction d = myLoc.directionTo(target);
if (rc.canMove(d)) rc.move(d);
else if (rc.canMove(d.rotateLeft())) rc.move(d.rotateLeft());
else if (rc.canMove(d.rotateRight())) rc.move(d.rotateRight());
}
}
} catch (GameActionException e) {
System.out.println("Missile exception");
// e.printStackTrace();
}
rc.yield();
}
}
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());
}
public static void goDirectionAndDontDefuseOrAvoidMines(Direction dir)
throws GameActionException {
if (rc.isActive()) {
Direction lookingAtCurrently = dir;
lookAround:
for (int d : directionOffsets) {
lookingAtCurrently = Direction.values()[(dir.ordinal() + d + 8) % 8];
if (rc.isActive() && rc.canMove(lookingAtCurrently)) {
rc.move(lookingAtCurrently);
break lookAround;
}
}
}
}
/**
* Try to move.
*
* @param sneak:
* @return
*/
public void execute(int sneak) {
// int bc = Clock.getBytecodesLeft();
// RC.setIndicatorString(1, "my x = " + Integer.toString(RC.getLocation().x) + ", my y = " +
// Integer.toString(RC.getLocation().y)
// + "x = " + Integer.toString(dest.x) + ", y = " + Integer.toString(dest.y));
// RC.setIndicatorString(2, Clock.getRoundNum() + " | dest = " + dest + ", navtype = " +
// navType);
if (arrived()) return;
if (RC.isActive()) {
Direction d;
d = navAlg.getNextDir();
if (d != null && d != Direction.NONE && d != Direction.OMNI) {
if (RC.canMove(d)) {
try {
switch (sneak) {
case SNEAK:
// RC.setIndicatorString(2, dest.x + ", " + dest.y + ": sneak");
RC.sneak(d);
break;
case RUN:
// RC.setIndicatorString(2, dest.x + ", " + dest.y + ": run");
RC.move(d);
break;
case PUSH_HOME:
// RC.setIndicatorString(2, dest.x + ", " + dest.y + ": push_home");
Direction awayFromHome = currentLocation.directionTo(ALLY_HQ).opposite();
if (d == awayFromHome
|| d == awayFromHome.rotateLeft()
|| d == awayFromHome.rotateRight()) {
RC.sneak(d);
} else {
RC.move(d);
}
break;
default:
break;
}
} catch (GameActionException e) {
e.printStackTrace();
}
} else if (currentLocation.distanceSquaredTo(dest) <= 2) {
setTarget(currentLocation);
}
}
}
// System.out.println("Bytecodes used by Mover.execute() = " +
// Integer.toString(bc-Clock.getBytecodesLeft()));
}
/////////////////////////////////////////////////////////////
// moveAway()
//
private static boolean moveAway(MapLocation center) throws GameActionException {
while (!rc.isCoreReady()) {
Clock.yield();
}
Direction dir = center.directionTo(rc.getLocation());
int c = 0;
while (!rc.canMove(dir)) {
dir = dir.rotateRight();
c++;
if (c >= 4) return false;
}
rc.move(dir);
return true;
}
public static boolean turnNuke(RobotController rc) {
boolean nuke = false;
GameObject[] nearByEnemies =
rc.senseNearbyGameObjects(Robot.class, 35, rc.getTeam().opponent());
GameObject[] nearByFriends;
if (nearByEnemies.length == 0) {
} else {
MapLocation[] nearBySpots = new MapLocation[8];
Direction dir = rc.getLocation().directionTo(rc.senseHQLocation());
for (int i = 0; i < nearBySpots.length; i++) {
nearBySpots[i] = rc.getLocation().add(dir);
dir.rotateLeft();
}
int[] damage = new int[8];
for (int i = 0; i < damage.length; i++) {
nearByEnemies =
rc.senseNearbyGameObjects(Robot.class, nearBySpots[i], 2, rc.getTeam().opponent());
nearByFriends = rc.senseNearbyGameObjects(Robot.class, nearBySpots[i], 2, rc.getTeam());
int total = nearByEnemies.length - nearByFriends.length;
damage[i] = total;
}
int largest = damage[0];
int index = 0;
for (int k = 1; k < damage.length; k++) {
if (largest < damage[k]) {
largest = damage[k];
index = k;
}
}
if (largest > 1) {
// Nuke nuker = new Nuke(rc, nearBySpots[index]);
// nuker.run();
return true;
} else {
return false;
}
}
return nuke;
}
