Exemple #1
0
  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;
    }
  }
Exemple #2
0
 private boolean move(Direction dir) throws GameActionException {
   if (!RC.isActive() || !RC.canMove(dir)) return false;
   switch (movementType) {
     case SNEAK:
       RC.sneak(dir);
       break;
     case RUN:
       RC.move(dir);
       break;
   }
   return true;
 }
  /** Called every round. */
  @Override
  public void run() throws GameActionException {
    while (!RC.isActive()) {
      RC.yield();
    }
    Robot[] robots = Utils.RC.senseNearbyGameObjects(Robot.class, 35, ENEMY_TEAM);
    Utils.RC.setIndicatorString(1, "" + robots.length);
    for (int i = 0; i < robots.length; ++i) {
      messagingSystem.writeAttackMessage(Utils.RC.senseRobotInfo(robots[i]).location);
      messagingSystem.writeMicroMessage(Utils.RC.senseRobotInfo(robots[i]).location, 1);
    }

    makeSomeNoise();
  }
Exemple #4
0
  /**
   * 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()));
  }
  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;
          }
        }
      }
    }
  }
Exemple #6
0
  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);
  }
Exemple #7
0
  @Override
  public void run() throws GameActionException {
    if (luge()) { // luge = micro
      // set mode to ATTACK or something
      return;
      // send message?
    } else if (mode != Mode.ENGAGE
        && mode != Mode.ACQUIRE_TARGET
        && mode != Mode.BIRTH_DECIDE_MODE
        && mode != Mode.FIND_PASTR_LOC
        && mode != Mode.BUILD_PASTR) {
      if (ENEMY_MILK - ALLY_MILK > 50000 || ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT) {
        changeMode(Mode.ACQUIRE_TARGET);
      } else {
        // try to build pastures if late in game
        // probably deprecated (doesn't happen)
        if (currentRound > 1800 && ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT && !panicPastrBuilding) {
          if (currentCowsHere < 150) {
            panicPastrBuilding = true;
            dest = ALLY_HQ.subtract(ALLY_HQ.directionTo(ENEMY_HQ));
            mover.setTarget(dest);
            sneakToBuildingLoc = 1;
            changeMode(Mode.FIND_PASTR_LOC);
          } else if (currentCowsHere < 400) {
            panicPastrBuilding = true;
            mover.setTarget(ALLY_HQ);
            changeMode(Mode.RETURN_HOME);
          }
        } else if (!initialSweep) {
          // stand on rich squares
          MapLocation loc = findRichSquare();
          if (loc != null) {
            mover.setTarget(loc);
            changeMode(Mode.STAND_RICH_LOC);
          }
        }
      }
    }

    switch (mode) {
      case BIRTH_DECIDE_MODE:
        int robotNum = RC.senseRobotCount();
        if (ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT + 1
            || (robotNum + currentRound / 100 > 22 && ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT)) {
          roleIndex = ALLY_PASTR_COUNT % 4;
          role = Role.PASTR;
          changeMode(Mode.FIND_PASTR_LOC);
          dest =
              new MapLocation(
                  (ALLY_HQ.x + roleLocList[roleIndex].x) / 2,
                  (ALLY_HQ.y + roleLocList[roleIndex].y) / 2);
        } else {
          roleIndex = robotNum % 4;
          role = roleList[roleIndex];

          changeMode(Mode.SWEEP_OUT);
          dest = roleLocList[roleIndex];

          initialSweep = true;
        }
        mover.setTarget(dest);
        mover.move();
        break;
      case GOING_TO_MIDDLE:
        if (mover.arrived()) {
          decideNextMode();
        } else {
          mover.movePushHome();
        }
        break;
      case SWEEP_OUT:
        if (mover.arrived()) {
          dest =
              new MapLocation(
                  (2 * ALLY_HQ.x + roleLocList[roleIndex].x) / 3,
                  (2 * ALLY_HQ.y + roleLocList[roleIndex].y) / 3);
          mover.setTarget(dest);
          changeMode(Mode.RETURN_HOME);
        } else {
          mover.movePushHome();
        }
        break;
      case RETURN_HOME:
        if (mover.arrived()) {
          dest = roleLocList[roleIndex];
          mover.setTarget(dest);
          changeMode(Mode.SWEEP_OUT);

          initialSweep = false;
        } else {
          mover.movePushHome();
        }
        break;
      case STAND_RICH_LOC:
        if (!mover.arrived()) {
          mover.sneak();
        } else {
          RC.setIndicatorString(1, "cows here: " + currentCowsHere);
          if (currentCowsHere < 500) {
            mover.setTarget(roleLocList[roleIndex]);
            changeMode(Mode.SWEEP_OUT);
          }
        }
        break;
      case FIND_PASTR_LOC:
        if (mover.arrived()) {
          changeMode(Mode.BUILD_PASTR);
        } else {
          mover.execute(sneakToBuildingLoc);
        }
        break;
      case BUILD_PASTR:
        if (!RC.isConstructing() && RC.isActive()) {
          RC.construct(RobotType.PASTR);
        }

        if (RC.getConstructingRounds() == 0) {
          buildingFinished = true;
        }
        break;
      case ACQUIRE_TARGET:
        int mindistance = 10000000;
        MapLocation pastrTarget = null;
        for (MapLocation pastrLoc : ENEMY_PASTR_LOCS) {
          int d = currentLocation.distanceSquaredTo(pastrLoc);
          if (d < mindistance) {
            mindistance = d;
            pastrTarget = pastrLoc;
          }
        }

        if (pastrTarget == null) {
          mover.setTarget(ALLY_HQ);
          changeMode(Mode.RETURN_HOME);
        } else {
          mover.setTarget(pastrTarget);
          changeMode(Mode.ENGAGE);
          mover.move();
        }
        break;
      case ENGAGE:
        if (mover.arrived()) {
          changeMode(Mode.RETURN_HOME);
        } else {
          mover.move();
        }
        break;
      default:
        break;
    }
  }