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); } } }
private MapLocation traceNext(MapLocation currentLoc, Direction faceDir, boolean cw) { // Put isTraversable first so that the second while loop will rotate the // direction to walkable position // Try code reuse in the future int step = 0; if (cw) { while (isTraversable(currentLoc.add(faceDir)) && step < 8) { faceDir = faceDir.rotateRight(); step++; } step = 0; while (!isTraversable(currentLoc.add(faceDir)) && step < 8) { faceDir = faceDir.rotateLeft(); step++; } } else { while (isTraversable(currentLoc.add(faceDir)) && step < 8) { faceDir = faceDir.rotateLeft(); step++; } step = 0; while (!isTraversable(currentLoc.add(faceDir)) && step < 8) { faceDir = faceDir.rotateRight(); step++; } } return currentLoc.add(faceDir); }
private static void shootRandomly() throws GameActionException { if (rc.getRoundNum() > 500) { Direction trueAway = alpha.directionTo(here); Direction away = trueAway; MapLocation enemyLocation = here; int count = 0; while (count < 4 || rc.canAttackLocation(enemyLocation.add(away))) { enemyLocation = enemyLocation.add(away); away = (new Direction[] { trueAway, trueAway.rotateLeft(), trueAway.rotateRight(), trueAway.rotateLeft().rotateLeft(), trueAway.rotateRight().rotateRight() }) [rand.nextInt(5)]; count++; if (rc.canSenseLocation(enemyLocation) && !rc.onTheMap(enemyLocation)) { return; } } if (rc.canAttackLocation(enemyLocation)) { rc.attackLocation(enemyLocation); return; } } }
public static void 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); } } }
public static void goToGoal( Direction movingDirection, boolean greaterAttackForce, int numAllAllies) throws GameActionException { // forwardish(randomDirection()); if (RobotPlayer.soldierLeader) { RobotPlayer.rc.setIndicatorString(2, "I am a leader about to move"); if (numAllAllies > 7 && greaterAttackForce) { RobotPlayer.rc.setIndicatorString(2, "I am a leader with a strong force"); forwardish(movingDirection); } else if (greaterAttackForce) { // TODO what to do with small groups? RobotPlayer.rc.setIndicatorString(2, "I am a leader with a larger force"); if (RobotPlayer.rc.getRoundNum() % 8 == 0) forwardish(movingDirection); } else { RobotPlayer.rc.setIndicatorString(2, "greater attack force? " + greaterAttackForce); if (RobotPlayer.rc.getRoundNum() % 5 == 0) { RobotPlayer.movingDirection = movingDirection.rotateRight(); forwardish(RobotPlayer.movingDirection); } } } else if (RobotPlayer.rc.getType() == RobotType.SOLDIER) { if (greaterAttackForce || RobotPlayer.haveLeader) { forwardish(movingDirection); // keep going where we are going } else { forwardish( movingDirection .rotateRight()); // wiat for leader, turn (should i go in random direction?) } } else if (RobotPlayer.rc.getType() == RobotType.GUARD) { if (greaterAttackForce || RobotPlayer.haveLeader) { forwardish(movingDirection); // keep going where we are going } else { forwardish( movingDirection .rotateRight()); // wiat for leader, turn (should i go in random direction?) } } // else { // // if (greaterAttackForce){ // forwardish(movingDirection);//keep going where we are going // } // // forwardish(randomDirection());//wiat for leader, go in random direction //// forwardish(movingDirection); // } // // else if(RobotPlayer.haveLeader){ // // // // }else{ // // // // //} }
// 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); } } } } }
public static Direction[] bestDir(Direction dir) { Direction[] bestDir = { dir, dir.rotateLeft(), dir.rotateRight(), dir.rotateLeft().rotateLeft(), dir.rotateRight().rotateRight() }; return bestDir; }
private static void runMissile() { int lastTurn = Clock.getRoundNum() + GameConstants.MISSILE_LIFESPAN; int[] damageRange = {0, 8, 15, 24, 35, 48}; MapLocation target = null; boolean targetMoves = true; while (true) { myLoc = rc.getLocation(); int turns = lastTurn - Clock.getRoundNum(); if (targetMoves) { // Re-acquire the target's location RobotInfo[] inRange = rc.senseNearbyRobots(damageRange[turns], enemyTeam); if (inRange.length > 0) { // No units to target target = inRange[0].location; targetMoves = inRange[0].type.canMove(); rc.setIndicatorString(0, "Missile targetting " + inRange[0].type + "@" + target); } else { targetMoves = false; // Pick a tower or the HQ MapLocation[] enemyTowers = rc.senseEnemyTowerLocations(); for (MapLocation t : enemyTowers) { if (myLoc.distanceSquaredTo(t) <= damageRange[turns]) { target = t; rc.setIndicatorString(0, "Missile targetting Tower @" + target); break; } } if (target == null) { target = rc.senseEnemyHQLocation(); rc.setIndicatorString(0, "Missile targetting HQ @" + target); } } } try { if (target != null) { if (myLoc.distanceSquaredTo(target) <= GameConstants.MISSILE_RADIUS_SQUARED) rc.explode(); else { Direction d = myLoc.directionTo(target); if (rc.canMove(d)) rc.move(d); else if (rc.canMove(d.rotateLeft())) rc.move(d.rotateLeft()); else if (rc.canMove(d.rotateRight())) rc.move(d.rotateRight()); } } } catch (GameActionException e) { System.out.println("Missile exception"); // e.printStackTrace(); } rc.yield(); } }
private boolean moveToPath() throws GameActionException { if (dstar == null) { dstar = new DStar(outPath, distances, currentLocation); } if (!dstar.arrived(currentLocation)) { dstar.compute(7000); } if (!RC.isActive()) return true; Direction dir = Direction.NORTH, best = null; int min = Integer.MAX_VALUE; for (int i = 0; i < 8; i++) { int d = RC.canMove(dir) ? dstar.getDistance(currentLocation.add(dir)) : Integer.MAX_VALUE; if (d < min) { min = d; best = dir; } dir = dir.rotateRight(); } if (best != null && move(best)) { RC.setIndicatorString(1, "Moving to outPath"); return true; } else { return false; } }
/** * 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; }
private void cautiouslyApproachVisibleEnemySoldier(MapLocation enemySoldier, int maxEnemyExposure) throws GameActionException { int[] numEnemiesAttackingDirs = countNumEnemiesAttackingMoveDirs(); Direction toEnemy = here.directionTo(enemySoldier); Direction[] tryDirs = new Direction[] {toEnemy, toEnemy.rotateLeft(), toEnemy.rotateRight()}; for (int i = 0; i < tryDirs.length; i++) { Direction tryDir = tryDirs[i]; if (!rc.canMove(tryDir)) continue; if (numEnemiesAttackingDirs[tryDir.ordinal()] > maxEnemyExposure) continue; if (Util.inHQAttackRange(here.add(tryDir), theirHQ)) continue; Debug.indicate( "micro", 1, String.format( "cautiously approaching enemy soldier; direction %d; attackers = %d %d %d %d %d %d %d %d", tryDir.ordinal(), numEnemiesAttackingDirs[0], numEnemiesAttackingDirs[1], numEnemiesAttackingDirs[2], numEnemiesAttackingDirs[3], numEnemiesAttackingDirs[4], numEnemiesAttackingDirs[5], numEnemiesAttackingDirs[6], numEnemiesAttackingDirs[7])); rc.move(tryDir); return; } Debug.indicate("micro", 1, "can't safely approach enemy soldier"); }
private static void doMinerMove() { // If there is an available adjacent tile with twice as much ore we are better off moving Direction startDir = directions[rand.nextInt(directions.length)]; Direction d = startDir; Direction best = Direction.NONE; double mostOre = rc.senseOre(myLoc) * 2; // Only move if there is twice as much ore boolean done = false; while (!done) { if (rc.canMove(d)) { MapLocation adj = rc.getLocation().add(d); double ore = rc.senseOre(adj); if ((ore > mostOre || (ore == mostOre && ore > 0 && adj.distanceSquaredTo(myHQ) > myLoc.distanceSquaredTo(myHQ))) && !threats.isThreatened(adj)) { mostOre = rc.senseOre(adj); best = d; } } d = d.rotateRight(); done = (d == startDir); } if (best != Direction.NONE) { rc.setIndicatorString(2, "Mining - better ore " + d); try { rc.move(best); } catch (GameActionException e) { System.out.println("Miner move exception"); // e.printStackTrace(); } } }
private boolean spawn() throws GameActionException { Direction dir = rc.getLocation().directionTo(rc.senseEnemyHQLocation()); // Need to do this first so the termination check works if (rc.canMove(dir)) { rc.spawn(dir); return true; } // Spawn as close to the desired direction as possible Direction dirLeft = dir; Direction dirRight = dir; do { dirLeft = dirLeft.rotateLeft(); if (rc.canMove(dirLeft)) { rc.spawn(dirLeft); return true; } dirRight = dirRight.rotateRight(); if (rc.canMove(dirRight)) { rc.spawn(dirRight); return true; } } while (dirRight != dirLeft); return false; }
private boolean isOpen( MapLocation currentLoc, Direction currentDir, Direction nextDir, Direction desDir, boolean cw) { if (desDir == Direction.OMNI) { return true; } if (!isTraversable(currentLoc.add(currentDir))) return false; if (cw) { while (currentDir != nextDir) { if (currentDir == desDir) return true; currentDir = currentDir.rotateRight(); } } else { while (currentDir != nextDir) { if (currentDir == desDir) return true; currentDir = currentDir.rotateLeft(); } } return (nextDir == desDir); }
/* * Head towards the nearest tile that we haven't sensed before * If there is a tie, pick the one nearest to the hq */ private static void doPatrol() { if (!droneCentred) { // start point for the spiral is 2/5 of the way from our HQ to their HQ MapLocation centre = new MapLocation( (3 * myHQ.x + 2 * threats.enemyHQ.x) / 5, (3 * myHQ.y + 2 * threats.enemyHQ.y) / 5); if (threats.isThreatened(centre) || myLoc.distanceSquaredTo(centre) <= 2) droneCentred = true; else { moveDir = myLoc.directionTo(centre); } } if (droneCentred && --droneMoveCurrent <= 0) { if (patrolClockwise) moveDir = moveDir.rotateRight(); else moveDir = moveDir.rotateLeft(); if (!moveDir.isDiagonal()) droneMoveMax++; droneMoveCurrent = droneMoveMax; } while (true) { try { if (rc.canMove(moveDir) && !threats.isThreatened(myLoc.add(moveDir))) { rc.move(moveDir); break; } else if (rc.canMove(moveDir.rotateLeft()) && !threats.isThreatened(myLoc.add(moveDir.rotateLeft()))) { rc.move(moveDir.rotateLeft()); break; } else if (rc.canMove(moveDir.rotateRight()) && !threats.isThreatened(myLoc.add(moveDir.rotateRight()))) { rc.move(moveDir.rotateRight()); break; } else if (droneCentred) { moveDir = moveDir.opposite(); patrolClockwise = !patrolClockwise; if (!moveDir.isDiagonal()) droneMoveMax++; droneMoveCurrent = droneMoveMax; } else { break; } } catch (GameActionException e) { System.out.println("Drone patrol exception"); // e.printStackTrace(); } } }
public Direction Bug(MapLocation s, MapLocation t, int tolerance) { // arrive the destination if (s.distanceSquaredTo(t) <= tolerance) { reset(); return Direction.OMNI; } Direction nextDir; Direction faceDir = controllers.myRC.getDirection(); // if target is not traversable, back-tracing the destination while (!isTraversable(t)) { nextDir = s.directionTo(t); t = t.subtract(nextDir); // beside the source if (s.distanceSquaredTo(t) <= tolerance) { reset(); return Direction.OMNI; } } modifiedDes = t; Direction desDir = s.directionTo(t); MapLocation nextLoc; if (isTracing) { Direction startTracingDir = isCW ? faceDir.rotateRight().rotateRight() : faceDir.rotateLeft().rotateLeft(); nextLoc = traceNext(s, startTracingDir, isCW); nextDir = s.directionTo(nextLoc); // The way is open if (isOpen(s, faceDir, nextDir, desDir, isCW) && isTraversable(s.add(desDir))) { isTracing = false; return desDir; } return nextDir; } else { if (isTraversable(s.add(desDir))) { return desDir; } else { isTracing = true; isCW = betterTracingWay(s, t); nextLoc = traceNext(s, desDir, isCW); return s.directionTo(nextLoc); } } }
protected boolean trySafeMove( Direction direction, RobotInfo[] nearbyEnemies, RobotInfo[] nearbyZombies) throws GameActionException { MapLocation currentLocation = rc.getLocation(); MapLocation next = currentLocation.add(direction); if (canMoveSafely(direction, next, nearbyEnemies, nearbyZombies)) { rc.move(direction); return true; } Direction left = direction.rotateLeft(); next = currentLocation.add(left); if (canMoveSafely(left, next, nearbyEnemies, nearbyZombies)) { rc.move(left); return true; } Direction right = direction.rotateRight(); next = currentLocation.add(right); if (canMoveSafely(right, next, nearbyEnemies, nearbyZombies)) { rc.move(right); return true; } for (int i = 0; i < 2; i++) { left = left.rotateLeft(); next = currentLocation.add(left); if (canMoveSafely(left, next, nearbyEnemies, nearbyZombies)) { rc.move(left); return true; } right = right.rotateRight(); next = currentLocation.add(right); if (canMoveSafely(right, next, nearbyEnemies, nearbyZombies)) { rc.move(right); return true; } } return false; }
private Direction detour(Direction faceDir, boolean cw) { if (cw) { while (controllers.motor.canMove(faceDir)) { faceDir = faceDir.rotateRight(); } while (!controllers.motor.canMove(faceDir)) { faceDir = faceDir.rotateLeft(); } } else { while (controllers.motor.canMove(faceDir)) { faceDir = faceDir.rotateLeft(); } while (!controllers.motor.canMove(faceDir)) { faceDir = faceDir.rotateRight(); } } return faceDir; }
/** * Try to move. * * @param sneak: * @return */ public void execute(int sneak) { // int bc = Clock.getBytecodesLeft(); // RC.setIndicatorString(1, "my x = " + Integer.toString(RC.getLocation().x) + ", my y = " + // Integer.toString(RC.getLocation().y) // + "x = " + Integer.toString(dest.x) + ", y = " + Integer.toString(dest.y)); // RC.setIndicatorString(2, Clock.getRoundNum() + " | dest = " + dest + ", navtype = " + // navType); if (arrived()) return; if (RC.isActive()) { Direction d; d = navAlg.getNextDir(); if (d != null && d != Direction.NONE && d != Direction.OMNI) { if (RC.canMove(d)) { try { switch (sneak) { case SNEAK: // RC.setIndicatorString(2, dest.x + ", " + dest.y + ": sneak"); RC.sneak(d); break; case RUN: // RC.setIndicatorString(2, dest.x + ", " + dest.y + ": run"); RC.move(d); break; case PUSH_HOME: // RC.setIndicatorString(2, dest.x + ", " + dest.y + ": push_home"); Direction awayFromHome = currentLocation.directionTo(ALLY_HQ).opposite(); if (d == awayFromHome || d == awayFromHome.rotateLeft() || d == awayFromHome.rotateRight()) { RC.sneak(d); } else { RC.move(d); } break; default: break; } } catch (GameActionException e) { e.printStackTrace(); } } else if (currentLocation.distanceSquaredTo(dest) <= 2) { setTarget(currentLocation); } } } // System.out.println("Bytecodes used by Mover.execute() = " + // Integer.toString(bc-Clock.getBytecodesLeft())); }
///////////////////////////////////////////////////////////// // moveAway() // private static boolean moveAway(MapLocation center) throws GameActionException { while (!rc.isCoreReady()) { Clock.yield(); } Direction dir = center.directionTo(rc.getLocation()); int c = 0; while (!rc.canMove(dir)) { dir = dir.rotateRight(); c++; if (c >= 4) return false; } rc.move(dir); return true; }
/** * 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); } } } }
private static boolean isBlockingSomeone(RobotController rc, MapLocation target) throws GameActionException { Direction dir = myLoc.directionTo(target); MapLocation behind = myLoc.add(dir.opposite()); MapLocation left = behind.add(dir.rotateLeft()); MapLocation right = behind.add(dir.rotateRight()); // There is someone behind us if (rc.senseRobotAtLocation(behind) != null) { // If there is stuff blocking on both sides, then blocking if (!rc.canMove(myLoc.directionTo(left)) && !rc.canMove(myLoc.directionTo(right))) { return true; } } return false; }
/** * @param desiredDir * @param otherDir * @return Integer.MAX_VALUE if otherDir can't be rotated to desiredDir or... TODO */ private static double distanceFromDirection(Direction desiredDir, Direction otherDir) { double[] weights = {0, 3, 8, 15, 25}; // double[] weights = {0.75, 0.8, .85, .9, .95}; // double[] weights = {1, 1.0001, 1.0002, 1.0003, 1.0004}; Direction leftRotation = otherDir; Direction rightRotation = otherDir; for (int i = 0; i <= 4; i++) { if (desiredDir.equals(leftRotation) || desiredDir.equals(rightRotation)) { return weights[i]; } leftRotation = leftRotation.rotateLeft(); rightRotation = rightRotation.rotateRight(); } return Integer.MAX_VALUE; }
protected void tryMove(Direction direction) throws GameActionException { if (rc.canMove(direction)) { rc.move(direction); return; } Direction left = direction.rotateLeft(); if (rc.canMove(left)) { rc.move(left); return; } Direction right = direction.rotateRight(); if (rc.canMove(right)) { rc.move(right); return; } for (int i = 0; i < 2; i++) { left = left.rotateLeft(); if (rc.canMove(left)) { rc.move(left); return; } right = right.rotateRight(); if (rc.canMove(right)) { rc.move(right); return; } } if (rc.getType() != RobotType.TTM) { tryClearRubble(direction); } }
protected void goTo(Direction direction) throws GameActionException { Direction destinationDirection = direction; Direction currentDirection = destinationDirection; while (!myRC.canMove(currentDirection) && !currentDirection.equals(destinationDirection.rotateLeft())) { currentDirection = currentDirection.rotateRight(); } if (myRC.canMove(currentDirection)) { if (!myRC.getDirection().equals(currentDirection)) { myRC.setDirection(currentDirection); } else { myRC.moveForward(); } } }
/** * @param rc * @param dirToCorner * @return the location of the corner in the given direction or LOCATION_NONE if it is not a * corner * @throws GameActionException */ private static MapLocation checkForCorner(RobotController rc, Direction dirToCorner) throws GameActionException { int senseRadiusMinusOneSquared = (int) Math.pow(Math.sqrt(rc.getType().sensorRadiusSquared) - 1, 2); // so that when you add one below to check for a corner, you can still sense the +1 location MapLocation[] nearby = MapLocation.getAllMapLocationsWithinRadiusSq(rc.getLocation(), senseRadiusMinusOneSquared); boolean isCorner = true; MapLocation corner = getFurthestInDirection(rc, nearby, dirToCorner); Direction[] nearDirections = {dirToCorner, dirToCorner.rotateLeft(), dirToCorner.rotateRight()}; for (Direction dir : nearDirections) { if (rc.onTheMap(corner.add(dir))) { isCorner = false; } } return isCorner ? corner : LOCATION_NONE; }
private static void herdTowardPastrSmart() throws GameActionException { if (smartLoc == null || smartLoc.distanceSquaredTo(pastr) <= GameConstants.PASTR_RANGE) { smartLoc = pastr.add( nextStartDir, nextStartDir.isDiagonal() ? maxDiagonalRadius - 3 : maxOrthogonalRadius - 3); nextStartDir = nextStartDir.rotateRight(); edgeTrimIndex = edgesX.length - 1; // Debug.indicate("herd", 0, "starting new spoke"); } while (edgeTrimIndex >= 0) { MapLocation edge = new MapLocation(pastr.x + edgesX[edgeTrimIndex], pastr.y + edgesY[edgeTrimIndex]); edgeTrimIndex--; if (isOnMap(edge) && rc.canSenseSquare(edge) && rc.senseCowsAtLocation(edge) > 1000) { MapLocation targetSquare = edge.add(pastr.directionTo(edge)); if (rc.canAttackSquare(targetSquare)) { rc.attackSquareLight(targetSquare); return; } } } while (!rc.canAttackSquare(smartLoc) || !isOnMap(smartLoc)) { Direction moveDir = smartLoc.directionTo(pastr); Direction computedMoveDir = HerdPattern.readHerdDir(smartLoc, rc); if (computedMoveDir != null) moveDir = computedMoveDir; smartLoc = smartLoc.add(moveDir); if (here.distanceSquaredTo(smartLoc) > RobotType.NOISETOWER.attackRadiusMaxSquared) { smartLoc = null; return; } if (smartLoc.equals(pastr)) return; // otherwise in some situations we could get an infinite loop } Direction herdDir = smartLoc.directionTo(pastr); Direction computedHerdDir = HerdPattern.readHerdDir(smartLoc, rc); if (computedHerdDir != null) herdDir = computedHerdDir; MapLocation targetSquare = smartLoc.add(Util.opposite(herdDir), 3); // Debug.indicate("herd", 2, "want to attack " + targetSquare.toString()); if (rc.canAttackSquare(targetSquare)) rc.attackSquare(targetSquare); smartLoc = smartLoc.add(herdDir); }
/** * If robotType is null, compute where to move. Else compute where to build. * * @param rc * @param dir * @param robotType * @return Direction to move/build in */ static Direction findPathDirection(RobotController rc, Direction dir, RobotType robotType) { final int maxRotations = 8; int diff = rand.nextInt(2); for (int i = 0; i <= maxRotations; ++i) { if (i == maxRotations) return Direction.NONE; if ((i + diff) % 2 == 0) { for (int j = 0; j < i; ++j) dir = dir.rotateLeft(); } else { for (int j = 0; j < i; ++j) dir = dir.rotateRight(); } if (robotType == null) { if (rc.canMove(dir)) break; } else { if (rc.canBuild(dir, robotType)) break; } } return dir; }
private static MapLocation getFurthestInDirection( RobotController rc, MapLocation[] locs, Direction dir) throws GameActionException { final MapLocation myLocation = rc.getLocation(); MapLocation furthest = myLocation.add(dir); int furthestDist = myLocation.distanceSquaredTo(furthest); List<Direction> directionsTowards = Arrays.asList(dir, dir.rotateLeft(), dir.rotateRight()); for (MapLocation loc : locs) { if (directionsTowards.contains(myLocation.directionTo(loc))) { if (rc.onTheMap(loc)) { int dist = myLocation.distanceSquaredTo(loc); if (dist > furthestDist) { furthestDist = dist; furthest = loc; } } } } return furthest; }
public Direction getNextDir(int tolerance) { if (controllers.myRC.getLocation().equals(previousRobLoc)) { if (controllers.motor.canMove(previousDir)) { // controllers.myRC.setIndicatorString(1, "precomputed"); return previousDir; } // else if (!controllers.motor.isActive() && // controllers.motor.canMove(previousDir.rotateRight())) { // isTracing = false; // previousDir = previousDir.rotateRight(); // controllers.myRC.setIndicatorString(1, "yield"); // return previousDir; // } else { // controllers.myRC.setIndicatorString(1, "detour " + isCW); if (!isTracing) { previousDir = detour(controllers.myRC.getDirection(), isCW); } else { Direction faceDir = controllers.myRC.getDirection(); Direction startTracingDir = isCW ? faceDir.rotateRight().rotateRight() : faceDir.rotateLeft().rotateLeft(); previousDir = detour(startTracingDir, isCW); } } return previousDir; } else { // controllers.myRC.setIndicatorString(1, "bugging"); previousRobLoc = controllers.myRC.getLocation(); if (destination == null) { reset(); previousDir = Direction.OMNI; return Direction.OMNI; } else { previousDir = Bug(controllers.myRC.getLocation(), modifiedDes, tolerance); return previousDir; } } }