コード例 #1
0
ファイル: NoiseTowerBehavior.java プロジェクト: jalman/armada
 public static boolean pathbetween(MapLocation a, MapLocation b) {
   while (!a.equals(b)) {
     a = a.add(a.directionTo(b));
     if (RC.senseTerrainTile(a) == TerrainTile.VOID) return false;
   }
   return true;
 }
コード例 #2
0
ファイル: SoldierBehavior.java プロジェクト: jalman/armada
  private MapLocation findRichSquare() {
    double maxCows = currentCowsHere + 50 * COW_GROWTH[curX][curY] + 300; // favor staying here
    double curCows;

    MapLocation best = currentLocation;
    for (MapLocation current :
        MapLocation.getAllMapLocationsWithinRadiusSq(
            currentLocation, RobotType.SOLDIER.sensorRadiusSquared)) {
      try {
        if (RC.senseTerrainTile(current) == TerrainTile.OFF_MAP) continue;

        curCows = RC.senseCowsAtLocation(current) + 50 * COW_GROWTH[current.x][current.y];
        if (curCows > maxCows && RC.senseObjectAtLocation(current) == null) {
          best = current;
          maxCows = curCows;
        }
      } catch (GameActionException e) {
        e.printStackTrace();
      }
    }

    RC.setIndicatorString(1, "max nearby cows: " + maxCows + " at " + best);
    if (maxCows > 1000) {
      return best;
    }

    return null;
  }
コード例 #3
0
ファイル: Dijkstra.java プロジェクト: jalman/armada
  /**
   * Compute until either bytecodes have run out or we find a destination.
   *
   * @param end Hash-map of destination.
   * @param bytecodes The bytecode limit.
   * @param broadcast Whether to broadcast the results (used by the HQ).
   * @return Whether we found a destination.
   */
  public boolean compute(boolean[][] end, int bytecodes, boolean broadcast) {
    // cache variables
    int min, w, x, y;
    int[] weight;
    MapLocation next, nbr, prev, p;
    Direction dir;
    final BucketQueue<MapLocation> queue = this.queue;
    final int[][] distance = this.distance;
    final Direction[][] from = this.from;
    // final MapLocation[][] parent = this.parent;
    final boolean[][] unsafe = getUnsafe();

    // int iters = 0;
    // int bc = Clock.getBytecodeNum();

    while (queue.size > 0) {
      // iters++;
      if (Clock.getBytecodeNum() >= bytecodes - 500) {
        break;
      }

      // RC.setIndicatorString(0, Integer.toString(min));
      // ALERT: queue.min is valid only after a call to deleteMin()!
      next = queue.deleteMin();
      min = queue.min;

      x = next.x;
      y = next.y;

      // check if we have already visited this node
      if (min == distance[x][y]) {
        if (unsafe[x][y]) min += 100;

        dir = from[x][y];

        /*
         * if (dir != null) {
         * prev = next.subtract(dir);
         * p = parent[prev.x][prev.y];
         * if (min <= distance[p.x][p.y] + PARENT_DIST) {
         * parent[x][y] = p;
         * } else {
         * parent[x][y] = prev;
         * }
         * }
         */

        if (broadcast) {
          try {
            messagingSystem.writePathingInfo(next, dir, min, null /* parent[x][y] */);
          } catch (GameActionException e) {
            // e.printStackTrace();
          }
        }

        // if (end[x][y]) {
        // reached = next;
        // break;
        // }

        weight = WEIGHT[RC.senseTerrainTile(next).ordinal()];

        int i;
        if (dir == null) {
          dir = Direction.NORTH;
          i = 8;
        } else if (dir.isDiagonal()) {
          dir = dir.rotateLeft().rotateLeft();
          i = 5;
        } else {
          dir = dir.rotateLeft();
          i = 3;
        }

        for (; --i >= 0; dir = dir.rotateRight()) {
          nbr = next.add(dir);
          if (RC.senseTerrainTile(nbr).isTraversableAtHeight(RobotLevel.ON_GROUND)) {
            w = min + weight[dir.ordinal()];

            x = nbr.x;
            y = nbr.y;

            if (from[x][y] == null) {
              queue.insert_fast(w, nbr);
              // System.out.println("inserted " + nbr + " with distance " + w + " from " + dir);
              distance[x][y] = w;
              from[x][y] = dir;
            } else {
              if (w < distance[x][y]) {
                queue.insert_fast(w, nbr);
                distance[x][y] = w;
                from[x][y] = dir;
              }
            }
          }
        }
      }
    }

    // bc = Clock.getBytecodeNum() - bc;
    // RC.setIndicatorString(2, "average Dijkstra bytecodes: " + bc / iters);

    return reached != null;
  }
コード例 #4
0
ファイル: NoiseTowerBehavior.java プロジェクト: jalman/armada
  public NoiseTowerBehavior() {
    for (int i = 7; i >= 0; i--) {
      int lastdir = (i + 4) % 8;
      int at = 1;
      paths[i][0] = currentLocation;
      int lastcow = 0;
      for (int j = 1; j < 30; j++) {
        if (i < 7 && RC.isActive()) {
          try {
            makeSomeNoise();
          } catch (GameActionException e1) {
            e1.printStackTrace();
          }
        }

        int k = lastdir + 2;
        k %= 8;
        int bestscore = -1;
        MapLocation bestplace = currentLocation;
        while (k != (lastdir + 6) % 8) {

          int score = Math.abs(i - k);
          if (score < 4) score = 8 - score;
          score *= score * score;
          MapLocation here = paths[i][j - 1].add(directions[k]);
          double cows;
          try {
            cows = Utils.COW_GROWTH[here.x][here.y];
            if (cows > 0) lastcow = j;
            score =
                (here.add(directions[k])).distanceSquaredTo(currentLocation) > 300
                        || RC.senseTerrainTile(here) == TerrainTile.VOID
                    ? -10
                    : cows == 0.0 ? 30 : score + (int) (cows) * 0 + 30;
          } catch (Exception e) {
            score = -2;
          }

          if (score > bestscore) {
            bestscore = score;
            bestplace = here;
          }

          k++;
          if (k == 8) k = 0;
        }
        if (!bestplace.equals(currentLocation)) {
          paths[i][j] = bestplace;
        } else {
          break;
        }
      }
      pathat[i] = lastcow;
      while (paths[i][pathat[i]] == null && pathat[i] > 0) pathat[i]--;
      if (lastcow < 29) lastcow++;
    }

    skip[0] = false;

    double[] d = new double[8];
    int[] dist = new int[8];
    MapLocation[] toconsider = new MapLocation[8];

    for (int i = 7; i >= 0; i--) {
      if (pathat[i] == 0) {
        d[i] = 0;
        dist[i] = 0;
      } else {
        toconsider[i] = paths[i][pathat[i] - 1];
        d[i] = Math.atan2(toconsider[i].y - curY, toconsider[i].x - curX);
        dist[i] = currentLocation.distanceSquaredTo(toconsider[i]);
      }
    }
    for (int i = 7; i >= 0; i--) {
      if (dist[i] == 0) skip[i] = true;
      else {
        for (int j = i - 1; j >= 0; j--) {
          if (i == j || dist[j] == 0) continue;
          if (Math.abs(d[i] - d[j]) < 0.4 && pathbetween(toconsider[i], toconsider[j])) {
            if (dist[i] < dist[j]) skip[i] = true;
            else skip[j] = true;
          }
        }
      }
    }
  }
コード例 #5
0
ファイル: BFSNoiseTower.java プロジェクト: jalman/armada
  public BFSNoiseTower() throws GameActionException {
    System.out.println("start " + Clock.getBytecodeNum());

    queue[0] = currentLocation;
    dir[17][17] = Direction.OMNI;

    for (int i = 7; i >= 0; i--) {
      Direction d = directions[i];
      MapLocation loc = currentLocation.add(d);
      TerrainTile there = RC.senseTerrainTile(loc);
      if (!there.isTraversableAtHeight(RobotLevel.ON_GROUND)) continue;
      int x = loc.x - currentLocation.x;
      int y = loc.y - currentLocation.y;
      dir[x + 17][y + 17] = d.opposite();
      queue[at] = loc;
      at++;
    }

    for (int s = 1; s < at; s++) {
      if (s % 30 == 0 && RC.isActive()) {
        if (target == null
            || target.distanceSquaredTo(ALLY_PASTR_COUNT > 0 ? ALLY_PASTR_LOCS[0] : currentLocation)
                <= 5) {
          earlyNearbyCows();
        }
        MapLocation realTarget = target.add(currentLocation.directionTo(target), 3);

        if (RC.canAttackSquare(realTarget)) RC.attackSquare(realTarget);

        target = target.add(target.directionTo(currentLocation));
      }

      Direction initD =
          dir[queue[s].x - currentLocation.x + 17][queue[s].y - currentLocation.y + 17];
      Direction aD;
      Direction bD;
      if (initD.isDiagonal()) {
        aD = initD.rotateLeft().rotateLeft();
        bD = initD.rotateRight();
      } else {
        aD = initD.rotateLeft().rotateLeft().rotateLeft();
        bD = initD.rotateRight().rotateRight();
      }
      for (Direction d = aD; d != bD; d = d.rotateLeft()) {
        MapLocation loc = queue[s].add(d);
        TerrainTile there = RC.senseTerrainTile(loc);
        if (!there.isTraversableAtHeight(RobotLevel.ON_GROUND)) continue;
        int x = loc.x - currentLocation.x;
        int y = loc.y - currentLocation.y;
        if (x * x + y * y > 200) continue;

        if (dir[x + 17][y + 17] == null) {
          dir[x + 17][y + 17] = d.opposite();
          queue[at] = loc;
          at++;
        }
      }
    }

    System.out.println("end " + Clock.getBytecodeNum());
    System.out.println("at " + at);
  }
コード例 #6
0
ファイル: DStar.java プロジェクト: jalman/armada
  public boolean compute(int bytecodes) {
    // cache variables
    int d, w, e, x, y;
    int[] weight;
    MapLocation next, nbr;
    Direction dir;
    final BucketQueue<MapLocation> queue = this.queue;
    final int[][] distance = this.distance;
    final Direction[][] from = this.from;

    // int iters = 0;
    // int bc = Clock.getBytecodeNum();

    while (queue.size > 0) {
      // iters++;
      if (Clock.getBytecodeNum() >= bytecodes - 600) {
        break;
      }

      // RC.setIndicatorString(0, Integer.toString(min));
      // ALERT: queue.min is valid only after a call to deleteMin()!
      next = queue.deleteMin();

      x = next.x;
      y = next.y;
      d = distance[x][y];

      // check if we have already visited this node
      if (!visited[x][y]) {
        visited[x][y] = true;
        /*
         * if (broadcast) {
         * try {
         * messagingSystem.writePathingDirection(next, from[x][y]);
         * } catch (GameActionException ex) {
         * ex.printStackTrace();
         * }
         * }
         */

        weight = WEIGHT[RC.senseTerrainTile(next).ordinal()];

        dir = from[x][y];
        int i;
        if (dir == Direction.NONE) {
          dir = Direction.NORTH;
          i = 8;
        } else if (dir.isDiagonal()) {
          dir = dir.rotateLeft().rotateLeft();
          i = 5;
        } else {
          dir = dir.rotateLeft();
          i = 3;
        }

        for (; --i >= 0; dir = dir.rotateRight()) {
          nbr = next.add(dir);
          if (RC.senseTerrainTile(nbr).isTraversableAtHeight(RobotLevel.ON_GROUND)) {
            w = d + weight[dir.ordinal()];
            e = w + heuristic(next, dest);

            x = nbr.x;
            y = nbr.y;

            if (from[x][y] == null) {
              queue.insert(e, nbr);
              // if (RC.getRobot().getID() == 118)
              // System.out.println("inserted " + nbr + ": " + w + " " + e);
              distance[x][y] = w;
              // estimate[x][y] = e;
              from[x][y] = dir;
            } else {
              if (w < distance[x][y]) {
                queue.insert(e, nbr);
                distance[x][y] = w;
                // estimate[x][y] = e;
                from[x][y] = dir;
                visited[x][y] = false;
              }
            }
          }
        }
      }
    }

    // bc = Clock.getBytecodeNum() - bc;
    // RC.setIndicatorString(2, "average DStar bytecodes: " + (iters > 0 ? bc / iters : bc));

    return arrived(dest);
  }