Пример #1
0
 public double getBaseValue(PlanetUtility p, Location averageLocation, double variance) {
   double distanceFactor =
       (variance + BASE_DISTANCE_FACTOR)
           / (averageLocation.distance(p.planet) + BASE_DISTANCE_FACTOR);
   return (PlayerUtils.getCurrentEventualOwner(p.planet, fleets, this) == PlanetOwner.NOBODY
           ? 1.0
           : AGGRESSION)
       * Math.pow(distanceFactor, DISTANCE_WEIGHTING)
       / p.planet.PRODUCTION_TIME
       / (unitBaseCost + p.units);
 }
Пример #2
0
 public double getAggressiveValue(PlanetUtility p, Location averageLocation, double variance) {
   double distanceFactor =
       (variance + BASE_DISTANCE_FACTOR)
           / (averageLocation.distance(p.planet) + BASE_DISTANCE_FACTOR);
   double baseValue =
       (PlayerUtils.getCurrentEventualOwner(p.planet, fleets, this) == PlanetOwner.NOBODY
               ? 1.0
               : AGGRESSION * AGGRESSION_MULTIPLIER)
           * Math.pow(distanceFactor, DISTANCE_WEIGHTING)
           / p.planet.PRODUCTION_TIME
           / (unitBaseCost + p.units);
   // double stratValue = getDefensiveValue(p.planet, baseValue) / getOffensiveValue(p.planet,
   // baseValue);
   return baseValue;
 }
Пример #3
0
  @Override
  protected void turn() {
    List<Planet> myPlanets = PlayerUtils.getPlanetsOwnedByPlayer(planets, this);
    //      List<Planet> notMyPlanets = PlayerUtils.getPlanetsNotOwnedByPlayer(planets, this);
    //      List<Planet> enemyPlanets = PlayerUtils.getOpponentsPlanets(planets, this);
    //      List<Planet> unownedPlanets = PlayerUtils.getUnoccupiedPlanets(planets);

    int myTotalUnits = PlayerUtils.getMyUnitCount(fleets, planets, this);
    int enemyTotalUnits = PlayerUtils.getOpponentUnitCount(fleets, planets, this);
    int mySpareUnits = 0;
    double myProduction = PlayerUtils.getMyTotalProductionFrequency(planets, this);
    double enemyProduction = PlayerUtils.getEnemyTotalProductionFrequency(planets, this);
    double currentUnitRatio = (myTotalUnits + 0.0001) / (enemyTotalUnits + 0.0001);
    double currentProductionRatio = (myProduction + 0.0001) / (enemyProduction + 0.0001);

    Location averageLocation = Location.center(myPlanets);
    double variance = Location.variance(myPlanets);

    PlayMode mode;
    if (currentUnitRatio > UNIT_ADVANTAGE_RATIO) { // cover more units
      if (currentProductionRatio > PRODUCTION_DISADVANTAGE_RATIO) { // cover more/same production
        mode = PlayMode.CONFIDENT;
      } else { // cover less production
        mode = PlayMode.AGGRESSIVE;
      }
    } else if (currentUnitRatio < UNIT_DISADVANTAGE_RATIO) { // cover less units
      if (currentProductionRatio > PRODUCTION_ADVANTAGE_RATIO) { // cover more production
        mode = PlayMode.DEFENSIVE;
      } else { // cover less/equal production
        mode = PlayMode.DESPARATE;
      }
    } else { // cover same units
      if (currentProductionRatio > PRODUCTION_DISADVANTAGE_RATIO) { // cover more/same production
        mode = PlayMode.NORMAL;
      } else { // cover less production
        mode = PlayMode.DESPARATE;
      }
    }

    // System.out.println("myUnits: " + myTotalUnits + " enemyUnits: " + enemyTotalUnits);
    // System.out.println("unitRatio: " + currentUnitRatio + " prdnRatio: " +
    // currentProductionRatio);
    // System.out.println(mode);

    // aggregate information about planets
    for (int i = 0; i < allPlanetInfo.size(); i++) {
      PlanetUtility temp = allPlanetInfo.get(i);
      temp.units = temp.planet.getNumUnits();
      temp.eventualOwner = PlayerUtils.getCurrentEventualOwner(temp.planet, fleets, this);
      temp.minBaseConquerCost = PlayerUtils.getUnitsToCapture(temp.planet, fleets, this);
      temp.extraUnits =
          temp.units - PlayerUtils.getOpponentsIncomingFleetCount(temp.planet, fleets, this);
      temp.defensiveValue = getDefensiveValue(temp.planet, temp.baseStrategicValue);
      temp.offensiveValue = getOffensiveValue(temp.planet, temp.baseStrategicValue);

      // System.out.println("num: "+i+" own: "+temp.planet.getOwner()+" units: "+temp.units+"
      // evenOwn: "+temp.eventualOwner+" conCost: "+temp.minBaseConquerCost);
    }

    // defense loop
    for (PlanetUtility p : allPlanetInfo) {
      if (p.planet.ownedBy(this) && p.eventualOwner != PlanetOwner.PLAYER) {
        for (PlanetUtility other : allPlanetInfo) {
          if (other.planet.ownedBy(this)
              && other != p
              && other.minBaseConquerCost
                  < 0) { // planet is under no threat itself and not the same one
            // send as many units as required or as many as can be spared if not enough
            int willSend =
                other.extraUnits > p.minBaseConquerCost ? p.minBaseConquerCost : other.extraUnits;
            other.units -= willSend;
            other.extraUnits -= willSend;
            p.minBaseConquerCost -= willSend;
            addAction(other.planet, p.planet, willSend);
          }
        }
      }
    }

    for (PlanetUtility p : allPlanetInfo) {
      if (p.minBaseConquerCost < 0 && p.units > 0) {
        mySpareUnits +=
            p.units - PlayerUtils.getOpponentsIncomingFleetCount(p.planet, fleets, this);
      }
    }

    ArrayList<PlanetUtility> targets;
    currentUnitRatio = currentUnitRatio > 1 ? 1 : currentUnitRatio;

    switch (mode) {
      case CONFIDENT:
        mySpareUnits *= AGGRESSIVE_SPARE_UNIT_RATIO;
        // mySpareUnits = (int) Math.max(mySpareUnits * AGGRESSIVE_SPARE_UNIT_RATIO, mySpareUnits *
        // currentUnitRatio); //AGGRESSIVE_SPARE_UNIT_RATIO;
        targets = sortByAggressiveValue(allPlanetInfo, averageLocation, variance);
        break;
      case AGGRESSIVE:
        mySpareUnits *= AGGRESSIVE_SPARE_UNIT_RATIO;
        // mySpareUnits = (int) Math.max(mySpareUnits * AGGRESSIVE_SPARE_UNIT_RATIO, mySpareUnits *
        // currentUnitRatio);
        targets = sortByOverallValue(allPlanetInfo, averageLocation, variance);
        break;
      case DEFENSIVE:
        mySpareUnits *= DEFENSIVE_SPARE_UNIT_RATIO;
        // mySpareUnits = (int) Math.max(mySpareUnits * DEFENSIVE_SPARE_UNIT_RATIO, mySpareUnits *
        // currentUnitRatio);
        targets = sortByDefensiveValue(allPlanetInfo, averageLocation, variance);
        break;
      case DESPARATE:
        mySpareUnits *= AGGRESSIVE_SPARE_UNIT_RATIO;
        // mySpareUnits = (int) Math.min(mySpareUnits * AGGRESSIVE_SPARE_UNIT_RATIO, mySpareUnits *
        // currentUnitRatio);
        targets = sortByOverallValue(allPlanetInfo, averageLocation, variance);
        break;
      case NORMAL:
        mySpareUnits *= NORMAL_SPARE_UNIT_RATIO;
        // mySpareUnits = (int) Math.min(mySpareUnits * NORMAL_SPARE_UNIT_RATIO, mySpareUnits *
        // currentUnitRatio);
        targets = sortByOverallValue(allPlanetInfo, averageLocation, variance);
        break;
      default:
        System.out.println("Error - in default of switch");
        return;
    }

    // System.out.println("spareUnits: " + mySpareUnits);

    for (int i = 0; i < allPlanetInfo.size() && targets.size() > 0; i++) {
      PlanetUtility current = allPlanetInfo.get(i);

      if (targets.get(0).planet.ownedBy(this)) {
        targets.remove(0);
        i--;
        continue;
      }

      if (current.planet.ownedBy(this)) {
        PlanetUtility temp = targets.get(0);
        // System.out.println("target: " + temp.planet.getOwner() + " u: " +
        // temp.planet.getNumUnits());
        int extraUnitsNeeded = 3;
        if (temp.planet.ownedByOpponentOf(this)) {
          extraUnitsNeeded +=
              (int) temp.planet.distanceTo(current.planet)
                  / (FLEET_SPEED * temp.planet.PRODUCTION_TIME);
        }
        if (mySpareUnits > temp.minBaseConquerCost) {
          if (current.minBaseConquerCost < 0 && current.units > 0) {
            int willSend =
                current.extraUnits > temp.minBaseConquerCost + extraUnitsNeeded
                    ? temp.minBaseConquerCost + extraUnitsNeeded
                    : current.extraUnits;
            current.units -= willSend;
            current.extraUnits -= willSend;
            temp.minBaseConquerCost -= willSend;
            if (willSend == temp.minBaseConquerCost) {
              targets.remove(0);
            }
            addAction(current.planet, temp.planet, willSend);
          }
        } else {
          targets.remove(0);
          i--;
        }
      }
    }
  }