// 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()); } } }
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(); } } }
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; } }
/** * 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(); } }
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; } }
/** * 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)); } } }
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); } } }
/** * Repairs the first-sensed neutral robot, if rc's core is ready * * @param rc must be an archon * @throws GameActionException */ private static boolean activateFirst(RobotController rc) throws GameActionException { boolean hasActed = false; RobotInfo[] nearbyNeutralRobots = rc.senseNearbyRobots(ONE_SQUARE_RADIUS, Team.NEUTRAL); if (nearbyNeutralRobots.length > 0) { rc.activate(nearbyNeutralRobots[0].location); hasActed = true; } return hasActed; }
/** * Repairs the first-sensed, injured, allied robot * * @param rc must be an archon * @throws GameActionException */ private static void repairFirst(RobotController rc) throws GameActionException { RobotInfo[] allies = rc.senseNearbyRobots(rc.getType().attackRadiusSquared, myTeam); for (int i = 0; i < allies.length; i++) { if (allies[i].health < allies[i].maxHealth && !allies[i].type.equals(RobotType.ARCHON)) { // can't repair other archons rc.repair(allies[i].location); break; } } }
@Override public boolean runInner(RobotController rc) throws GameActionException { if (rc.getRoundNum() == Common.enrollment) { target = new Target(Common.enemyBase); target.weights.put(Target.TargetType.ZOMBIE_ATTACK, Target.TargetType.Level.INACTIVE); Common.models.addFirst(target); } move(rc); attack(rc, rc.senseNearbyRobots(Common.sightRadius, Common.enemyTeam)); return false; }
protected void gatherMapInfo() throws GameActionException { // rc.setIndicatorString(0, "Sensing"); RobotInfo[] enemyRobotsInRange = rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, Team.ZOMBIE); for (int n = 0; n < enemyRobotsInRange.length; n++) { if (enemyRobotsInRange[n].type == RobotType.ZOMBIEDEN) { memory.addMapInfo( enemyRobotsInRange[n].location, (int) enemyRobotsInRange[n].health, RobotConstants.mapTypes.ZOMBIE_DEN); } } RobotInfo[] neutralRobotsInRange = rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, Team.NEUTRAL); for (int n = 0; n < neutralRobotsInRange.length; n++) { memory.addNeutralRobotMapInfo(neutralRobotsInRange[n].location, neutralRobotsInRange[n]); } MapLocation[] partsLoc = rc.sensePartLocations(rc.getType().sensorRadiusSquared); for (int n = 0; n < partsLoc.length; n++) { memory.addMapInfo( partsLoc[n], (int) rc.senseParts(partsLoc[n]), RobotConstants.mapTypes.PARTS); } for (int x = -robotSenseRadius / (int) Math.sqrt(2) + rc.getLocation().x; x < robotSenseRadius / (int) Math.sqrt(2) + rc.getLocation().x; x++) { for (int y = -robotSenseRadius / (int) Math.sqrt(2) + rc.getLocation().y; y < robotSenseRadius / (int) Math.sqrt(2) + rc.getLocation().y; y++) { MapLocation underView = new MapLocation(x, y); if (rc.canSense(underView) && rc.onTheMap(underView)) { int rubbles = (int) rc.senseRubble(underView); if (rubbles > 0) { memory.addMapInfo(underView, rubbles, RobotConstants.mapTypes.RUBBLE); } } } } }
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 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); } } } }
/* * Drones without supply head back to the HQ * Drones with supply head to the nearest unit without supply */ private static void doSupply() { if (rc.getSupplyLevel() > 2000) { RobotInfo[] units = rc.senseNearbyRobots(Integer.MAX_VALUE, myTeam); for (RobotInfo r : units) { if (r.supplyLevel == 0 && r.type.needsSupply()) { tryMove(myLoc.directionTo(r.location), false); return; } } } tryMove(myLoc.directionTo(myHQ), false); }
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(); } }
// 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(); } } } }
protected boolean simpleAttack() throws GameActionException { boolean attacked = false; if (rc.getType().canAttack()) { RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(rc.getType().attackRadiusSquared, enemyTeam); RobotInfo[] zombiesWithinRange = rc.senseNearbyRobots(rc.getType().attackRadiusSquared, Team.ZOMBIE); if (enemiesWithinRange.length > 0) { if (rc.isWeaponReady()) { rc.attackLocation( enemiesWithinRange[randall.nextInt(enemiesWithinRange.length)].location); attacked = true; } } else if (zombiesWithinRange.length > 0) { if (rc.isWeaponReady()) { rc.attackLocation( zombiesWithinRange[randall.nextInt(zombiesWithinRange.length)].location); attacked = true; } } } return attacked; }
/* * 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; }
public static void bugAroundFriendly(RobotController rc) throws GameActionException { RobotInfo[] nearbyFriendlyRobots = rc.senseNearbyRobots(sightRadius, myTeam); if (nearbyFriendlyRobots.length > 0) { RobotInfo nearestFriend = null; for (RobotInfo r : nearbyFriendlyRobots) { if (r.type == RobotType.ARCHON) { nearestFriend = r; } } if (nearestFriend != null && !nearestFriend.location.equals(storedDestination) || bugging == null) { bugging = new Bugging(rc, nearestFriend.location); storedDestination = nearestFriend.location; } if (rc.isCoreReady()) { // don't want to get too close to archon bugging.move(); } } }
private static boolean archonIsTooClose(RobotController rc) { boolean tooClose = false; int archonReserveDistance = (int) (Math.sqrt(rc.getRobotCount()) * 1.4); // @Hope make this more finessed List<RobotInfo> robots = Arrays.asList(rc.senseNearbyRobots(archonReserveDistance + 1, myTeam)); List<RobotInfo> archons = new ArrayList<>(); for (RobotInfo robot : robots) { if (robot.type == RobotType.ARCHON) { archons.add(robot); } } MapLocation myLocation = rc.getLocation(); for (RobotInfo archon : archons) { if (!tooClose && myLocation.distanceSquaredTo(archon.location) < archonReserveDistance) { tooClose = true; break; } } return tooClose; }
// moves to parts/neutral robots in sight radius // returns true if there were parts/neutral robots to go to; else returns false public static boolean getToParts(RobotController rc) throws Exception { if (rc.isCoreReady()) { MapLocation goTo = null; MapLocation myLoc = rc.getLocation(); int sightRadius = rc.getType().sensorRadiusSquared; MapLocation[] squaresInSight = MapLocation.getAllMapLocationsWithinRadiusSq(rc.getLocation(), sightRadius); RobotInfo[] nearbyNeutralRobots = rc.senseNearbyRobots(sightRadius, Team.NEUTRAL); // goes to closest parts/neutral robot if (nearbyNeutralRobots.length > 0) { goTo = nearbyNeutralRobots[0].location; for (RobotInfo n : nearbyNeutralRobots) { if (myLoc.distanceSquaredTo(n.location) < myLoc.distanceSquaredTo(goTo)) { goTo = n.location; } } } for (MapLocation sq : squaresInSight) { if ((rc.senseParts(sq) > 0) && (goTo != null)) { if (myLoc.distanceSquaredTo(sq) < myLoc.distanceSquaredTo(goTo)) { goTo = sq; } } } if (goTo != null) { MapLocation curLoc = rc.getLocation(); Direction dirToGo = curLoc.directionTo(goTo); if (rc.canMove(dirToGo)) { rc.move(dirToGo); return true; } else { return false; } } else { return false; } } else { return false; } }
/** * Code to run every turn. * * @param rc */ static void runBefore(RobotController rc) throws GameActionException { // -2 for build signals Signals.maxMessages = GameConstants.MESSAGE_SIGNALS_PER_TURN - 2; read = Signals.readSignals(rc); sent = 0; int turn = rc.getRoundNum(); switch (turn - enrollment) { case 0: if (targetType != null && Signals.targetsSize > 0) { models.addFirst(new Target(targetType, Signals.targets[0])); } break; case 1: for (int i = 0; i < sqrt.length; ++i) sqrt[i] = Math.sqrt(i); break; case 2: // Sense rubble a little after construction // TODO: change to 3(?) to avoid overlapping with action senseRubble(rc); break; default: break; } if (canMessageSignal) { sendRadius = 2 * sightRadius; sendBoundariesLow = false; sendBoundariesHigh = false; senseParts(rc); } updateMap(rc); if (turn > 5) { robotInfos = rc.senseNearbyRobots(); for (RobotInfo info : robotInfos) { addInfo(info); } } }
// This method will attack the weakest enemy in sight static boolean attackWeakest() { RobotInfo[] targets = rc.senseNearbyRobots(attackRange, enemyTeam); if (targets.length == 0) return false; // Find enemy with lowest health - pick units that can damage us as a preference RobotInfo weakest = targets[0]; for (RobotInfo e : targets) { if ((!canDamage(weakest.type) && canDamage(e.type)) || (canDamage(weakest.type) == canDamage(e.type) && e.health < weakest.health)) { weakest = e; } } try { rc.attackLocation(weakest.location); } catch (GameActionException e) { System.out.println("Attack exception"); // e.printStackTrace(); } return true; }
// Supply our units // Getting supply to the buildings producing units is cool private static void doTransfer() { double supply = rc.getSupplyLevel(); double supplyToKeep = myType.supplyUpkeep * 10; // 10 turns worth of supply if (myType == RobotType.COMMANDER) supplyToKeep *= 10; if (supply < supplyToKeep) return; RobotInfo[] robots = rc.senseNearbyRobots(GameConstants.SUPPLY_TRANSFER_RADIUS_SQUARED, myTeam); // Pass to first neighbour with half the supply we have RobotInfo target = null; // Pick the nearest ally with the least supply for (RobotInfo r : robots) { // Never pass supply to buildings that can't spawn or to the HQ if (r.type == RobotType.HQ || r.type == RobotType.TOWER || r.type == RobotType.SUPPLYDEPOT || r.type == RobotType.HANDWASHSTATION) continue; // Drone will only pass to units with 0 supply if (myType == RobotType.DRONE && r.supplyLevel > 0) continue; if (target == null || r.supplyLevel < target.supplyLevel) target = r; if (Clock.getBytecodesLeft() < 600) break; } double toTransfer = supply - supplyToKeep; if (target == null || supply < target.supplyLevel * 2.0) return; // Keep half of what we have available unless we are the HQ if (target.type != RobotType.HQ) toTransfer /= 2.0; try { rc.transferSupplies((int) toTransfer, target.location); } catch (GameActionException e) { System.out.println("Supply 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(RobotController rc) { Random rand = new Random(rc.getID()); Team myTeam = rc.getTeam(); Team enemyTeam = myTeam.opponent(); int numFriendly = 0; RobotInfo[] adjNeutralRobots = rc.senseNearbyRobots(2, Team.NEUTRAL); // if useTurrets = true, then use turret strategy boolean useTurrets = false; try { // Any code here gets executed exactly once at the beginning of the game. RobotInfo[] nearbyArchons = rc.senseNearbyRobots(RobotType.ARCHON.sensorRadiusSquared, rc.getTeam()); if (nearbyArchons.length >= 2) { useTurrets = true; } // rc.setIndicatorString(1, "newString"); } catch (Exception e) { // Throwing an uncaught exception makes the robot die, so we need to catch exceptions. // Caught exceptions will result in a bytecode penalty. System.out.println(e.getMessage()); e.printStackTrace(); } while (true) { // This is a loop to prevent the run() method from returning. Because of the Clock.yield() // at the end of it, the loop will iterate once per game round. try { if (useTurrets) { boolean escape = false; // if (rc.isCoreReady()) { // int numAdjTurrets = 0; // for (RobotInfo f : friendlyAdjacent) { // if (f.type == RobotType.TURRET) { // numAdjTurrets++; // } // } // if (numAdjTurrets < 3) { // escape = Movement.moveAwayFromEnemy(rc); // } // } // if (rc.isCoreReady()) { // escape = Movement.moveAwayFromEnemy(rc); // } if (!escape) { if (adjNeutralRobots.length > 0) { // if there is a neutral robot adjacent, activate it or wait until there's no core // delay if (rc.isCoreReady()) { rc.activate(adjNeutralRobots[0].location); } } // careful- moving to parts might get into enemy turret range if (Movement.getToAdjParts(rc)) { } else { boolean toheal = false; // repair a nearby friendly robot if (rc.isWeaponReady()) { RobotInfo[] friendlyWithinRange = rc.senseNearbyRobots(24, myTeam); numFriendly = friendlyWithinRange.length; if (friendlyWithinRange.length > 0) { RobotInfo toRepair = friendlyWithinRange[0]; for (RobotInfo r : friendlyWithinRange) { if ((r.health < toRepair.health) && (r.type != RobotType.ARCHON) && (r.maxHealth - r.health > 1)) { toRepair = r; } } if ((toRepair.maxHealth - toRepair.health > 1) && (toRepair.type != RobotType.ARCHON)) { toheal = true; rc.repair(toRepair.location); } } } if (toheal == false && rc.isCoreReady()) { // did not heal any robots // sense all the hostile robots within the archon's radius MapLocation myLoc = rc.getLocation(); RobotInfo[] hostileWithinRange = rc.senseHostileRobots(myLoc, RobotType.ARCHON.sensorRadiusSquared); RobotInfo closestRobot = null; int closestDistance = 0; // get the furthest robot from the scout for (RobotInfo r : hostileWithinRange) { if (r.location.distanceSquaredTo(myLoc) > closestDistance) { closestRobot = r; closestDistance = r.location.distanceSquaredTo(myLoc); } } // if there is such an enemy, signal it to range 8 if (closestRobot != null) { try { // this signaling is only effective against non turret enemies rc.broadcastMessageSignal(closestRobot.location.x, closestRobot.location.y, 8); } catch (GameActionException e) { // TODO Auto-generated catch block e.printStackTrace(); } } int turnNum = rc.getRoundNum(); int numVeryCloseScouts = 0; int numNearbyTurrets = 0; RobotInfo[] friendlyNearby = rc.senseNearbyRobots(RobotType.ARCHON.sensorRadiusSquared, myTeam); for (RobotInfo f : friendlyNearby) { if (f.type == RobotType.TURRET) { numNearbyTurrets++; } } // for sensing if there are guards within range 24 RobotInfo[] friendlyClose = rc.senseNearbyRobots(24, myTeam); int numNearbyGuards = 0; for (RobotInfo f : friendlyClose) { if (f.type == RobotType.GUARD) { numNearbyGuards++; } } // check for scouts; how close should they be???? RobotInfo[] friendlyVeryClose = rc.senseNearbyRobots(15, myTeam); for (RobotInfo f : friendlyClose) { if (f.type == RobotType.SCOUT) { numVeryCloseScouts++; } } if (rc.hasBuildRequirements(RobotType.GUARD) && rc.isCoreReady() && numNearbyGuards < 1) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(8)]; for (int i = 0; i < 8; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.GUARD)) { rc.build(dirToBuild, RobotType.GUARD); break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); } } } // if there are <1 turrets next to archon, build asap if (rc.hasBuildRequirements(RobotType.TURRET) && rc.isCoreReady() && numNearbyTurrets < 1) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(4) * 2]; for (int i = 0; i < 4; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.TURRET)) { rc.build(dirToBuild, RobotType.TURRET); turretCount++; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); dirToBuild = dirToBuild.rotateLeft(); } } } // if there are <1 scout next to archon and 1 turret, build scout asap if (rc.hasBuildRequirements(RobotType.SCOUT) && rc.isCoreReady() && numNearbyTurrets > 0 && numVeryCloseScouts == 0 && turnNum < 400) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(8)]; for (int i = 0; i < 8; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.SCOUT)) { rc.build(dirToBuild, RobotType.SCOUT); scoutCount++; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); } } } // build turret every 100 turns until turn 400 // if (turnNum > 1 && turnNum < 400) { // if (turnNum % 100 == 85 && rc.isCoreReady()) { // Direction dirToBuild = RobotPlayer.directions[rand.nextInt(4)*2]; // for (int i = 0; i < 4; i++) { // // If possible, build in this direction // if (rc.canBuild(dirToBuild, RobotType.TURRET)) { // rc.build(dirToBuild, RobotType.TURRET); // turretCount++; // break; // } else { // // Rotate the direction to try // dirToBuild = dirToBuild.rotateLeft(); // dirToBuild = dirToBuild.rotateLeft(); // } // } // } // } else { // Check if this ARCHON's core is ready if (rc.isCoreReady()) { boolean built = false; RobotType typeToBuild = RobotType.TURRET; if (scoutCount < turretCount / 5) { typeToBuild = RobotType.SCOUT; } // never build scouts after a certain turn if (turnNum < 1500) { typeToBuild = RobotType.TURRET; } // Check for sufficient parts if (rc.hasBuildRequirements(typeToBuild)) { // Choose a random direction to try to build in; NESW for turrets; all 8 for // scouts if (typeToBuild.equals(RobotType.TURRET)) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(4) * 2]; for (int i = 0; i < 4; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.TURRET)) { rc.build(dirToBuild, RobotType.TURRET); turretCount++; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); dirToBuild = dirToBuild.rotateLeft(); } } } else { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(8)]; for (int i = 0; i < 8; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.SCOUT)) { rc.build(dirToBuild, RobotType.SCOUT); scoutCount++; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); } } } } // only move around if there are resources if ((!built) && rc.hasBuildRequirements(RobotType.TURRET) && (rc.isCoreReady())) { // don't move into enemy turret range if scout sends signal about it Set<Direction> dangerousDirs = new HashSet<>(); Signal currentSignal = rc.readSignal(); while (currentSignal != null) { int messageX = currentSignal.getMessage()[0]; int messageY = currentSignal.getMessage()[1]; // if signal message > 80000, then the message is signaling a turret // location if (messageX > 80000) { messageX = messageX - 100000; messageY = messageY - 100000; MapLocation enemyTurretLoc = new MapLocation(messageX, messageY); Direction dirToEnemyTurret = myLoc.directionTo(enemyTurretLoc); Direction dirToEnemyTurretL = myLoc.directionTo(enemyTurretLoc).rotateLeft(); Direction dirToEnemyTurretR = myLoc.directionTo(enemyTurretLoc).rotateRight(); if (myLoc.add(dirToEnemyTurret).distanceSquaredTo(enemyTurretLoc) <= 48) { dangerousDirs.add(dirToEnemyTurret); } if (myLoc.add(dirToEnemyTurretL).distanceSquaredTo(enemyTurretLoc) <= 48) { dangerousDirs.add(dirToEnemyTurretL); } if (myLoc.add(dirToEnemyTurretR).distanceSquaredTo(enemyTurretLoc) <= 48) { dangerousDirs.add(dirToEnemyTurretR); } } currentSignal = rc.readSignal(); } Direction dirToMove = RobotPlayer.directions[(rand.nextInt(4) * 2) + 1]; for (int i = 0; i < 4; i++) { if (rc.canMove(dirToMove) && !dangerousDirs.contains(dirToMove)) { rc.move(dirToMove); break; } else { dirToMove = dirToMove.rotateLeft(); dirToMove = dirToMove.rotateLeft(); } } } } } } } } } else { // use soldiers boolean escape = false; if (rc.isCoreReady()) { escape = Movement.moveAwayFromEnemy(rc); } if (!escape) { if (adjNeutralRobots.length > 0) { // if there is a neutral robot adjacent, activate it or wait until there's no core // delay if (rc.isCoreReady()) { rc.activate(adjNeutralRobots[0].location); } } if (Movement.getToAdjParts(rc)) { } else { boolean toheal = false; // repair a nearby friendly robot if (rc.isWeaponReady()) { RobotInfo[] friendlyWithinRange = rc.senseNearbyRobots(24, myTeam); numFriendly = friendlyWithinRange.length; if (friendlyWithinRange.length > 0) { RobotInfo toRepair = friendlyWithinRange[0]; for (RobotInfo r : friendlyWithinRange) { if ((r.health < toRepair.health) && (r.type != RobotType.ARCHON) && (r.maxHealth - r.health > 1)) { toRepair = r; } } if ((toRepair.maxHealth - toRepair.health > 1) && (toRepair.type != RobotType.ARCHON)) { toheal = true; rc.repair(toRepair.location); } } } if (toheal == false) { // for sensing if there are guards within range 24 RobotInfo[] friendlyClose = rc.senseNearbyRobots(24, myTeam); int numNearbyGuards = 0; for (RobotInfo f : friendlyClose) { if (f.type == RobotType.GUARD) { numNearbyGuards++; } } boolean built = false; int turnNum = rc.getRoundNum(); if (rc.hasBuildRequirements(RobotType.SCOUT) && rc.isCoreReady() && turnNum > 1 && turnNum % 150 >= 0 && turnNum % 150 <= 19 && turnNum < 900) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(8)]; for (int i = 0; i < 8; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.SCOUT)) { rc.build(dirToBuild, RobotType.SCOUT); built = true; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); } } } if (rc.hasBuildRequirements(RobotType.GUARD) && rc.isCoreReady() && !built && numNearbyGuards < 1) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(8)]; for (int i = 0; i < 8; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.GUARD)) { rc.build(dirToBuild, RobotType.GUARD); built = true; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); } } } if (rc.hasBuildRequirements(RobotType.SOLDIER) && rc.isCoreReady() && !built) { Direction dirToBuild = RobotPlayer.directions[rand.nextInt(8)]; for (int i = 0; i < 8; i++) { // If possible, build in this direction if (rc.canBuild(dirToBuild, RobotType.SOLDIER)) { rc.build(dirToBuild, RobotType.SOLDIER); built = true; break; } else { // Rotate the direction to try dirToBuild = dirToBuild.rotateLeft(); } } } // if archon has nothing to do, tell soldiers to come to it's location /*if (rc.getRoundNum() > 500 && rc.isCoreReady() && rc.isWeaponReady()) { rc.broadcastMessageSignal(-100, 0, 70 * 70); }*/ } } } } Clock.yield(); } catch (Exception e) { System.out.println(e.getMessage()); e.printStackTrace(); } } }
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(); } }
public static void run(RobotController rc) { int myAttackRange = 0; Random rand = new Random(rc.getID()); Team myTeam = rc.getTeam(); Team enemyTeam = myTeam.opponent(); try { // Any code here gets executed exactly once at the beginning of the game. myAttackRange = rc.getType().attackRadiusSquared; } catch (Exception e) { // Throwing an uncaught exception makes the robot die, so we need to catch exceptions. // Caught exceptions will result in a bytecode penalty. System.out.println(e.getMessage()); e.printStackTrace(); } while (true) { // This is a loop to prevent the run() method from returning. Because of the Clock.yield() // at the end of it, the loop will iterate once per game round. try { MapLocation myLoc = rc.getLocation(); // If this robot type can attack, check for enemies within range and attack one // guards only attack ZOMBIES RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, Team.ZOMBIE); RobotInfo[] friendliesWithinRange = rc.senseNearbyRobots(rc.getType().sensorRadiusSquared, myTeam); int closestArchonDist = 60; MapLocation closestArchonLoc = null; for (RobotInfo f : friendliesWithinRange) { if (f.type == RobotType.ARCHON) { MapLocation curArchonLoc = f.location; if (myLoc.distanceSquaredTo(curArchonLoc) < closestArchonDist) { closestArchonDist = myLoc.distanceSquaredTo(curArchonLoc); closestArchonLoc = curArchonLoc; } } } if (closestArchonLoc != null) { if (enemiesWithinRange.length > 0) { RobotInfo nearestEnemyToArchon = enemiesWithinRange[0]; int nearestEnemyToArchonDist = nearestEnemyToArchon.location.distanceSquaredTo(closestArchonLoc); for (RobotInfo e : enemiesWithinRange) { if (e.location.distanceSquaredTo(closestArchonLoc) < nearestEnemyToArchonDist) { nearestEnemyToArchonDist = e.location.distanceSquaredTo(closestArchonLoc); nearestEnemyToArchon = e; } } // only attack/move towards if it's within 24 range of the archon if (nearestEnemyToArchonDist <= 24) { // Check if weapon is ready if (rc.isWeaponReady() && rc.canAttackLocation(nearestEnemyToArchon.location)) { rc.attackLocation(nearestEnemyToArchon.location); } else { // otherwise try to move towards the enemy if (rc.isCoreReady()) { // try to move towards enemy Direction dirToMove = myLoc.directionTo(nearestEnemyToArchon.location); if (rc.canMove(dirToMove)) { rc.move(dirToMove); } else if (rc.canMove(dirToMove.rotateLeft())) { rc.move(dirToMove.rotateLeft()); } else if (rc.canMove(dirToMove.rotateRight())) { rc.move(dirToMove.rotateRight()); } } } } } else { // if no enemies, it should try to circle nearest archon if (rc.isCoreReady()) { Direction dirToMove = myLoc.directionTo(closestArchonLoc); if (rc.canMove(dirToMove)) { rc.move(dirToMove); } else if (rc.canMove(dirToMove.rotateLeft())) { rc.move(dirToMove.rotateLeft()); } else if (rc.canMove(dirToMove.rotateRight())) { rc.move(dirToMove.rotateRight()); } } } } else { rc.setIndicatorString(1, "no archon"); // if no archons nearby, move randomly and attack if (enemiesWithinRange.length > 0) { RobotInfo nearestEnemy = enemiesWithinRange[0]; int nearestEnemyDist = nearestEnemy.location.distanceSquaredTo(myLoc); for (RobotInfo e : enemiesWithinRange) { if (e.location.distanceSquaredTo(myLoc) < nearestEnemyDist) { nearestEnemyDist = e.location.distanceSquaredTo(myLoc); nearestEnemy = e; } } if (rc.isWeaponReady() && rc.canAttackLocation(nearestEnemy.location)) { rc.attackLocation(nearestEnemy.location); } else { // otherwise try to move towards the enemy if (rc.isCoreReady()) { // try to move towards enemy Direction dirToMove = myLoc.directionTo(nearestEnemy.location); if (rc.canMove(dirToMove)) { rc.move(dirToMove); } else if (rc.canMove(dirToMove.rotateLeft())) { rc.move(dirToMove.rotateLeft()); } else if (rc.canMove(dirToMove.rotateRight())) { rc.move(dirToMove.rotateRight()); } } } } else if (rc.isCoreReady()) { Direction dirToMove = RobotPlayer.directions[(rand.nextInt(8))]; for (int i = 0; i < 8; i++) { if (rc.canMove(dirToMove)) { rc.move(dirToMove); break; } else { dirToMove = dirToMove.rotateLeft(); } } } } Clock.yield(); } catch (Exception e) { System.out.println(e.getMessage()); e.printStackTrace(); } } }
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(); } } }