/** * 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(); } }
/** * Archon checks within a squared radius of 9 for neutral units. If neutral archon, always head * toward and activate. If no neutral archons are detected, activate adjacent units. If no * adjacent units, move towards nearest neutral unit. * * @param rc must be archon * @return if activated a unit * @throws GameActionException */ private static void activateUnits(RobotController rc) throws GameActionException { if (rc.isCoreReady()) activateFirst(rc); int lowestDistanceIndex = 0; MapLocation myLocation = rc.getLocation(); MapLocation robotLocation; RobotInfo[] robots = rc.senseNearbyRobots(ACTIVATION_RADIUS_SQUARED, Team.NEUTRAL); for (int i = 0; i < robots.length; i++) { robotLocation = robots[i].location; if (rc.isCoreReady() && robots[i].type == RobotType.ARCHON) { if (myLocation.isAdjacentTo(robotLocation)) { rc.activate(robotLocation); } else { moveTowards(rc, myLocation.directionTo(robotLocation)); } } if (robots[i].type != RobotType.ARCHON) { lowestDistanceIndex = myLocation.distanceSquaredTo(robotLocation) < myLocation.distanceSquaredTo(robots[lowestDistanceIndex].location) ? i : lowestDistanceIndex; } } if (rc.isCoreReady() && robots.length > 0) { if (myLocation.isAdjacentTo(robots[lowestDistanceIndex].location)) { rc.activate(robots[lowestDistanceIndex].location); } else { moveTowards(rc, myLocation.directionTo(robots[lowestDistanceIndex].location)); } } }
// All combat units (Soldiers, Bashers, Tanks, Drones, Launchers, Commander) private static void runCombat() { while (true) { threats.update(); myLoc = rc.getLocation(); // Move if we can and want to if (rc.isCoreReady()) { boolean ignoreThreat = overwhelms(); if (!ignoreThreat && shouldRetreat()) { if (rc.isWeaponReady() && myType.loadingDelay == 0) attackWeakest(); doRetreatMove(); // Pull back if in range of the enemy guns } else { boolean engaged = false; if (rc.isCoreReady() && inCombat(4)) engaged = doCloseWithEnemyMove(ignoreThreat); if (rc.isCoreReady() && !engaged) // Close with enemy might not do a move if the enemy is a drone out of // reach doAdvanceMove(); } } // Attack if there is an enemy in sight if (myType == RobotType.LAUNCHER) doLaunch(); else if (rc.isWeaponReady()) attackWeakest(); doTransfer(); rc.yield(); } }
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(); } }
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 broadcastRecordedEnemy(RobotController rc, RobotInfo enemy) throws GameActionException { if (enemy.type == RobotType.ARCHON && rc.isCoreReady()) { Message.sendMessageGivenDelay(rc, enemy.location, Message.ENEMYARCHONLOC, 0.25); } else if (enemy.team == Team.ZOMBIE && enemy.type != RobotType.RANGEDZOMBIE && rc.isCoreReady()) { Message.sendMessageGivenDelay(rc, enemy.location, Message.ZOMBIE, 0.25); } else if (enemy.type == RobotType.TURRET && rc.isCoreReady()) { Message.sendMessageGivenDelay(rc, enemy.location, Message.TURRET, 0.25); } else if (rc.isCoreReady()) { Message.sendMessageGivenDelay(rc, enemy.location, Message.ENEMY, 0.25); } }
private static void moveFromCorner(RobotController rc) throws GameActionException { int minRadius = 9; // units should try to maintain a minimum of 5 squared units // away from corner // @Hope - refine max radius int maxRadius = 26 + (int) Math.pow(rc.getRobotCount() / 6, 2); // based of number // of troops the max radius increases int distanceToCorner = rc.getLocation().distanceSquaredTo(turtleCorner); if (distanceToCorner <= minRadius && rc.isCoreReady()) { Direction dir = (rc.getLocation().directionTo(turtleCorner)).opposite(); moveTowards(rc, dir); } if (distanceToCorner >= maxRadius && rc.isCoreReady()) { moveTowards(rc, rc.getLocation().directionTo(turtleCorner)); } }
// TODO this method needs a lot of work...isn't doing things properly even if there's just an // archon making bots with open space around it. Add onto that later, when there are more bots // around, // others will need to move forward in order for those just next to the archon to move. private static void moveAwayFromArchons(RobotController rc) throws GameActionException { int mySenseRadius = rc.getType().sensorRadiusSquared; int archonReserveDistance = 9; // @Hope make this more finessed archonReserveDistance = archonReserveDistance < mySenseRadius ? archonReserveDistance : mySenseRadius; List<RobotInfo> robots = Arrays.asList(rc.senseNearbyRobots(archonReserveDistance, myTeam)); List<RobotInfo> archons = new ArrayList<>(); for (RobotInfo robot : robots) { if (robot.type == RobotType.ARCHON) { archons.add(robot); } } boolean tooClose = false; MapLocation myLocation = rc.getLocation(); for (RobotInfo archon : archons) { if (!tooClose && myLocation.distanceSquaredTo(archon.location) < archonReserveDistance) { tooClose = true; } } if (tooClose) { for (RobotInfo archon : archons) { if (rc.isCoreReady()) moveTowards(rc, rc.getLocation().directionTo(archon.location).opposite()); } } }
protected boolean tryBuild(RobotType robotType, Direction initialDirection) throws GameActionException { if (!rc.isCoreReady()) { return false; } if (rc.getTeamParts() < robotType.partCost) { return false; } int startingPosition = getDirectionNumber(initialDirection); if (startingPosition < 0) { startingPosition = 0; } int[] d = {0, 1, 7, 2, 6, 3, 5, 4}; for (int i = 0; i < 8; i++) { Direction direction = directions[(startingPosition + d[i]) % 8]; if (rc.canBuild(direction, robotType)) { rc.build(direction, robotType); return true; } } return false; }
private static void broadcastCollectibles(RobotController rc, boolean thereAreEnemies) throws GameActionException { MapLocation[] parts = rc.sensePartLocations(sightRange); RobotInfo[] neutrals = rc.senseNearbyRobots(sightRange, Team.NEUTRAL); MapLocation closestCollectible = null; int closestDist = 10000; for (MapLocation part : parts) { if (previouslyBroadcastedPartLoc != null) { if (part.distanceSquaredTo(previouslyBroadcastedPartLoc) <= 35) continue; } int dist = myLoc.distanceSquaredTo(part); if (dist < closestDist) { closestDist = dist; closestCollectible = part; } } for (RobotInfo neutral : neutrals) { if (previouslyBroadcastedPartLoc != null) { if (neutral.location.distanceSquaredTo(previouslyBroadcastedPartLoc) <= 35) continue; } int dist = myLoc.distanceSquaredTo(neutral.location); if (dist < closestDist) { closestDist = dist; closestCollectible = neutral.location; } } if (closestCollectible != null && rc.isCoreReady()) { if (thereAreEnemies) { Message.sendMessageGivenDelay(rc, closestCollectible, Message.COLLECTIBLES, 0.3); } else { Message.sendMessageGivenDelay(rc, closestCollectible, Message.COLLECTIBLES, 8.65); } previouslyBroadcastedPartLoc = closestCollectible; } }
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); } } }
// Drones private static void runDrone() { moveDir = Direction.NORTH; droneMoveCurrent = 1; droneMoveMax = 2; patrolClockwise = true; droneCentred = false; // We haven't made it to the centre of our spiral yet while (true) { threats.update(); myLoc = rc.getLocation(); // Attack if there is an enemy in sight if (rc.isWeaponReady()) attackWeakest(); // Move if we can and want to if (rc.isCoreReady()) { if (shouldRetreat()) { doRetreatMove(); // Pull back if in range of the enemy guns } else if (Clock.getRoundNum() < 600) { doPatrol(); } else { doSupply(); } } doTransfer(); rc.yield(); } }
// 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); } } }
/** * 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; }
// Beavers private static void runBeaver() { strategy = new BuildStrategy(rc); rand = new Random(rc.getID()); while (true) { threats.update(); myLoc = rc.getLocation(); if (rc.isCoreReady()) { RobotType build = strategy.getBuildOrder(); if (build != null) tryBuild(rc.getLocation().directionTo(threats.enemyHQ), build); } // Attack if there is an enemy in sight if (rc.isWeaponReady()) attackWeakest(); double ore = rc.senseOre(rc.getLocation()); // Move if we can and want to if (rc.isCoreReady()) { boolean ignoreThreat = overwhelms(); if (!ignoreThreat && shouldRetreat()) { doRetreatMove(); // Pull back if in range of the enemy guns } else { doMinerMove(); if (ore == 0 && rc.isCoreReady()) { // We didn't find ore nearby doSearchMove(); } } } // Mine if possible if (rc.isCoreReady() && ore > 0) { try { rc.mine(); } catch (GameActionException e) { System.out.println("Mining Exception"); // e.printStackTrace(); } } doTransfer(); rc.yield(); } }
private static void leadZombiesToEnemy(RobotController rc) throws GameActionException { // TODO stop anti-kiting if (rc.isCoreReady()) { if (rc.canMove(Direction.SOUTH_WEST)) { rc.move(Direction.SOUTH_WEST); } } }
/** * 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 enemyMicro(RobotController rc, RobotInfo bestEnemy) throws GameActionException { // Prioritize movement Direction d = myLoc.directionTo(bestEnemy.location); if (rc.isCoreReady()) { if (rc.getHealth() > (numEnemySoldiers + 1) * RobotType.SOLDIER.attackPower) { // If the enemy can be killed but we're not in range, move forward if (!rc.canAttackLocation(bestEnemy.location) && bestEnemy.health <= RobotType.SOLDIER.attackPower) { 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()); } // If not in range, see if we should move in by comparing soldier health } else { double totalOurSoldierHealth = 0; RobotInfo[] allies = rc.senseNearbyRobots(bestEnemy.location, 18, rc.getTeam()); for (RobotInfo ally : allies) { if (ally.type == RobotType.SOLDIER) { if (ally.health > numEnemySoldiers * RobotType.SOLDIER.attackPower) { totalOurSoldierHealth += ally.health; } } } // If we feel that we are strong enough, rush in. if (totalOurSoldierHealth > totalEnemySoldierHealth) { if (!rc.canAttackLocation(bestEnemy.location)) { 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()); } } } else if (4 * totalOurSoldierHealth < 3 * totalEnemySoldierHealth) { if (rc.canMove(d.opposite())) { rc.move(d.opposite()); } else if (rc.canMove(d.opposite().rotateLeft())) { rc.move(d.opposite().rotateLeft()); } else if (rc.canMove(d.opposite().rotateRight())) { rc.move(d.opposite().rotateRight()); } } } } } // Attack whenever you can if (rc.isWeaponReady()) { if (rc.canAttackLocation(bestEnemy.location)) { broadcastingAttack(rc, bestEnemy); } } }
// 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); } } } } }
// build a robot of a given type public static void buildRobot(RobotType type) throws GameActionException { if (rc.isCoreReady() && rc.hasBuildRequirements(type)) { Direction[] values = Direction.values(); for (Direction dir : values) { if (rc.canBuild(dir, type)) { rc.build(dir, type); return; } } } }
static void move(RobotController rc) throws GameActionException { int rand = Common.rand.nextInt(9); Direction dir; if (rand == 8 && last != null) dir = last; else dir = Common.DIRECTIONS[rand]; dir = Common.findPathDirection(rc, dir); if (rc.isCoreReady() && rc.canMove(dir)) { Common.move(rc, dir); last = dir; } }
/** * If rc has no core delay, attempts to move towards the first allied archon sensed. Does not move * if rc is already within ARCHON_RESERVED_DISTANCE_SQUARED of the archon * * @param rc * @return true if rc moves else false * @throws GameActionException */ private static void moveTowardsArchon(RobotController rc) throws GameActionException { RobotInfo[] nearbyRobots = rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, myTeam); for (int i = 0; i < nearbyRobots.length; i++) { if (nearbyRobots[i].type == (RobotType.ARCHON) && rc.isCoreReady()) { if (nearbyRobots[i].location.distanceSquaredTo(rc.getLocation()) > ARCHON_RESERVED_DISTANCE_SQUARED) { Direction dir = rc.getLocation().directionTo(nearbyRobots[i].location); moveTowards(rc, dir); } } } }
private static void moveAwayFromEnemies(RobotController rc) throws GameActionException { // TODO might want a different value for how far you sense enemies and // do a "center of mass" of enemies weighted by their attack values then // move away from that? RobotInfo[] enemies = rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, myTeam.opponent()); for (int i = 0; i < enemies.length; i++) { if (rc.isCoreReady()) { Direction awayFrom = rc.getLocation().directionTo(enemies[0].location).opposite(); moveTowards(rc, awayFrom); } } }
/* * 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(); } }
/** * @param rc * @return true if rc moves else false * @throws GameActionException */ private static void moveTowardsNearestEnemy(RobotController rc) throws GameActionException { List<RobotInfo> enemies = Arrays.asList(rc.senseHostileRobots(rc.getLocation(), -1)); Optional<RobotInfo> nearestEnemy = enemies .stream() .min( (enemy1, enemy2) -> rc.getLocation().distanceSquaredTo(enemy1.location) - rc.getLocation().distanceSquaredTo(enemy2.location)); if (nearestEnemy.isPresent() && rc.isCoreReady()) { moveTowards(rc, rc.getLocation().directionTo(nearestEnemy.get().location)); } }
public static boolean getToAdjParts(RobotController rc) throws GameActionException { if (rc.isCoreReady()) { MapLocation myLoc = rc.getLocation(); MapLocation[] squaresAdj = MapLocation.getAllMapLocationsWithinRadiusSq(rc.getLocation(), 2); for (MapLocation sq : squaresAdj) { if ((rc.senseParts(sq) > 0) && (rc.canMove(myLoc.directionTo(sq)))) { rc.move(myLoc.directionTo(sq)); return true; } } } return false; }
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()); }
/** * Checks if rc can move in direction dir (runs isCoreReady and canMove). If so, moves. If not, * moves rc in any of the four directions nearest dir, if possible. * * @param rc * @param dir * @return true if rc moves else false * @throws GameActionException */ private static void moveTowards(RobotController rc, Direction dir) throws GameActionException { if (rc.isCoreReady() && !dir.equals(Direction.OMNI) && !dir.equals(Direction.NONE)) { Direction[] moveRight = { dir, dir.rotateRight(), dir.rotateLeft(), dir.rotateRight().rotateRight(), dir.rotateLeft().rotateLeft() }; Direction[] moveLeft = { dir, dir.rotateLeft(), dir.rotateRight(), dir.rotateLeft().rotateLeft(), dir.rotateRight().rotateRight() }; Direction[] nearDirections = Math.random() >= .5 ? moveRight : moveLeft; // 50% chance robot tries to move to right first for (Direction nearDir : nearDirections) { if (rc.canMove(nearDir) && rc.isCoreReady()) { rc.move(nearDir); } } if (rc.getType() != RobotType.TTM && rc.getType() != RobotType.TTM) // these types can't clear rubble { if (rc.isCoreReady() && rc.onTheMap(rc.getLocation().add(dir)) && rc.senseRubble(rc.getLocation().add(dir)) > RUBBLE_LOWER_CLEAR_THRESHOLD) { clearRubble(rc); } } } }
/** * If rc finds a zombie den, it signals out to surrounding robots If rc has no weapon delay, * attacks in the following priority: 1) adjacent robots (if robot is a bigzombie or standard * zombie move away every other turn to kite it) 2) big zombies 3) nearest enemy * * @param rc RobotController which will attack * @param RobotController * @throws GameActionException * @return true if this robot attacked else false */ private static void attackFirst(RobotController rc) throws GameActionException { boolean equalHealth = true; int lowestHealthIndex = -1; int lowestDistanceIndex = -1; int attackIndex = -1; RobotInfo[] enemies = rc.senseHostileRobots(rc.getLocation(), rc.getType().attackRadiusSquared); if (rc.isWeaponReady() && enemies.length > 0) { for (int i = 0; i < enemies.length; i++) { if (enemies[i].type == RobotType.ZOMBIEDEN) { rc.broadcastSignal(rc.getType().sensorRadiusSquared * 2); } if (attackIndex < 0 && (rc.getLocation()).isAdjacentTo(enemies[i].location)) { attackIndex = i; // TODO test this part - work on kiting if ((enemies[i].type == RobotType.BIGZOMBIE || enemies[i].type == RobotType.STANDARDZOMBIE) && rc.getRoundNum() % 2 == 0 && rc.isCoreReady()) { moveAwayFromEnemy(rc, rc.getLocation().directionTo(enemies[i].location)); } if (rc.isWeaponReady()) { rc.attackLocation(enemies[i].location); } } if (rc.isWeaponReady() && enemies[i].type == RobotType.BIGZOMBIE) { attackIndex = i; rc.attackLocation(enemies[i].location); } if (attackIndex < 0) { lowestHealthIndex = lowestHealthIndex < 0 ? 0 : lowestHealthIndex; lowestDistanceIndex = lowestDistanceIndex < 0 ? 0 : lowestDistanceIndex; equalHealth = equalHealth && enemies[i].health == enemies[lowestHealthIndex].health; lowestDistanceIndex = rc.getLocation().distanceSquaredTo(enemies[i].location) < rc.getLocation().distanceSquaredTo(enemies[lowestDistanceIndex].location) ? i : lowestDistanceIndex; lowestHealthIndex = enemies[i].health < enemies[lowestHealthIndex].health ? i : lowestHealthIndex; } } if (attackIndex < 0 && enemies.length > 0) { attackIndex = equalHealth ? lowestDistanceIndex : lowestHealthIndex; } if (attackIndex >= 0 && rc.isWeaponReady()) { rc.attackLocation(enemies[attackIndex].location); } } }
// Factories and supply depots private static void runBuilding() { // Most builds spawn units if (myType.canSpawn()) strategy = new BuildStrategy(rc); while (true) { if (rc.isCoreReady() && myType.canSpawn()) { threats.update(); RobotType build = strategy.getBuildOrder(); if (build != null) trySpawn(rc.getLocation().directionTo(threats.enemyHQ), build); } doTransfer(); rc.yield(); } }