Ejemplo n.º 1
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;
 }
Ejemplo n.º 2
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;
  }
Ejemplo n.º 3
0
  // Computers
  private static void runOther() {
    int numTowers = -1;
    while (true) {
      threats.update();
      myLoc = rc.getLocation();

      // Move if we can and want to
      if (rc.isCoreReady() && myType.canMove()) {
        if (shouldRetreat()) doRetreatMove(); // Pull back if in range of the enemy guns
        else doAdvanceMove(); // Move towards our HQ
      }

      doTransfer();

      // Perform a background breadth first search to the enemy HQ
      if (myType == RobotType.COMPUTER && Clock.getBytecodesLeft() > 1000) {
        bfs.work(threats.enemyHQ, Bfs.PRIORITY_HIGH, 1000, numTowers != threats.enemyTowers.length);
      }
      numTowers = threats.enemyTowers.length;
      rc.yield();
    }
  }
Ejemplo n.º 4
0
  // 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();
    }
  }
Ejemplo n.º 5
0
  private boolean doWork(MapLocation dest, int priority, int stopWhen, int page)
      throws GameActionException {
    if (!dest.equals(previousDest)) {
      initQueue(dest);
      System.out.print(
          "Cleanser BFS to "
              + dest
              + ", page "
              + page
              + ", start round "
              + Clock.getRoundNum()
              + "\n");
    }

    previousDest = dest;
    previousPage = page;
    previousRoundWorked = Clock.getRoundNum();

    int emptyCount = 0;
    while (emptyCount < NUM_QUEUES
        && qHeads[currentQ] == qTails[currentQ]) { // Skip over empty queues
      emptyCount++;
      currentQ = (currentQ + 1) % NUM_QUEUES;
    }
    if (emptyCount == NUM_QUEUES) return true; // Finished

    while (Clock.getBytecodesLeft() > stopWhen) {
      // pop a location from the queue
      int data = locQueues[qHeads[currentQ]];
      int locX = data >> 24;
      int locY = (data >> 16) & 0xff;
      double delay = (data & 0xffff) / 10;
      if (++qHeads[currentQ] % MAX_QUEUE_SIZE == 0) qHeads[currentQ] -= MAX_QUEUE_SIZE;

      for (int i = 8; i-- > 0; ) {
        int x = cropX(locX + dirsX[i]);
        int y = cropY(locY + dirsY[i]);
        boolean isDiagonal = (i <= 3);

        if (!processed[x][y]) {
          processed[x][y] = true;
          TerrainTile t = map.tile(x, y);

          if (t.isTraversable()) {
            MapLocation newLoc = new MapLocation(x, y);
            // push newLoc onto queue - pick queue according to how long the move takes
            double newDelay;
            if (isDiagonal) newDelay = diagonalDelay;
            else newDelay = moveDelay;
            int newQ = (currentQ + (int) (newDelay + (delay % 1))) % NUM_QUEUES;
            newDelay += delay;
            locQueues[qTails[newQ]] = (x << 24) | (y << 16) | (int) (newDelay * 10);
            if (++qTails[newQ] % MAX_QUEUE_SIZE == 0) qTails[newQ] -= MAX_QUEUE_SIZE;
            // System.out.print("Adding " + x + ", " + y + " to queue " + newQ + " element " +
            // qTails[newQ] + "\n");
            publishResult(page, newLoc, dest, dirs[i], (int) newDelay);
          } else if (t == TerrainTile.UNKNOWN) containsUnknowns = true;
        }
      }
      emptyCount = 0;
      while (emptyCount < NUM_QUEUES
          && qHeads[currentQ] == qTails[currentQ]) { // Skip over empty queues
        emptyCount++;
        currentQ = (currentQ + 1) % NUM_QUEUES;
      }
      if (emptyCount == NUM_QUEUES) {
        // map.dump();
        break;
      }
    }

    writePageMetadata(page, previousRoundWorked, dest, priority, (emptyCount == NUM_QUEUES));
    return (emptyCount == NUM_QUEUES && containsUnknowns == false);
  }