private static void shallWeAllIn() throws GameActionException { if (rc.senseEnemyNukeHalfDone() && Clock.getRoundNum() < 300) { rc.broadcast(Constants.attackChannel, Constants.attackAllIn); return; } int massedRobos = 0; double massedAmountNeeded = .5 * (40 + (10 * gencount) - (1 * othercount)); if (rc.senseEnemyNukeHalfDone()) massedAmountNeeded -= 10; int rallyRadius = 33; if (massedAmountNeeded > 50) rallyRadius = 63; Robot[] robos = rc.senseNearbyGameObjects(Robot.class, findRallyPoint(), rallyRadius, rc.getTeam()); for (Robot r : robos) { if (rc.senseRobotInfo(r).type == RobotType.SOLDIER) { ++massedRobos; } } if (massedRobos > massedAmountNeeded) // if we should all in... { rc.broadcast(Constants.attackChannel, Constants.attackAllIn); allInRound = Clock.getRoundNum(); } }
// After a little while, if nothing has gone wrong, if we are next to a pastr and no one // else is building or has built a noise tower, build one. private boolean tryBuildNoiseTower() throws GameActionException { if (!rc.isActive()) return false; if (Clock.getRoundNum() < 200) return false; if (rc.senseRobotCount() < 6) return false; // A problem with building a noise tower is that it makes us more vulnerable to // a rush. If it's early and the opponent hasn't build a pastr, let's hold off // in case it means that they are rushing. if (Clock.getRoundNum() < 300 && rc.sensePastrLocations(them).length == 0) return false; // Only allowed to build noise tower if adjacent to pastr MapLocation[] ourPastrs = rc.sensePastrLocations(us); if (ourPastrs.length == 0 || !here.isAdjacentTo(ourPastrs[0])) return false; // Check if someone else is already building a noise tower MapLocation existingBuilder = MessageBoard.BUILDING_NOISE_TOWER.readMapLocation(); if (existingBuilder != null) { if (rc.senseNearbyGameObjects(Robot.class, existingBuilder, 1, us).length > 0) { return false; } } // Construct the noise tower and advertise the fact that we are doing it MessageBoard.BUILDING_NOISE_TOWER.writeMapLocation(here); constructNoiseTower(ourPastrs[0]); return true; }
public static boolean doWeNeedGenerator() throws GameActionException { if (rc.readBroadcast(Constants.campChannel) == Constants.campGenInProduction) return false; if (Clock.getRoundNum() - allInRound < 80) return false; if (rc.readBroadcast(Constants.commandChannel) == Constants.commandRally && rc.getTeamPower() > powerThreshold) return false; if (rc.getTeamPower() < minPowerThreshold && Clock.getRoundNum() > minRoundThreshold) { return true; } gencount = 0; soldiercount = 0; othercount = 0; Robot[] robos = rc.senseNearbyGameObjects(Robot.class, new MapLocation(0, 0), 1000000, rc.getTeam()); for (Robot r : robos) { RobotType rt = rc.senseRobotInfo(r).type; if (rt == RobotType.GENERATOR) ++gencount; else if (rt == RobotType.SOLDIER) ++soldiercount; else ++othercount; } double decay = .8; if (rc.hasUpgrade(Upgrade.FUSION)) { decay = .99; } if ((40 + (10 * gencount) - (1.6 * soldiercount) - (1 * othercount)) * decay < 1) { return true; } return false; }
// HQ or pastr calls this function to spend spare bytecodes computing paths for soldiers public static void work(MapLocation dest, int priority, int bytecodeLimit) throws GameActionException { int page = findFreePage(dest, priority); Debug.indicate("path", 1, "BFS Pathing to " + dest.toString() + "; using page " + page); if (page == -1) return; // We can't do any work, or don't have to if (!dest.equals(previousDest)) { Debug.indicate("path", 0, "BFS initingQueue"); initQueue(dest); } else { Debug.indicate("path", 0, "BFS queue already inited"); } previousDest = dest; previousRoundWorked = Clock.getRoundNum(); previousPage = page; int mapWidth = rc.getMapWidth(); int mapHeight = rc.getMapHeight(); MapLocation enemyHQ = rc.senseEnemyHQLocation(); boolean destInSpawn = dest.distanceSquaredTo(enemyHQ) <= 25; while (locQueueHead != locQueueTail && Clock.getBytecodeNum() < bytecodeLimit) { // pop a location from the queue MapLocation loc = locQueue[locQueueHead]; locQueueHead++; int locX = loc.x; int locY = loc.y; for (int i = 8; i-- > 0; ) { int x = locX + dirsX[i]; int y = locY + dirsY[i]; if (x >= 0 && y >= 0 && x < mapWidth && y < mapHeight && !wasQueued[x][y]) { MapLocation newLoc = new MapLocation(x, y); if (rc.senseTerrainTile(newLoc) != TerrainTile.VOID && (destInSpawn || !Bot.isInTheirHQAttackRange(newLoc))) { publishResult(page, newLoc, dest, dirs[i]); // push newLoc onto queue locQueue[locQueueTail] = newLoc; locQueueTail++; wasQueued[x][y] = true; } } } } boolean finished = locQueueHead == locQueueTail; Debug.indicate("path", 2, "BFS finished = " + finished + "; locQueueHead = " + locQueueHead); writePageMetadata(page, Clock.getRoundNum(), dest, priority, finished); }
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(); } }
// 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(); } }
public void turn() throws GameActionException { updateStrategicInfo(); // First turn gets special treatment: spawn then do a bunch of computation // (which we devoutly hope will finished before the spawn timer is up // and before anyone attacks us). if (Clock.getRoundNum() == 0) { doFirstTurn(); return; } if (rc.isActive()) { spawnSoldier(); } attackEnemies(); directStrategy(); // Use spare bytecodes to do pathing computations MapLocation pathingDest; if (attackModeTarget != null) pathingDest = attackModeTarget; else if (computedBestPastrLocation != null) pathingDest = computedBestPastrLocation; else pathingDest = null; if (pathingDest != null) Bfs.work(pathingDest, rc, 9000); }
public static void run(RobotController myRC) { BaseRobot br = null; try { switch (myRC.getType()) { case HQ: br = new HQRobot(myRC); break; case SOLDIER: br = new SoldierRobot(myRC); break; case ARTILLERY: br = new Artillery(myRC); break; default: br = new PassiveEncampment(myRC); } while (true) { br.curRound = Clock.getRoundNum(); br.run(); br.rc.yield(); } } catch (Exception e) { // DEBUG System.out.println("Shit happened!"); e.printStackTrace(); br.rc.addMatchObservation(e.toString()); } }
private int findFreePage(MapLocation dest, int priority) throws GameActionException { // see if we can reuse a page we used before if (dest.equals(previousDest) && previousPage != -1) { int previousPageMetadata = readPageMetadata(previousPage); if (getMetadataRoundLastUpdated(previousPageMetadata) == previousRoundWorked) { MapLocation where = getMetadataDestination(previousPageMetadata); if (where.x == cropX(dest.x) && where.y == cropY(dest.y)) { if (getMetadataIsFinished(previousPageMetadata)) { if (getMetadataIsComplete(previousPageMetadata)) return -1; // we're done! don't do any work! // Restart the search with more up to data map info initQueue(dest); // System.out.print("Restart BFS to " + dest + ", page " + previousPage+ ", start round // " + Clock.getRoundNum() + "\n"); return previousPage; } else { return previousPage; } } } } // Check to see if anyone else is working on this destination. If so, don't bother doing // anything. // But as we loop over pages, look for the page that hasn't been touched in the longest time int lastRound = Clock.getRoundNum() - 1; int oldestPage = -1; int oldestPageRoundUpdated = 999999; for (int page = 0; page < NUM_PAGES; page++) { int metadata = readPageMetadata(page); if (metadata == 0) { // untouched page if (oldestPageRoundUpdated > 0) { oldestPage = page; oldestPageRoundUpdated = 0; } } else { int roundUpdated = getMetadataRoundLastUpdated(metadata); boolean isFinished = getMetadataIsFinished(metadata); if (roundUpdated >= lastRound || isFinished) { if (cropSame(getMetadataDestination(metadata), dest)) { return -1; // someone else is on the case! } } if (roundUpdated < oldestPageRoundUpdated) { oldestPageRoundUpdated = roundUpdated; oldestPage = page; } } } // No one else is working on our dest. If we found an inactive page, use that one. if (oldestPage != -1 && oldestPageRoundUpdated < lastRound) return oldestPage; // If there aren't any inactive pages, and we have high priority, just trash page 0: if (priority == PRIORITY_HIGH) return 0; // otherwise, give up: return -1; }
public static void run(RobotController myRC) { rc = myRC; barracks = findBarracks(); while (true) { try { if (rc.getType() == RobotType.SOLDIER) { Robot[] enemyRobots = rc.senseNearbyGameObjects( Robot.class, 50000, rc.getTeam().opponent()); // list of enemy robots if (enemyRobots.length == 0) { Clock.getRoundNum(); // gets the round number if (Clock.getRoundNum() < 250) { goToLocation( barracks); // if you are before round 250 travel to the "barracks" or meeting // place. } else { goToLocation(rc.senseEnemyHQLocation()); } } else { // else attack the closest enemy int closestDist = 50000; MapLocation closestEnemy = null; for (int i = 0; i < enemyRobots.length; i++) { Robot enemyBot = enemyRobots[i]; RobotInfo arobotInfo = rc.senseRobotInfo(enemyBot); int dist = arobotInfo.location.distanceSquaredTo(rc.getLocation()); if (dist < closestDist) { closestDist = dist; closestEnemy = arobotInfo.location; } } goToLocation(closestEnemy); } } else { HqCommand(); } } catch (Exception e) { e.printStackTrace(); } rc.yield(); // end turn } }
public static void timerEnd(String message) { int endBytecodeNum = Clock.getBytecodeNum(); int endRoundNum = Clock.getRoundNum(); if (endRoundNum == startRoundNum) System.out.format( "timed %s: took %d bytecodes\n", message, endBytecodeNum - startBytecodeNum); else System.out.format( "timed %s: took %d turns + %d bytecodes\n", message, endRoundNum - startRoundNum, endBytecodeNum - startBytecodeNum); }
public void enemyInSight( MapLocation[] locations, int[] ints, String[] strings, int locationStart, int intStart, int stringStart, int count) { closestEnemySeen = Clock.getRoundNum(); closestEnemy = navigation.findClosest(locations, locationStart); }
public void herdInward() throws GameActionException { radius = 20 - Math.min(13, (Clock.getRoundNum() % 120) * 16.0 / 120.0); MapLocation target = new MapLocation( (int) (here.x + radius * Math.cos(angle)), (int) (here.y + radius * Math.sin(angle))); angle += rate; rc.setIndicatorString(0, "angle = " + angle); if (rc.canAttackSquare(target)) { rc.attackSquare(target); } }
private static void turn() throws GameActionException { if (rc.getHealth() <= 6 * RobotType.SOLDIER.attackPower) { MessageBoard.PASTR_DISTRESS_SIGNAL.writeInt(Clock.getRoundNum()); } // do speculative pathing calculations int bytecodeLimit = 9000; MapLocation[] enemyPastrs = rc.sensePastrLocations(them); for (int i = 0; i < enemyPastrs.length; i++) { if (Clock.getBytecodeNum() > bytecodeLimit) break; Bfs.work(enemyPastrs[i], Bfs.PRIORITY_LOW, bytecodeLimit); } }
private static int findFreePage(MapLocation dest, int priority) throws GameActionException { // see if we can reuse a page we used before if (dest.equals(previousDest) && previousPage != -1) { int previousPageMetadata = readPageMetadata(previousPage); if (getMetadataRoundLastUpdated(previousPageMetadata) == previousRoundWorked && getMetadataDestination(previousPageMetadata).equals(dest)) { if (getMetadataIsFinished(previousPageMetadata)) { return -1; // we're done! don't do any work! } else { return previousPage; } } } // Check to see if anyone else is working on this destination. If so, don't bother doing // anything. // But as we loop over pages, look for the page that hasn't been touched in the longest time int lastRound = Clock.getRoundNum() - 1; int oldestPage = -1; int oldestPageRoundUpdated = 999999; for (int page = 0; page < NUM_PAGES; page++) { int metadata = readPageMetadata(page); if (metadata == 0) { // untouched page if (oldestPageRoundUpdated > 0) { oldestPage = page; oldestPageRoundUpdated = 0; } } else { int roundUpdated = getMetadataRoundLastUpdated(metadata); boolean isFinished = getMetadataIsFinished(metadata); if (roundUpdated >= lastRound || isFinished) { if (getMetadataDestination(metadata).equals(dest)) { return -1; // someone else is on the case! } } if (roundUpdated < oldestPageRoundUpdated) { oldestPageRoundUpdated = roundUpdated; oldestPage = page; } } } // No one else is working on our dest. If we found an inactive page, use that one. if (oldestPage != -1 && oldestPageRoundUpdated < lastRound) return oldestPage; // If there aren't any inactive pages, and we have high priority, just trash page 0: if (priority == PRIORITY_HIGH) return 0; // otherwise, give up: return -1; }
// Launch a missile if there is an enemy in sight. // We ignore other missiles private static void doLaunch() { int count = rc.getMissileCount(); if (count > 0 && Clock.getRoundNum() % 2 == 0) { MapLocation launchFrom; // We can launch 1 tile towards the enemy MapLocation explodeAt; // We can explode adjacent to the enemy (1 tile towards us) int missileRange = 30; RobotInfo[] enemies = rc.senseNearbyRobots(49, enemyTeam); MapLocation target = null; for (RobotInfo r : enemies) { if (r.type != RobotType.MISSILE) { // Ignore missiles launchFrom = myLoc.add(myLoc.directionTo(r.location)); explodeAt = r.location.add(r.location.directionTo(myLoc)); if (launchFrom.distanceSquaredTo(explodeAt) <= missileRange) { target = r.location; break; } } } if (target == null) { // Check for towers for (MapLocation t : threats.enemyTowers) { launchFrom = myLoc.add(myLoc.directionTo(t)); explodeAt = t.add(t.directionTo(myLoc)); if (launchFrom.distanceSquaredTo(explodeAt) <= missileRange) { target = t; break; } } if (target == null) { // Check for HQ MapLocation ehq = threats.enemyHQ; launchFrom = myLoc.add(myLoc.directionTo(ehq)); explodeAt = ehq.add(ehq.directionTo(myLoc)); if (launchFrom.distanceSquaredTo(explodeAt) <= missileRange) target = ehq; } } if (target != null) { try { Direction d = myLoc.directionTo(target); if (rc.canLaunch(d)) { rc.launchMissile(d); } } catch (GameActionException e) { System.out.println("Launch exception"); e.printStackTrace(); } } } }
@Override public void run() { while (true) { try { } catch (Exception e) { System.out.println( "Robot " + myRC.getRobot().getID() + " during round number " + Clock.getRoundNum() + " caught exception:"); e.printStackTrace(); } } }
/* * 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; }
// 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); } }
public static void init() { m_w = 12987394 + 183639462 * Clock.getRoundNum(); /* must not be zero, nor 0x464fffff */ m_z = 87692688 + 129348760 * Clock.getRoundNum(); /* must not be zero, nor 0x9068ffff */ }
public class SoldierBehavior extends RobotBehavior { enum Role { LEFTLEFT, LEFTRIGHT, RIGHTLEFT, RIGHTRIGHT, PASTR, NONE }; enum Mode { GOING_TO_MIDDLE, SWEEP_OUT, RETURN_HOME, STAND_RICH_LOC, FIND_PASTR_LOC, BUILD_PASTR, ACQUIRE_TARGET, ENGAGE, BIRTH_DECIDE_MODE }; // basic data int bornRound = Clock.getRoundNum(); Mover mover = new Mover(); // state machine stuff Mode mode; int roleIndex; Role role; /** true if this is the first sweep attempt, false afterwards. */ boolean initialSweep; /** true if we're panicking to build pastures at the end */ boolean panicPastrBuilding; /** whether we're done building */ boolean buildingFinished = false; /** whether to sneak to where the building should be built */ int sneakToBuildingLoc = 0; // map locations MapLocation dest; static final MapLocation middle = new MapLocation(ALLY_HQ.x + HQ_DX / 2, ALLY_HQ.y + HQ_DY / 2); static final MapLocation leftleft = new MapLocation(ALLY_HQ.x + HQ_DX / 3 - HQ_DY / 3, ALLY_HQ.y + HQ_DY / 3 + HQ_DX / 3); static final MapLocation leftright = new MapLocation(ALLY_HQ.x + HQ_DX / 3 - HQ_DY / 5, ALLY_HQ.y + HQ_DY / 3 + HQ_DX / 5); static final MapLocation rightleft = new MapLocation(ALLY_HQ.x + HQ_DX / 3 + HQ_DY / 5, ALLY_HQ.y + HQ_DY / 3 - HQ_DX / 5); static final MapLocation rightright = new MapLocation(ALLY_HQ.x + HQ_DX / 3 + HQ_DY / 3, ALLY_HQ.y + HQ_DY / 3 - HQ_DX / 3); static final Role[] roleList = {Role.LEFTLEFT, Role.LEFTRIGHT, Role.RIGHTLEFT, Role.RIGHTRIGHT}; static final MapLocation[] roleLocList = {leftleft, leftright, rightleft, rightright}; public SoldierBehavior() { role = Role.NONE; changeMode(Mode.BIRTH_DECIDE_MODE); } @Override protected void initMessageHandlers() { handlers[MessageType.ATTACK_LOCATION.ordinal()] = new MessageHandler() { @Override public void handleMessage(int[] message) { MapLocation loc = new MapLocation(message[0], message[1]); // TODO: attack! } }; } @Override public void beginRound() throws GameActionException { updateUnitUtils(); // turn into a pasture or noise tower if (buildingFinished) { RobotPlayer.run(RC); } messagingSystem.beginRound(handlers); } @Override public void run() throws GameActionException { if (luge()) { // luge = micro // set mode to ATTACK or something return; // send message? } else if (mode != Mode.ENGAGE && mode != Mode.ACQUIRE_TARGET && mode != Mode.BIRTH_DECIDE_MODE && mode != Mode.FIND_PASTR_LOC && mode != Mode.BUILD_PASTR) { if (ENEMY_MILK - ALLY_MILK > 50000 || ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT) { changeMode(Mode.ACQUIRE_TARGET); } else { // try to build pastures if late in game // probably deprecated (doesn't happen) if (currentRound > 1800 && ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT && !panicPastrBuilding) { if (currentCowsHere < 150) { panicPastrBuilding = true; dest = ALLY_HQ.subtract(ALLY_HQ.directionTo(ENEMY_HQ)); mover.setTarget(dest); sneakToBuildingLoc = 1; changeMode(Mode.FIND_PASTR_LOC); } else if (currentCowsHere < 400) { panicPastrBuilding = true; mover.setTarget(ALLY_HQ); changeMode(Mode.RETURN_HOME); } } else if (!initialSweep) { // stand on rich squares MapLocation loc = findRichSquare(); if (loc != null) { mover.setTarget(loc); changeMode(Mode.STAND_RICH_LOC); } } } } switch (mode) { case BIRTH_DECIDE_MODE: int robotNum = RC.senseRobotCount(); if (ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT + 1 || (robotNum + currentRound / 100 > 22 && ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT)) { roleIndex = ALLY_PASTR_COUNT % 4; role = Role.PASTR; changeMode(Mode.FIND_PASTR_LOC); dest = new MapLocation( (ALLY_HQ.x + roleLocList[roleIndex].x) / 2, (ALLY_HQ.y + roleLocList[roleIndex].y) / 2); } else { roleIndex = robotNum % 4; role = roleList[roleIndex]; changeMode(Mode.SWEEP_OUT); dest = roleLocList[roleIndex]; initialSweep = true; } mover.setTarget(dest); mover.move(); break; case GOING_TO_MIDDLE: if (mover.arrived()) { decideNextMode(); } else { mover.movePushHome(); } break; case SWEEP_OUT: if (mover.arrived()) { dest = new MapLocation( (2 * ALLY_HQ.x + roleLocList[roleIndex].x) / 3, (2 * ALLY_HQ.y + roleLocList[roleIndex].y) / 3); mover.setTarget(dest); changeMode(Mode.RETURN_HOME); } else { mover.movePushHome(); } break; case RETURN_HOME: if (mover.arrived()) { dest = roleLocList[roleIndex]; mover.setTarget(dest); changeMode(Mode.SWEEP_OUT); initialSweep = false; } else { mover.movePushHome(); } break; case STAND_RICH_LOC: if (!mover.arrived()) { mover.sneak(); } else { RC.setIndicatorString(1, "cows here: " + currentCowsHere); if (currentCowsHere < 500) { mover.setTarget(roleLocList[roleIndex]); changeMode(Mode.SWEEP_OUT); } } break; case FIND_PASTR_LOC: if (mover.arrived()) { changeMode(Mode.BUILD_PASTR); } else { mover.execute(sneakToBuildingLoc); } break; case BUILD_PASTR: if (!RC.isConstructing() && RC.isActive()) { RC.construct(RobotType.PASTR); } if (RC.getConstructingRounds() == 0) { buildingFinished = true; } break; case ACQUIRE_TARGET: int mindistance = 10000000; MapLocation pastrTarget = null; for (MapLocation pastrLoc : ENEMY_PASTR_LOCS) { int d = currentLocation.distanceSquaredTo(pastrLoc); if (d < mindistance) { mindistance = d; pastrTarget = pastrLoc; } } if (pastrTarget == null) { mover.setTarget(ALLY_HQ); changeMode(Mode.RETURN_HOME); } else { mover.setTarget(pastrTarget); changeMode(Mode.ENGAGE); mover.move(); } break; case ENGAGE: if (mover.arrived()) { changeMode(Mode.RETURN_HOME); } else { mover.move(); } break; default: break; } } private void changeMode(Mode m) { RC.setIndicatorString(0, currentRound + ": " + m.toString() + " " + role.toString()); mode = m; } private MapLocation findRichSquare() { double maxCows = currentCowsHere + 50 * COW_GROWTH[curX][curY] + 300; // favor staying here double curCows; MapLocation best = currentLocation; for (MapLocation current : MapLocation.getAllMapLocationsWithinRadiusSq( currentLocation, RobotType.SOLDIER.sensorRadiusSquared)) { try { if (RC.senseTerrainTile(current) == TerrainTile.OFF_MAP) continue; curCows = RC.senseCowsAtLocation(current) + 50 * COW_GROWTH[current.x][current.y]; if (curCows > maxCows && RC.senseObjectAtLocation(current) == null) { best = current; maxCows = curCows; } } catch (GameActionException e) { e.printStackTrace(); } } RC.setIndicatorString(1, "max nearby cows: " + maxCows + " at " + best); if (maxCows > 1000) { return best; } return null; } private void decideNextMode() {} @Override public void endRound() throws GameActionException { messagingSystem.endRound(); } }
public static void timerStart() { startRoundNum = Clock.getRoundNum(); startBytecodeNum = Clock.getBytecodeNum(); }
NavigationController(RobotController rc) { this.rc = rc; this.myTeam = rc.getTeam(); this.mapIntDistribution = new int[rc.getMapWidth()][rc.getMapHeight()]; this.dice = new Random(Clock.getRoundNum()); }
public static void debugBytecodes(String message) { System.out.format( "turn: %d, bytecodes: %d: %s\n", Clock.getRoundNum(), Clock.getBytecodeNum(), message); }
public Boolean areDronesRestrictedToMiners() throws GameActionException { int clockNumber = Clock.getRoundNum(); if (clockNumber > 800) return true; return false; }
public Boolean shouldBlitzkrieg(int roundLimit) throws GameActionException { int clockNumber = Clock.getRoundNum(); return clockNumber > roundLimit - 300; }
// @param turns the amount of turns that the budget was saved up for // @param progress the progress that we are in the build order public void updateBudgetingForBuildOrderProgress(int turns, int oreMined, int progress) throws GameActionException { int remainingOre = oreMined; // check if we need to take some for the supply depots if (progress >= this.civicRatios.length - 1) { if (this.broadcaster.budgetForType(RobotType.SUPPLYDEPOT) < 250) { this.broadcaster.incrementBudget(RobotType.SUPPLYDEPOT, (int) (remainingOre * 0.1)); remainingOre *= 0.9; } } // firstly check the beavers final int beavers = this.broadcaster.robotCountFor(Beaver.type()); int beaverOreAllocation = 0; if (beavers == 0) { beaverOreAllocation = 100; } // miners final int minerFactories = this.broadcaster.robotCountFor(MinerFactory.type()); int minerOreAllocation = 0; if (minerFactories > 0 && this.broadcaster.robotCountFor(Miner.type()) < 30) { minerOreAllocation = (60 / (20 / turns)); if (this.broadcaster.budgetForType(Miner.type()) >= minerFactories * 60) minerOreAllocation = 0; } // launchers final int aerospaceLabs = this.broadcaster.robotCountFor(AerospaceLab.type()); int launcherOreAllocation = aerospaceLabs * (400 / (100 / turns)); if (this.broadcaster.budgetForType(Launcher.type()) >= aerospaceLabs * 400) launcherOreAllocation = 0; // drones int droneOreAllocation = 0; if (Clock.getRoundNum() > 600 && this.broadcaster.robotCountFor(Drone.type()) == 0) { droneOreAllocation = 8; } int total = beaverOreAllocation + minerOreAllocation + launcherOreAllocation + droneOreAllocation; double multiplier = (total > remainingOre) ? remainingOre / (float) total : 1.0; this.broadcaster.incrementBudget(Beaver.type(), (int) (beaverOreAllocation * multiplier)); this.broadcaster.incrementBudget(Miner.type(), (int) (minerOreAllocation * multiplier)); this.broadcaster.incrementBudget(Launcher.type(), (int) (launcherOreAllocation * multiplier)); this.broadcaster.incrementBudget(Drone.type(), (int) (droneOreAllocation * multiplier)); remainingOre -= total * multiplier; if (remainingOre > 40 && oreMined < 500 /* first turn */) { beaverOreAllocation = 10; this.broadcaster.incrementBudget(Beaver.type(), beaverOreAllocation); remainingOre -= beaverOreAllocation; } this.broadcaster.incrementCivicBudget(remainingOre); }
public Boolean shouldGoAllOut(int roundLimit) { int clockNumber = Clock.getRoundNum(); return clockNumber > roundLimit - 150; }
public void run() { super.run(); try { // run some checks against harassment if (this.broadcaster.isEnemyTeamRushing()) this.isHarassing = false; int roundNumber = Clock.getRoundNum(); if (roundNumber > 800) this.isHarassing = false; // harassment is A-ok if (this.robotController.isWeaponReady()) { this.attack(); } if (this.robotController.isCoreReady()) { Boolean canMove = true; if (canMove) { RobotInfo[] enemiesInRange = this.unitController.nearbyEnemiesWithinTheirAttackRange(); if (enemiesInRange.length > 0) { canMove = (this.movementController.moveAway(enemiesInRange) != null); } } if (this.isHarassing) { if (canMove) { canMove = (this.movementController.moveToward(this.locationController.enemyHQLocation()) != null); } } else { if (!this.shouldMobilize()) { if (canMove) { RobotInfo[] enemiesInTerritory = this.enemiesInTerritory(); if (enemiesInTerritory.length > 0) { RobotInfo enemy = this.desiredEnemy(enemiesInTerritory); MapLocation bestLocation = enemy.location; canMove = this.movementController.moveToward(bestLocation) == null; } } // if we haven't moved toward an enemy location then we can go and stick to the plan if (canMove) { MapLocation rallyLocation = this.locationController.militaryRallyLocation(); if (this.locationController.distanceTo(rallyLocation) > 18) { this.movementController.moveToward(rallyLocation); } else { this.movementController.moveTo(this.movementController.randomDirection()); } } } else { this.mobilize(); } } this.supplyController.transferSupplyIfPossible(); } } catch (GameActionException exception) { } this.robotController.yield(); }
public Boolean shouldBlitzkrieg(int roundLimit) throws GameActionException { int clockNumber = Clock.getRoundNum(); return clockNumber > 1700 || this.broadcaster.hasSeenLaunchers(); }