示例#1
0
文件: HQ.java 项目: TeamYOLO/BC2013
  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();
    }
  }
示例#2
0
  // 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;
  }
示例#3
0
文件: HQ.java 项目: TeamYOLO/BC2013
  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;
  }
示例#4
0
 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);
 }
示例#5
0
  public void run() {
    while (true) {
      try {
        Robot[] enemies = rc.senseNearbyGameObjects(Robot.class, 35, rc.getTeam().opponent());

        if (rc.isActive()) {
          Movement.fire(rc, enemies, null);
          HQFunctions.SpawnSoldiers(rc);
        }

        if (Clock.getRoundNum() % 50 == 0) {
          System.out.println();
          System.out.println("Enemy Bots: ");
          int[] AllEnemies = FightMicro.AllEnemyBots(rc);
          for (int i = 0; i < AllEnemies.length; i++) {
            System.out.print(FightMicro.getBotLocation(AllEnemies[i]));
          }
          System.out.println();
        }

        int broadcast = rc.readBroadcast(rallyPoint2);
        if (broadcast != 0) {
          if (broadcast != fightZone) {
            fightZone = broadcast;
            roundSet = Clock.getRoundNum();
          }
          // now it is time for us to move on
          else if (roundSet + 75 < Clock.getRoundNum()) {
            fightZone = 0;
            rc.broadcast(rallyPoint2, 0);
          }
        }

        if (Clock.getRoundNum() % 5 == 0 && Clock.getRoundNum() > 100) {
          // HQFunctions.moveTargetLocationRandomly(rc);
          /*
          if (goneForPastr && (rc.sensePastrLocations(rc.getTeam()).length > 0 || roundNum > (Clock.getRoundNum() - 250)))
          {
              HQFunctions.setTargetLocation(rc, goneForPastr);
          }
          else
          {
              goneForPastr = HQFunctions.setTargetLocation(rc, goneForPastr);
              roundNum = Clock.getRoundNum();
          }*/
          HQFunctions.setTargetLocation(rc, true);
          // HQFunctions.findInitialRally(rc);

        }
      } catch (Exception e) {
      }
      rc.yield();
    }
  }
示例#6
0
  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);
    }
  }
示例#7
0
 public static void loop(RobotController theRC) throws GameActionException {
   Clock.yield();
   Bot.init(theRC);
   init();
   while (true) {
     try {
       turn();
     } catch (Exception e) {
       e.printStackTrace();
     }
     Clock.yield();
   }
 }
示例#8
0
  // 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);
  }
示例#9
0
  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();
    }
  }
示例#10
0
public class Util {

  static int m_z = Clock.getBytecodeNum();
  static int m_w = Clock.getRoundNum();

  /**
   * Sets up our RNG given two seeds.
   *
   * @param seed1
   * @param seed2
   */
  public static void randInit(int seed1, int seed2) {
    m_z = seed1;
    m_w = seed2;
  }

  private static int gen() {
    m_z = 36969 * (m_z & 0xFFFF) + (m_z >> 16);
    m_w = 18000 * (m_w & 0xFFFF) + (m_w >> 16);
    return (m_w << 16) + m_z;
  }

  /**
   * Returns a random {@link Integer#MIN_VALUE} and {@link Integer#MAX_VALUE}
   *
   * @return
   */
  public static int randInt() {
    return gen();
  }

  /**
   * Returns a double between 0 and 1.0
   *
   * @return
   */
  public static double randDouble() {
    return (gen() * 2.32830644e-10 + 0.5);
  }

  /**
   * Calls randDouble()
   *
   * @return
   */
  public static double Random() {
    return randDouble();
  }
}
示例#11
0
  public LinkedList<MapLocation> pathFind(MapLocation start, MapLocation target)
      throws GameActionException {
    //		for (int i = 0; i < myRobot.allies.length; i++) {
    //			RobotInfo r = rc.senseRobotInfo(myRobot.allies[i]);
    //			if (myRobot.allies[i].getID() == myRobot.ID) continue;
    //			map[r.location.x][r.location.y] = -2;
    //		}
    //		for (int i = 0; i < myRobot.enemies.length; i++) {
    //			RobotInfo r = rc.senseRobotInfo(myRobot.enemies[i]);
    //			map[r.location.x][r.location.y] = -2;
    //		}
    int x = Clock.getRoundNum();
    SearchNode bugSearch = bugSearch(start, target);
    SearchNode[] nodes = new SearchNode[bugSearch.length];
    int counter = bugSearch.length - 1;
    while (bugSearch.prevLoc != null) {
      nodes[counter] = bugSearch;
      bugSearch = bugSearch.prevLoc;
      counter--;
    }

    nodes[0] = bugSearch;
    LinkedList<MapLocation> pivots = new LinkedList<MapLocation>();
    pivots.add(nodes[0].loc);

    for (int i = 1; i < nodes.length; i++) {
      if (nodes[i].isPivot) {
        pivots.add(nodes[i].loc);
      }
    }

    counter = 0;
    ListIterator<MapLocation> li1 = pivots.listIterator(), li2;
    while (li1.hasNext()) {
      li2 = pivots.listIterator(pivots.size());
      while (li2.hasPrevious() && li2.previousIndex() > li1.nextIndex() + 1) {
        if (canTravel(li1.next(), li2.previous())) {
          pivots.subList(li1.nextIndex(), li2.previousIndex() + 1).clear();
          li1 = pivots.listIterator(++counter);
          break;
        }
        li1.previous();
      }
      li1.next();
    }

    if (false) System.out.println(Clock.getRoundNum() - x);
    return pivots;
  }
 public void fightingCode() throws GameActionException {
   if (DataCache.numEnemyRobots == 0) {
     if (DataCache.numAlliedSoldiers < Constants.FIGHTING_NOT_ENOUGH_ALLIED_SOLDIERS) {
       if (!ourNukeHalfDone && enemyNukeHalfDone) {
         nextSoldierState = SoldierState.PUSHING;
         pushingCode();
       } else {
         if (Clock.getRoundNum() >= 200) {
           nextSoldierState = SoldierState.RALLYING;
           rallyingCode();
         } else {
           nextSoldierState = SoldierState.PUSHING;
           pushingCode();
         }
       }
     } else {
       nextSoldierState = SoldierState.PUSHING;
       pushingCode();
     }
   } else {
     // Otherwise, just keep fighting
     if (strategy == Strategy.NUKE) {
       defendMicro();
     } else {
       microCode();
     }
   }
 }
示例#13
0
  public static void workOnCache(RobotController rc, int bytecodeLimit) {
    if (cacheFinished) return;

    int mapWidth = rc.getMapWidth();
    int mapHeight = rc.getMapHeight();

    int x, y;
    if (workStarted) {
      x = workLocX;
      y = workLocY;
    } else {
      x = mapWidth - 1;
      y = mapHeight - 1;
      workStarted = true;
    }

    outerloop:
    while (x >= 0) {
      while (y >= 0) {
        terrain[x][y] = rc.senseTerrainTile(new MapLocation(x, y));
        y--;
        // TODO: this is in a tight loop so it would be nice to do this check less often
        if (Clock.getBytecodeNum() > bytecodeLimit) break outerloop;
      }
      y = mapHeight - 1;
      x--;
    }

    workLocX = x;
    workLocY = y;

    if (x < 0) cacheFinished = true;
  }
示例#14
0
  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());
    }
  }
示例#15
0
  // 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();
    }
  }
示例#16
0
  // Determines squad of robot to by spawned next
  private static int nextSquadNum(RobotController rc) throws GameActionException {
    // If it reads that defensive robots are dying from channel 10
    int squad = rc.readBroadcast(Util.spawnNext);
    if (squad != 0 && squad < 11 && !rush) {
      rc.broadcast(Util.spawnNext, 0); // reset value
      //			System.out.println("spawning a replacement for defender" + squad);
      return squad;
    }

    // If starting out a rush, spawn enough attacking squads.
    boolean rushFailed = false; // temporary hot fix - later this should be a checkpoint
    int rushRetreat = computeRushRetreat(rc);
    if (rush && Clock.getRoundNum() < rushRetreat && !rushFailed) { // TODO decide when to stop rush
      for (int i = 11; i < 12; i++) {
        if ((rc.readBroadcast(i) / 10000) % 10 < 8) return i;
      }
    }

    // Else if didn't establish pastures yet, need defensive squads
    for (int i = 3; i < 3 + desiredPASTRs.length; i++) {
      if ((rc.readBroadcast(i) / 10000) % 10 < 6) return i;
    }

    // else spawn attackers
    for (int i = 11; i < 21; i++) {
      if ((rc.readBroadcast(i) / 10000) % 10 < 6) return i;
    }

    return 3;
  }
示例#17
0
 public static void continueComputation() {
   // System.out.println("b" + Clock.getBytecodesLeft());
   if (!started) return;
   while (!que.isEmpty()) {
     if (Clock.getBytecodesLeft() < 2000) return;
     MapLocation loc = que.poll().b;
     if (visited[loc.x][loc.y]) continue;
     visited[loc.x][loc.y] = true;
     int thisDist = distances[loc.x][loc.y] + costs[loc.x][loc.y];
     int nextX, nextY, dy;
     for (int dx = -1; dx <= 1; ++dx)
       for (dy = -1; dy <= 1; ++dy) {
         nextX = loc.x + dx;
         nextY = loc.y + dy;
         if (nextX < 0 || nextX >= gridWidth || nextY < 0 || nextY >= gridHeight) continue;
         if (distances[nextX][nextY] > thisDist) {
           distances[nextX][nextY] = thisDist;
           que.add(Pair.of(thisDist, new MapLocation(nextX, nextY)));
           parents[nextX][nextY] = loc;
         }
       }
     // System.out.println("c" + Clock.getBytecodesLeft());
   }
   done = true;
 }
示例#18
0
 /**
  * 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 yield() {
    if (my_type == RobotType.ARCHON) rc.setIndicatorString(0, "Beta 1.5");

    if (rc.getRoundNum() % 25 == 0) Scanner.reset_health();

    Clock.yield();
  }
示例#20
0
 /**
  * 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();
     }
   }
 }
示例#21
0
 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();
   }
 }
示例#22
0
  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);
  }
示例#23
0
  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;
  }
示例#24
0
 private static void viper(RobotController rc) {
   // in case we use vipers later
   // do one time things here
   while (true) {
     rc.disintegrate();
     Clock.yield();
   }
 }
示例#25
0
  // returns the number of enemy/allied robots if a robot were to go in each direction.
  // number of allied is in 10s place, number of enemies is in 1s, a 100 means the direction is
  // blocked
  public static int[] getNeighborStats(int badLocs) throws GameActionException {

    // TODO: Remove this
    int a = Clock.getBytecodesLeft();

    Robot[] NearbyRobots =
        mRC.senseNearbyGameObjects(
            Robot.class, 2 * 2 + 2 * 2, ARobot.mEnemy); // 2 in either direction

    MapLocation roboLoc = mRC.getLocation();

    // This array is NUM_DIR + 1 0s, the +1 is for the not moving location
    int[] eachDirectionStats = {0, 0, 0, 0, 0, 0, 0, 0, 0};
    ArrayList<LocationAndIndex> directionLocs = new ArrayList<LocationAndIndex>();
    Direction tempDir;

    // Initialize all the locations
    for (int i = 0; i < NUM_DIR; i++) {
      tempDir = Direction.values()[i];
      if (mRC.canMove(tempDir) && ((badLocs >> i) & 1) != 1) {

        directionLocs.add(new LocationAndIndex(roboLoc.add(tempDir), i));
      } else {
        eachDirectionStats[i] = 100; // This signifies the spot is not movable
      }
    }

    // Go through all the robots and see if they're near any of the squares next to us
    MapLocation tempLocation = null;
    for (Robot r : NearbyRobots) {
      tempLocation = mRC.senseRobotInfo(r).location;
      for (LocationAndIndex mp : directionLocs) {
        if (tempLocation.distanceSquaredTo(mp.mp) < 2) { // 2 means directly next to us				
          eachDirectionStats[mp.i] += 1;
        }
      }
      if (tempLocation.distanceSquaredTo(roboLoc) < 2) {
        eachDirectionStats[NUM_DIR] += 1;
      }
    }
    mRC.setIndicatorString(1, "bytecode used for neighbor: " + (a - Clock.getBytecodesLeft()));
    return eachDirectionStats;
  }
  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
    }
  }
示例#27
0
 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);
 }
示例#28
0
 ///////////////////////////////////////////////////////////
 // moveClear()
 //
 private static void moveClear() throws GameActionException {
   while (true) {
     MapLocation center = closestArchonLoc();
     if (rc.getLocation().distanceSquaredTo(center) >= guardRad) break;
     else {
       if (!moveAway(center)) break;
     }
   }
   rc.unpack();
   Clock.yield();
 }
示例#29
0
 public static void run(RobotController _rc) throws GameActionException {
   Bot.init(_rc);
   init();
   while (true) {
     myLocation = rc.getLocation();
     Radio.process();
     action();
     Radio.clear();
     Clock.yield();
   }
 }
示例#30
0
  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);
    }
  }