private static void turret(RobotController rc) {
// do one time things here
turtleCorner = turtleCorner == null ? LOCATION_NONE : turtleCorner;
try {
RobotInfo[] friendlyRobots =
rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, rc.getTeam());
if (rc.getHealth() <= 3 && rc.isInfected() && friendlyRobots.length > 0) {
rc.disintegrate();
}
turretAttack(rc);
processFighterSignals(rc);
if ((archonIsTooClose(rc) || isAdjacentToWall(rc))
&& rc.getType() == RobotType.TURRET
&& rc.isCoreReady()) {
rc.pack();
}
if (turtleCorner != LOCATION_NONE && rc.isCoreReady() && rc.getType() == RobotType.TURRET) {
int minCornerRadius = (20 + (rc.getRobotCount() / 10));
if (rc.getLocation().distanceSquaredTo(turtleCorner) < minCornerRadius) {
rc.pack();
}
}
rc.setIndicatorString(0, "Turtle x: " + turtleCorner.x + "Turtle y: " + turtleCorner.y);
rc.setIndicatorString(1, "I am a turret");
// if (turtleCorner.equals(LOCATION_NONE)) tryToLocateCorner(rc);
Clock.yield();
} catch (GameActionException e) {
e.printStackTrace();
}
}
/**
* Working on soldier behavior: 1) If about to die and infected and senses nearby friendly robots,
* self destruct 2) Attack if possible 3) Process signals. (If another soldier signals, move
* towards that soldier (means there is a zombie den nearby)) 4) Move away from walls / archons 5)
* Use position and relative position to turtle corner to move away or toward turtle corner 6) Try
* to clear surrounding rubble
*
* @param rc
*/
private static void soldier(RobotController rc) {
turtleCorner = LOCATION_NONE;
while (true) {
try {
// 1)
RobotInfo[] friendlyRobots =
rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, rc.getTeam());
if (rc.getHealth() <= 3 && rc.isInfected() && friendlyRobots.length > 0) {
rc.disintegrate();
} else {
// 2)
attackFirst(rc);
// 3)
processFighterSignals(rc);
// 4)
moveAwayFromArchons(rc);
moveAwayFromWalls(rc);
// 5)
if (!turtleCorner.equals(LOCATION_NONE)) {
moveFromCorner(rc);
} else if (currentMode == TRANSITION_MODE) {
moveTowardsArchon(rc);
}
// 6)
clearRubble(rc);
// if(turtleCorner.equals(LOCATION_NONE)) tryToLocateCorner(rc);
}
rc.setIndicatorString(0, "Turtle x: " + turtleCorner.x + "Turtle y: " + turtleCorner.y);
rc.setIndicatorString(1, "Current Mode" + currentMode);
Clock.yield();
} catch (GameActionException e) {
e.printStackTrace();
}
}
}
/**
* 1) process signals, try to find turtleCorner 2) if enemies are within sensing radius, unpack 3)
* if too close to archons, move away 4) if too close to wall, move away 5) if too close to
* corner, move away 6) if it did nothing, unpack
*
* @param rc
*/
private static void ttm(RobotController rc) {
turtleCorner = turtleCorner.equals(null) ? LOCATION_NONE : turtleCorner;
try {
RobotInfo[] friendlyRobots =
rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, rc.getTeam());
if (rc.getHealth() <= 3 && rc.isInfected() && friendlyRobots.length > 0) {
rc.disintegrate();
}
// 1)
if (isNearbyEnemies(rc) && rc.isCoreReady()) {
rc.unpack();
}
// 2)
processFighterSignals(rc);
// 3)
moveAwayFromArchons(rc);
// 4)
moveAwayFromWalls(rc);
// 5)
if (turtleCorner != LOCATION_NONE) moveFromCorner(rc);
// 6)
if (rc.isCoreReady() && rc.getType() == RobotType.TTM && rc.getRoundNum() % 25 == 0)
rc.unpack();
rc.setIndicatorString(0, "Turtle x: " + turtleCorner.x + "Turtle y: " + turtleCorner.y);
rc.setIndicatorString(1, "I am a TTM!");
Clock.yield();
} catch (GameActionException e) {
e.printStackTrace();
}
}
private static void moveSoldier(RobotController rc) throws GameActionException {
// if we have a real current destination
rc.setIndicatorString(1, "moving somewhere " + currentDestination + rc.getRoundNum());
if (currentDestination != null) {
// if bugging is never initialized or we are switching destinations, reinitialize bugging
if (!currentDestination.equals(storedDestination) || bugging == null) {
bugging = new Bugging(rc, currentDestination);
storedDestination = currentDestination;
}
// if we are trying to move towards a turret, stay out of range
if (rc.isCoreReady()) {
if (currentDestination.equals(nearestTurretLocation)) {
bugging.turretAvoidMove(turretLocations);
} else
// if core is ready, then try to move towards destination
if (nearestTurretLocation != null) {
bugging.turretAvoidMove(turretLocations);
} else {
bugging.move();
}
}
} else if (nearestArchonLocation
!= null) { // we don't actually have a destination, so we want to try to move towards the
// closest archon
rc.setIndicatorString(
0, "moving to nearest archon " + nearestArchonLocation + rc.getRoundNum());
if (!nearestArchonLocation.equals(storedDestination)) {
bugging = new Bugging(rc, nearestArchonLocation);
storedDestination = nearestArchonLocation;
}
// if core is ready, try to move
if (rc.isCoreReady() && bugging != null) {
if (nearestTurretLocation != null) {
bugging.turretAvoidMove(turretLocations);
} else if (nearestArchonLocation.equals(bugging.destination)
&& myLoc.distanceSquaredTo(nearestArchonLocation)
> 13) { // if soldier is far, move towards archon
bugging.move();
} else if (nearestArchonLocation.equals(bugging.destination)
&& myLoc.distanceSquaredTo(nearestArchonLocation)
< 13) { // if soldier is too close, move towards archon
// try to move away from nearest archon
if (rc.canMove(nearestArchonLocation.directionTo(myLoc))) {
rc.move(nearestArchonLocation.directionTo(myLoc));
}
}
}
} else { // if we literally have nowhere to go
rc.setIndicatorString(1, "bugging around friendly " + rc.getRoundNum());
bugAroundFriendly(rc);
}
}
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();
}
}
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());
}
}
}
public static void setRetreatingStatus(RobotController rc, RobotInfo[] hostiles)
throws GameActionException {
// Retreating is when your first hit less than a third health or when you were retreating
// already and is not max health yet.
// But you should not be retreating if you are infected. That's not a good idea!
healing =
(3 * rc.getHealth() < RobotType.SOLDIER.maxHealth
|| (wasHealing && rc.getHealth() < RobotType.SOLDIER.maxHealth))
&& (rc.getHealth() > 2 * rc.getViperInfectedTurns());
if (!healing) {
if (wasHealing) bugging = null;
wasHealing = false;
}
if (healing) {
RobotInfo[] nearbyRobots = rc.senseNearbyRobots(sightRadius, myTeam);
for (RobotInfo r : nearbyRobots) {
if (r.type == RobotType.ARCHON) nearestArchonLocation = r.location;
}
rc.setIndicatorString(0, "should be retreating " + nearestArchonLocation + rc.getRoundNum());
if (!wasHealing || !bugging.destination.equals(nearestArchonLocation)) {
if (nearestArchonLocation == null) {
bugging = new Bugging(rc, rc.getLocation().add(Direction.EAST));
} else {
bugging = new Bugging(rc, nearestArchonLocation);
}
}
wasHealing = true;
}
}
/**
* @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 static void yield() {
if (my_type == RobotType.ARCHON) rc.setIndicatorString(0, "Beta 1.5");
if (rc.getRoundNum() % 25 == 0) Scanner.reset_health();
Clock.yield();
}
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();
}
}
}
public static void fire(RobotController rc) {
int radius;
try {
if (rc.getType() == RobotType.HQ) {
radius = 15;
Robot[] enemies = rc.senseNearbyGameObjects(Robot.class, radius, rc.getTeam().opponent());
Direction[] dirs = Direction.values();
Robot target = null;
int maxValue = 0;
for (int k = 0; k < enemies.length; k++) {
MapLocation loc = rc.senseRobotInfo(enemies[k]).location;
int value = 2;
for (int a = 0; a < 8; a++) {
try {
if (rc.senseObjectAtLocation(loc.add(dirs[a])).getTeam() == rc.getTeam().opponent()) {
value++;
} else if (rc.senseObjectAtLocation(loc.add(dirs[a])).getTeam() == rc.getTeam()) {
value--;
}
} catch (Exception e) {
e.printStackTrace();
}
}
rc.setIndicatorString(0, "" + value);
if (value > maxValue) {
maxValue = value;
target = enemies[k];
}
}
if (target != null) {
rc.attackSquare(rc.senseRobotInfo(target).location);
}
} else {
radius = 10;
Robot[] enemies = rc.senseNearbyGameObjects(Robot.class, radius, rc.getTeam().opponent());
Robot target = null;
for (int k = 0; k < enemies.length; k++) {
if (target == null) {
target = enemies[k];
} else if (rc.senseRobotInfo(enemies[k]).health < rc.senseRobotInfo(target).health) {
target = enemies[k];
}
}
if (target != null) {
rc.attackSquare(rc.senseRobotInfo(target).location);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static void runSoldier() throws GameActionException {
// follow orders from HQ
// Direction towardEnemy = rc.getLocation().directionTo(rc.senseEnemyHQLocation());
// BasicPathing.tryToMove(towardEnemy, true, rc, directionalLooks, allDirections);//was
// Direction.SOUTH_EAST
Robot[] enemyRobots = rc.senseNearbyGameObjects(Robot.class, 10000, rc.getTeam().opponent());
if (enemyRobots.length > 0) { // if there are enemies
rc.setIndicatorString(0, "There are enemies");
MapLocation[] robotLocations = new MapLocation[enemyRobots.length];
for (int i = 0; i < enemyRobots.length; i++) {
Robot anEnemy = enemyRobots[i];
RobotInfo anEnemyInfo = rc.senseRobotInfo(anEnemy);
robotLocations[i] = anEnemyInfo.location;
}
MapLocation closestEnemyLoc = VectorFunctions.findClosest(robotLocations, rc.getLocation());
if (closestEnemyLoc.distanceSquaredTo(rc.getLocation())
< rc.getType().attackRadiusMaxSquared) {
rc.setIndicatorString(1, "trying to shoot");
if (rc.isActive()) {
rc.attackSquare(closestEnemyLoc);
}
} else {
rc.setIndicatorString(1, "trying to go closer");
Direction towardClosest = rc.getLocation().directionTo(closestEnemyLoc);
simpleMove(towardClosest);
}
} else {
if (path.size() == 0) {
MapLocation goal = getRandomLocation();
path =
BreadthFirst.pathTo(
VectorFunctions.mldivide(rc.getLocation(), bigBoxSize),
VectorFunctions.mldivide(rc.senseEnemyHQLocation(), bigBoxSize),
100000);
}
// follow breadthFirst path
Direction bdir = BreadthFirst.getNextDirection(path, bigBoxSize);
BasicPathing.tryToMove(bdir, true, rc, directionalLooks, allDirections);
}
// Direction towardEnemy = rc.getLocation().directionTo(rc.senseEnemyHQLocation());
// simpleMove(towardEnemy);
}
/*
* Moves towards the nearest enemy
* Returns true if we moved or are in the right place
*/
private static boolean doCloseWithEnemyMove(boolean ignoreThreat) {
// Move to within attack range of the nearest enemy - ignore towers and HQ until later in the
// game
// We can move in closer if we are still out of range of the enemy
RobotInfo nearest = null;
RobotInfo preferred = null;
RobotInfo[] enemies = rc.senseNearbyRobots(senseRange * 16, enemyTeam);
boolean canFly = (myType == RobotType.DRONE);
int now = Clock.getRoundNum();
for (RobotInfo e : enemies) {
// We want to find and circle units, not towers or HQ (until later in the game)
if (now < maxRounds / 2 && (e.type == RobotType.HQ || e.type == RobotType.TOWER)) continue;
// Drones on VOID tiles cannot be reached by ground troops - ignore them
if (!canFly && rc.senseTerrainTile(e.location) != TerrainTile.NORMAL) continue;
// Commanders are good at picking off miners, beavers and non combat buildings - have a
// preference for them
if (myType == RobotType.COMMANDER
&& commanderLikes(e.type)
&& (preferred == null
|| e.location.distanceSquaredTo(myLoc) < preferred.location.distanceSquaredTo(myLoc)))
preferred = e;
if (nearest == null
|| e.location.distanceSquaredTo(myLoc) < nearest.location.distanceSquaredTo(myLoc))
nearest = e;
}
if (preferred != null) nearest = preferred;
int attackRange = myType.attackRadiusSquared;
if (myType == RobotType.LAUNCHER)
attackRange = (1 + GameConstants.MISSILE_LIFESPAN) * (1 + GameConstants.MISSILE_LIFESPAN);
if (nearest != null) {
if (ignoreThreat || myLoc.distanceSquaredTo(nearest.location) > attackRange) {
rc.setIndicatorString(2, "Closing with " + nearest.type + " at " + nearest.location);
if (rc.isCoreReady()) tryMove(rc.getLocation().directionTo(nearest.location), ignoreThreat);
} else {
rc.setIndicatorString(
2, "Holding at range with " + nearest.type + " at " + nearest.location);
}
return true;
}
return false;
}
/*
* If there are no good moves we should stay and fight
*/
private static void doRetreatMove() {
try {
if (myType == RobotType.COMMANDER
&& rc.hasLearnedSkill(CommanderSkillType.FLASH)
&& rc.getFlashCooldown() == 0) flashTowards(myHQ, true);
Direction d = myLoc.directionTo(myHQ);
rc.setIndicatorString(2, "Threatened - retreating towards HQ " + d);
if (rc.isCoreReady()) tryMove(d, false);
} catch (GameActionException e) {
System.out.println("Retreat exception");
// e.printStackTrace();
}
}
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 HQPlayer(RobotController rc) {
super(rc);
this.currentLocation = rc.getLocation();
this.directionToEnemyHQ = this.currentLocation.directionTo(enemyHQLocation);
this.initialMineCount = rc.senseMineLocations(currentLocation, 10000, Team.NEUTRAL).length;
try {
if (this.canBeTrapped()) {
rc.setIndicatorString(2, "Can be trapped");
this.markSpawnSquare();
} else {
rc.setIndicatorString(2, "No trap sensed");
}
// pick encampments on our side of the map
rc.broadcast(TargetEncampmentsStartChannel, targetEncampmentsStart);
this.targetEncampments =
rc.senseEncampmentSquares(
currentLocation,
this.currentLocation.distanceSquaredTo(enemyHQLocation) / 4,
Team.NEUTRAL);
// int a = Clock.getBytecodeNum();
QuicksortLocations(this.targetEncampments, this.currentLocation);
// int b = Clock.getBytecodeNum();
// rc.setIndicatorString(1, "Bytecodes: "+(b-a));
this.broadcastTargetEncampments();
int rendezvousX = (3 * this.currentLocation.x + this.enemyHQLocation.x) / 4;
int rendezvousY = (3 * this.currentLocation.y + this.enemyHQLocation.y) / 4;
MapLocation rendezvous = new MapLocation(rendezvousX, rendezvousY);
rc.broadcast(RendezVousChannel, intFromMapLocation(rendezvous));
} catch (GameActionException e) {
e.printStackTrace();
}
}
/**
* To be run by archons during the intro phase (and others? change it a bit?) to handle and gather
* information from incoming message signals
*
* @param rc
*/
private static void processIntroMessageSignals(RobotController rc) {
int cornerX = Integer.MIN_VALUE;
int cornerY = Integer.MIN_VALUE;
int denX = Integer.MIN_VALUE;
int denY = Integer.MIN_VALUE;
Signal[] signals = rc.emptySignalQueue();
for (Signal s : signals) {
if (s.getTeam().equals(myTeam) && s.getMessage() != null) {
final int[] message = s.getMessage();
if (message[0] == SENDING_CORNER_X) {
cornerX = message[1];
} else if (message[0] == SENDING_CORNER_Y) {
cornerY = message[1];
} else if (message[0] == SENDING_DEN_X) {
denX = message[1];
} else if (message[0] == SENDING_DEN_Y) {
denY = message[1];
}
}
}
if (cornerX > Integer.MIN_VALUE && cornerY > Integer.MIN_VALUE) {
MapLocation newCorner = new MapLocation(cornerX, cornerY);
if (!SCOUTED_CORNERS.contains(newCorner)) {
SCOUTED_CORNERS.add(newCorner);
rc.setIndicatorString(0, "Added new corner: " + newCorner);
rc.setIndicatorString(2, "Current Mode" + currentMode);
}
rc.setIndicatorString(1, SCOUTED_CORNERS + "");
}
if (denX > Integer.MIN_VALUE && denY > Integer.MIN_VALUE) {
MapLocation newDen = new MapLocation(denX, denY);
if (!ZOMBIE_DEN_LOCATIONS.contains(newDen)) {
ZOMBIE_DEN_LOCATIONS.add(newDen);
}
}
}
// Move towards enemy HQ if we can attack
private static void doAdvanceMove() {
try {
if (myType == RobotType.COMMANDER
&& rc.hasLearnedSkill(CommanderSkillType.FLASH)
&& rc.getFlashCooldown() == 0) flashTowards(threats.enemyHQ, false);
} catch (GameActionException e) {
System.out.println("Flash exception");
// e.printStackTrace();
}
if (rc.isCoreReady()) {
Direction dir = null;
if (myType.canAttack() || (myType == RobotType.LAUNCHER && Clock.getRoundNum() > 550)) {
if (myType != RobotType.DRONE) dir = bfs.readResult(myLoc, threats.enemyHQ);
if (dir == null) dir = myLoc.directionTo(threats.enemyHQ);
rc.setIndicatorString(2, "Advancing " + dir);
} else {
dir = myLoc.directionTo(myHQ);
rc.setIndicatorString(2, "HQ Defensive unit " + dir);
}
tryMove(dir, false);
}
}
private static void goDirectionAvoidMines(Direction dir) throws GameActionException {
int[] directionOffsets = {0, 1, -1, 2, -2};
Direction lookingAtCurrently = dir;
lookAround:
for (int d : directionOffsets) {
lookingAtCurrently = Direction.values()[(dir.ordinal() + d + 8) % 8];
if (rc.canMove(lookingAtCurrently)) {
if (!badBomb(rc.getLocation().add(lookingAtCurrently))) {
rc.move(lookingAtCurrently);
rc.setIndicatorString(0, "Last direction moved: " + lookingAtCurrently.toString());
}
break lookAround;
}
}
}
public void evalMove(MapLocation currentLocation, MapLocation whereToGo)
throws GameActionException { // New pathing algorithm
// SHOULD WE CONSIDER NOT MOVING??
if (rc.isActive()) {
try {
this.mapIntDistribution[currentLocation.x][currentLocation.y] += 1;
} catch (Exception e) {
this.mapIntDistribution[currentLocation.x][currentLocation.y] = 1;
}
int[] dirOffsets = {0, 1, 2, 3, 4, 5, 6, 7};
int bestScore = -1;
Direction bestDir = null;
for (int offset : dirOffsets) {
Direction dir = Direction.values()[offset];
if (rc.canMove(dir)) {
int score =
this.evalDirection(
currentLocation,
dir,
whereToGo,
currentLocation.directionTo(whereToGo),
this.movesAway(currentLocation, whereToGo));
if (bestDir == null) {
bestScore = score;
bestDir = dir;
} else if (score < bestScore) {
bestScore = score;
bestDir = dir;
}
}
}
if (bestDir != null) {
rc.setIndicatorString(
0,
"Best score: "
+ bestScore
+ ", Direction to target: "
+ currentLocation.directionTo(whereToGo));
MapLocation moveSquare = currentLocation.add(bestDir);
if (this.mineHazard(moveSquare)) {
rc.defuseMine(moveSquare);
} else {
rc.move(bestDir);
}
}
}
}
/*
* Beavers and miners without ore do this
*/
private static void doSearchMove() {
// We keep moving in the direction we were going
// When blocked we turn left or right depending on our unique ID
rc.setIndicatorString(2, "Mining: No ore - searching");
if (lastMove == null || rand.nextInt(10) == 1)
lastMove = directions[rand.nextInt(directions.length)];
Direction startDir = lastMove;
while (!rc.canMove(lastMove) || threats.isThreatened(myLoc.add(lastMove))) {
if (rc.getID() % 2 == 0) lastMove = lastMove.rotateLeft();
else lastMove = lastMove.rotateRight();
if (lastMove == startDir) // We are trapped
return;
}
try {
rc.move(lastMove);
} catch (GameActionException e) {
System.out.println("Move exception");
// e.printStackTrace();
}
}
public void run(final RobotController robotController) throws GameActionException {
final MapInfoModule mapInfoModule = new MapInfoModule();
final CombatModule combatModule = new CombatModule();
final CommunicationModule communicationModule = new CommunicationModule(mapInfoModule);
final DirectionModule directionModule = new DirectionModule(robotController.getID());
final MovementModule movementModule = new MovementModule();
final RubbleModule rubbleModule = new RubbleModule();
final Team currentTeam = robotController.getTeam();
int turnsStuck = 0;
while (true) {
RobotType type = robotController.getType();
MapLocation currentLocation = robotController.getLocation();
// update communication
communicationModule.processIncomingSignals(robotController);
// let's verify existing information
communicationModule.verifyCommunicationsInformation(robotController, null, false);
if (type == RobotType.TTM) {
// MOVE
// let's get the best assignment
CommunicationModuleSignal objectiveSignal = null;
int closestObjectiveLocationDistance = Integer.MAX_VALUE;
final Enumeration<CommunicationModuleSignal> zombieDenCommunicationModuleSignals =
communicationModule.zombieDens.elements();
while (zombieDenCommunicationModuleSignals.hasMoreElements()) {
final CommunicationModuleSignal signal =
zombieDenCommunicationModuleSignals.nextElement();
final int distance = signal.location.distanceSquaredTo(currentLocation);
if (distance < closestObjectiveLocationDistance) {
objectiveSignal = signal;
closestObjectiveLocationDistance = distance;
}
}
final Enumeration<CommunicationModuleSignal> enemyArchonCommunicationModuleSignals =
communicationModule.enemyArchons.elements();
while (enemyArchonCommunicationModuleSignals.hasMoreElements()) {
final CommunicationModuleSignal signal =
enemyArchonCommunicationModuleSignals.nextElement();
final int distance =
signal.location.distanceSquaredTo(currentLocation)
* 6; // multiplying by 6 to prioritize the dens
if (distance < closestObjectiveLocationDistance) {
objectiveSignal = signal;
closestObjectiveLocationDistance = distance;
}
}
final Enumeration<CommunicationModuleSignal> enemyTurretCommunicationModuleSignals =
communicationModule.enemyTurrets.elements();
while (enemyTurretCommunicationModuleSignals.hasMoreElements()) {
final CommunicationModuleSignal signal =
enemyTurretCommunicationModuleSignals.nextElement();
final int distance = signal.location.distanceSquaredTo(currentLocation) * 20;
if (distance < closestObjectiveLocationDistance) {
objectiveSignal = signal;
closestObjectiveLocationDistance = distance;
}
}
boolean shouldMove = true;
Direction desiredMovementDirection = null;
Direction targetRubbleClearanceDirection = null;
// check to make sure we are safe
final RobotInfo[] enemies =
robotController.senseHostileRobots(
currentLocation, robotController.getType().sensorRadiusSquared);
if (robotController.isCoreReady() && enemies.length > 0) {
final Direction fleeDirection =
directionModule.averageDirectionTowardDangerousRobotsAndOuterBounds(
robotController, enemies);
if (fleeDirection != null) {
final Direction fleeMovementDirection =
directionModule.recommendedMovementDirectionForDirection(
fleeDirection.opposite(), robotController, false);
if (fleeMovementDirection != null) {
robotController.move(fleeMovementDirection);
currentLocation = robotController.getLocation();
robotController.setIndicatorString(
1, fleeDirection.name() + " " + fleeMovementDirection.name());
}
}
}
// check if there are nearby signals
if (desiredMovementDirection == null) {
int closestSignalDistance = Integer.MAX_VALUE;
MapLocation closestSignalLocation = null;
final ArrayList<Signal> notifications = communicationModule.notifications;
for (int i = 0; i < notifications.size(); i++) {
final Signal signal = notifications.get(i);
final int distance = currentLocation.distanceSquaredTo(signal.getLocation());
if (distance < closestSignalDistance) {
closestSignalDistance = distance;
closestSignalLocation = signal.getLocation();
}
}
if (closestSignalLocation != null) {
desiredMovementDirection = currentLocation.directionTo(closestSignalLocation);
}
}
// now let's try move toward an assignment
if (robotController.isCoreReady()
&& communicationModule.initialInformationReceived
&& shouldMove) {
// check if we have an objective
if (desiredMovementDirection == null) {
if (objectiveSignal != null) {
final MapLocation objectiveLocation = objectiveSignal.location;
if (objectiveLocation.distanceSquaredTo(currentLocation) >= 8) {
desiredMovementDirection = currentLocation.directionTo(objectiveLocation);
}
}
}
// try move towards archon starting positions
if (desiredMovementDirection == null) {
int closestArchonDistance = Integer.MAX_VALUE;
MapLocation closestArchonLocation = null;
final MapLocation[] archonLocations =
robotController.getInitialArchonLocations(robotController.getTeam().opponent());
for (int i = 0; i < archonLocations.length; i++) {
final MapLocation location = archonLocations[i];
final int distance = currentLocation.distanceSquaredTo(location);
if (distance < closestArchonDistance) {
closestArchonDistance = distance;
closestArchonLocation = location;
}
}
if (closestArchonLocation != null) {
desiredMovementDirection = currentLocation.directionTo(closestArchonLocation);
}
}
// process movement
if (desiredMovementDirection != null) {
final Direction recommendedMovementDirection =
directionModule.recommendedMovementDirectionForDirection(
desiredMovementDirection, robotController, false);
final MapLocation recommendedMovementLocation =
recommendedMovementDirection != null
? currentLocation.add(recommendedMovementDirection)
: null;
if (recommendedMovementDirection != null
&& !movementModule.isMovementLocationRepetitive(
recommendedMovementLocation, robotController)) {
robotController.move(recommendedMovementDirection);
movementModule.addMovementLocation(recommendedMovementLocation, robotController);
currentLocation = robotController.getLocation();
turnsStuck = 0;
}
}
}
// unpack if we're safe
RobotInfo[] nearbyTeammates = robotController.senseNearbyRobots(8, currentTeam);
RobotInfo[] nearbySoldiers =
combatModule.robotsOfTypesFromRobots(
nearbyTeammates, new RobotType[] {RobotType.SOLDIER});
if (nearbySoldiers.length > 2) {
robotController.unpack();
}
} else {
// ATTACK
final RobotInfo[] enemies =
robotController.senseHostileRobots(
currentLocation, robotController.getType().attackRadiusSquared);
RobotInfo bestEnemy = this.getBestEnemyToAttackFromEnemies(robotController, enemies);
// handle attacking
if (bestEnemy != null) {
if (robotController.isWeaponReady()) {
// we can attack the enemy
robotController.attackLocation(bestEnemy.location);
if (bestEnemy.type != RobotType.ZOMBIEDEN) {
communicationModule.broadcastSignal(
robotController,
CommunicationModule.maximumFreeBroadcastRangeForRobotType(
robotController.getType()));
}
}
}
// pack if we aren't near soldiers
RobotInfo[] nearbyTeammates =
robotController.senseNearbyRobots(type.sensorRadiusSquared, currentTeam);
RobotInfo[] nearbySoldiers =
combatModule.robotsOfTypesFromRobots(
nearbyTeammates, new RobotType[] {RobotType.SOLDIER});
if (nearbySoldiers.length < 3) {
robotController.pack();
}
}
Clock.yield();
}
}
public static void run() throws GameActionException {
rc = RobotPlayer.rc;
rand = new Random(rc.getID());
// build scouts right away
buildRobot(RobotType.SCOUT);
while (true) {
/*
* INPUT
*/
if (rc.getLocation().equals(goal)) {
goal = null; // you made it to the goal
past10Locations =
new ArrayList<MapLocation>(); // delete the slug trail after you reach your goal
}
// sense locations around you
nearbyMapLocations =
MapLocation.getAllMapLocationsWithinRadiusSq(
rc.getLocation(), rc.getType().sensorRadiusSquared);
// parts locations
nearbyPartsLocations = rc.sensePartLocations(RobotType.ARCHON.sensorRadiusSquared);
// find the nearest mapLocation with the most parts
double maxParts = 0;
MapLocation nearbyLocationWithMostParts = null;
for (MapLocation loc : nearbyPartsLocations) {
// add to locationsWithParts arraylist
if (locationsWithParts.contains(loc) == false) {
locationsWithParts.add(loc);
}
// find the location with the most parts
double partsAtLoc = rc.senseParts(loc);
if (partsAtLoc > maxParts) {
maxParts = partsAtLoc;
nearbyLocationWithMostParts = loc;
}
}
// read signals
Signal[] signals = rc.emptySignalQueue();
for (Signal signal : signals) {
// check if the signal has parts at the location
int[] message = signal.getMessage();
if (message != null && message[0] == Utility.PARTS_CODE) {
// add that location to the locationsWithParts arraylist
locationsWithParts.add(signal.getLocation());
}
}
// sense robots
MapLocation myLoc = rc.getLocation();
robots = rc.senseNearbyRobots();
foes = new ArrayList<RobotInfo>();
foesWithinAttackRange = new ArrayList<RobotInfo>();
for (RobotInfo robot : robots) {
if (robot.team == Team.ZOMBIE
|| robot.team == rc.getTeam().opponent()) // if the robot is a foe
{
foes.add(robot);
if (myLoc.distanceSquaredTo(robot.location) < robot.type.attackRadiusSquared) {
foesWithinAttackRange.add(robot);
}
}
}
int nearbyFoes = foes.size();
int nearbyFoesInAttackRange = foesWithinAttackRange.size();
/*//check stats
double health = rc.getHealth();
int infectedTurns = rc.getInfectedTurns();
int robotsAlive = rc.getRobotCount();
*/
/*
* OUPUT
*/
// what to do
if (nearbyFoes == 0) // if there are no foes in sight
{
if (rc.getTeamParts() >= RobotType.TURRET.partCost) // build if you can
{
buildRobots();
} else {
if (maxParts > 0 && goal == null) // if there are parts nearby
{
// make that the goal
goal = nearbyLocationWithMostParts;
} else if (goal == null) // if there aren't and there is no goal
{
// build something or find new parts
// 80% build, 20% new parts
if (locationsWithParts.size() > 0 && rand.nextFloat() > .8) {
goal = locationsWithParts.get(0);
locationsWithParts.remove(0);
goalIsASafeLocation = false;
}
// calculate the next goal - maybe a new parts location you got via signal
} else if (goal != null) // if there is a goal, move there
{
moveToLocation(goal);
}
}
} else // there are foes nearby
{
// message for help!
if (Math.random() < probSignal) {
rc.broadcastSignal(archonInTroubleSignalRadiusSquared);
}
if (nearbyFoesInAttackRange > 0) {
goal = findSaferLocation();
rc.setIndicatorString(0, "" + goal.x + " " + goal.y);
goalIsASafeLocation = true;
moveToLocation(goal);
}
}
Clock.yield();
}
}
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);
}
}
}
}
protected void updateStatus() {
myRC.setIndicatorString(1, Integer.toString(enemyDistance));
myRC.setIndicatorString(2, state.name());
}
public static void run(RobotController rc) {
sightRadius = RobotType.SOLDIER.sensorRadiusSquared;
attackRadius = RobotType.SOLDIER.attackRadiusSquared;
myTeam = rc.getTeam();
enemyTeam = myTeam.opponent();
while (true) {
try {
numEnemySoldiers = 0;
totalEnemySoldierHealth = 0;
myLoc = rc.getLocation();
nearbyAllies = rc.senseNearbyRobots(sightRadius, myTeam);
nearbyEnemies = rc.senseHostileRobots(myLoc, sightRadius);
newArchonLoc = null;
// clear bad locations
resetLocations(rc);
// read messages and get destination
readMessages(rc);
// heal if need (and set the archon destination to go to)
setRetreatingStatus(rc, nearbyEnemies);
// Remove turret locations that you can see are not there.
// Does NOT remove turret locations due to broadcasts. Already done in read messages.
removeTurretLocations(rc);
if (newArchonLoc != null) {
nearestArchonLocation = newArchonLoc;
}
rc.setIndicatorString(2, "Round: " + rc.getRoundNum() + ", rushing: " + rush);
// Reset rushing if turns since rush is > 20 and see no more enemies.
if (rush && myLoc.distanceSquaredTo(rushLocation) <= 100) turnsSinceRush++;
if (turnsSinceRush > 20) {
if (rc.senseNearbyRobots(sightRadius, enemyTeam).length == 0) {
turnsSinceRush = 0;
rush = false;
}
}
// When rushing, be mad aggressive.
if (rush) {
rushMicro(rc, nearbyEnemies);
}
// When retreating, retreat
else if (healing) {
if (rc.isCoreReady()) {
if (nearestArchonLocation != null) {
if (myLoc.distanceSquaredTo(nearestArchonLocation) > 13) {
bugging.enemyAvoidMove(nearbyEnemies);
// Get away from archons that are not too close together.
} else if (myLoc.distanceSquaredTo(nearestArchonLocation) <= 2) {
Direction radialDir = nearestArchonLocation.directionTo(myLoc);
Direction awayDir = Movement.getBestMoveableDirection(radialDir, rc, 2);
if (awayDir != Direction.NONE) {
rc.move(awayDir);
}
}
}
}
// Make sure to attack people even when retreating.
// Prioritize the closest enemy. Then the closest zombie.
if (rc.isWeaponReady()) {
// Attack the closest enemy. If there is not one, then attack the closest zombie
int closestDist = 10000;
RobotInfo target = null;
for (RobotInfo hostile : nearbyEnemies) {
int dist = myLoc.distanceSquaredTo(hostile.location);
if (rc.canAttackLocation(hostile.location)) {
// There is already is a target
if (target != null) {
if (target.team == enemyTeam) {
// Target is already enemy, so prioritize the closest
if (hostile.team == enemyTeam) {
if (dist < closestDist) {
target = hostile;
closestDist = dist;
}
} // If hostile is not an enemy, not worth considering.
} else {
// Target is not on enemy team, so hostile is best choice!
if (hostile.team == enemyTeam) {
target = hostile;
closestDist = dist;
// Both are zombies, so just pick the closest.
} else {
if (dist < closestDist) {
target = hostile;
closestDist = dist;
}
}
}
// Set a target when there is not one.
} else {
target = hostile;
closestDist = dist;
}
}
}
// We know that if there is a target, we can attack it.
if (target != null) {
rc.attackLocation(target.location);
}
}
}
// When viper infected and will die from the infection, do special micro
else if (isViperInfected(rc)
&& (rc.getHealth() < rc.getViperInfectedTurns() * 2 || rc.getRoundNum() > 2100)) {
viperInfectedMicro(rc);
}
// if there are enemies in range, we should focus on attack and micro
else if (nearbyEnemies.length > 0) {
if (shouldLure(rc, nearbyEnemies, nearbyAllies)) luringMicro(rc);
else micro(rc);
} else { // otherwise, we should always be moving somewhere
moveSoldier(rc);
}
Clock.yield();
} catch (Exception e) {
e.printStackTrace();
}
}
}
protected void setIndicatorString(int i, String s) {
if (Config.DEBUG) {
int roundNum = rc.getRoundNum();
rc.setIndicatorString(i, String.format("%d: %s", roundNum, s));
}
}
/**
* @Nathan - Should we adjust these priorities (specifically where should building troops be?)
* TODO for archons - 1) repair nearest injured unit 2) signal turtle location 3) pick up adjacent
* parts and activate neutral units 4) move to turtle corner 5) build troops 6) run away from
* enemies
*
* @param rc
* @throws GameActionException
*/
private static void archon(RobotController rc) {
numArchons = rc.getInitialArchonLocations(myTeam).length;
turtleCorner = LOCATION_NONE;
while (true) {
try {
// 1) repair nearest injured unit
repairFirst(rc);
// 2) signal turtle location - every 25 turns
int broadcastRadius = rc.getType().sensorRadiusSquared * (2 + (rc.getRobotCount() / 50));
if (rc.getRoundNum() > 100 && rc.getRoundNum() % 30 == 0 && turtleCorner != LOCATION_NONE) {
rc.broadcastMessageSignal(turtleCorner.x, turtleCorner.y, broadcastRadius);
}
// @Nathan - Intro mode is all you -- I just pasted all the text into a separate method for
// clarity
if (turtleCorner != LOCATION_NONE && currentMode != TURTLE_MODE) {
currentMode = TRANSITION_MODE;
}
if (currentMode == INTRO_MODE) {
archonIntroMode(rc);
// if (turtleCorner.equals(LOCATION_NONE)) tryToLocateCorner(rc);
}
// 4) Move to turtle corner
if (currentMode == TRANSITION_MODE) {
if (rc.getLocation().distanceSquaredTo(turtleCorner) > 4) {
moveTowards(rc, rc.getLocation().directionTo(turtleCorner));
} else {
// TODO get in proper position
currentMode = TURTLE_MODE;
rc.broadcastMessageSignal(SENDING_MODE, TURTLE_MODE, rc.getType().sensorRadiusSquared);
}
}
// 5) Build Troops !
// @Nathan do we need to build more scouts in turtle mode so we can do more kiting?
boolean hasNearbyEnemies = isNearbyEnemies(rc);
if (!hasNearbyEnemies && rc.getRobotCount() - numArchons < NUM_INTRO_SCOUTS) {
tryToBuild(rc, RobotType.SCOUT);
Direction directionToTargetCorner = calculateDirectionToClosestCorner(rc);
rc.broadcastMessageSignal(
SENDING_TARGET_DIRECTION, DIRECTION_TO_SIGNAL.get(directionToTargetCorner), 4);
}
if ((rc.getRobotCount() <= 30 || hasNearbyEnemies)) {
tryToBuild(rc, RobotType.SOLDIER);
}
if (rc.getRobotCount() > 30 && !hasNearbyEnemies) {
tryToBuild(rc, RobotType.TURRET);
}
// 6) if senses enemy troop that is not a scout, run away from it
if (hasNearbyEnemies) moveAwayFromEnemies(rc);
// 3) Pick up parts on current square, check for adjacent parts and try to collect them
collectParts(rc);
// 3a) activate any nearby units
activateUnits(rc);
rc.setIndicatorString(0, "Turtle x: " + turtleCorner.x + "Turtle y: " + turtleCorner.y);
rc.setIndicatorString(1, "Current Mode" + currentMode);
Clock.yield(); // end turn
} catch (GameActionException e) {
e.printStackTrace();
}
}
}
// this method will advance one square towards a target and try to avoid enemies as much as
// possible
public static void avoidEnemiesMove(RobotController rc, MapLocation target) {
try {
// first we will find all enemy bots near us
GameObject[] nearByBots = rc.senseNearbyGameObjects(Robot.class, 15, rc.getTeam().opponent());
Direction direction = rc.getLocation().directionTo(target);
// if we don't see anything then lets head towards target
if (nearByBots.length == 0) {
// rc.setIndicatorString(2, "No enemies detected");
// rc.setIndicatorString(1, "x: "+target.x + " y: " + target.y);
direction = rc.getLocation().directionTo(target);
if (rc.canMove(direction)) // &&
// !rc.senseTerrainTile(rc.getLocation().add(direction).add(direction)).equals(TerrainTile.VOID))
{
if (rc.isActive()) {
rc.move(direction);
}
} else {
MapLocation target2 = rc.getLocation().add(direction);
if (rc.senseTerrainTile(target2).equals(TerrainTile.VOID)) {
int j = 0;
while (rc.senseTerrainTile(target2).equals(TerrainTile.VOID)) {
rc.setIndicatorString(0, "" + j);
j++;
target2 = target2.add(direction);
}
Utilities.MoveMapLocation(rc, target2, false);
}
/*
int distanceRight = 0;
int distanceLeft = 0;
direction = direction.rotateRight();
while (!rc.canMove(direction) && rc.senseTerrainTile(rc.getLocation().add(direction)).equals(TerrainTile.VOID))
{
direction = direction.rotateRight();
}
if (rc.isActive())
{
if (rc.canMove(direction))
{
rc.move(direction);
}
}
*/
}
}
// otherwise we need to avoid them
else {
rc.setIndicatorString(2, "Avoiding enemies");
rc.setIndicatorString(1, "Numb of Enemies: " + nearByBots.length);
// now we will calculate the distance form all 5 spots towards are target and the distance
// from that spot to all enemies we can see
// we will pick the one with the greatest distance
int[] distancesToLocations = new int[5];
for (int k = 0; k < distancesToLocations.length; k++) {
distancesToLocations[k] = 0;
}
MapLocation spot;
Direction newDir;
// first we look 90 to our right
newDir = direction.rotateRight().rotateRight();
for (int j = 0; j < 5; j++) {
if (rc.canMove(newDir)) {
spot = rc.getLocation().add(newDir);
for (int i = 0; i < nearByBots.length; i++) {
// System.out.println("entering for loop");
distancesToLocations[j] += spot.distanceSquaredTo(rc.senseLocationOf(nearByBots[i]));
}
} else {
distancesToLocations[j] = -123;
}
// every time through the loop we look one further to the left
newDir.rotateLeft();
}
int indexOfLargest = 0;
int largest = distancesToLocations[0];
for (int j = 1; j < distancesToLocations.length; j++) {
if (largest < distancesToLocations[j]) {
indexOfLargest = j;
largest = distancesToLocations[j];
}
}
// now we orientate newDir to the right spot
newDir = direction.rotateRight().rotateRight();
for (int i = 0; i <= indexOfLargest; i++) {
newDir = newDir.rotateLeft();
}
while (!rc.isActive()) {
rc.yield();
}
// now we can finally move
if (rc.isActive()) {
if (rc.canMove(newDir)) {
rc.move(newDir);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}