コード例 #1
0
  /**
   * Takes a table of nodes and adds a weighted score to each node score in the table. Nodes
   * touching hexes with better numbers get better scores. Also numbers that the player isn't
   * touching yet are better than ones that the player is already touching.
   *
   * @param nodes the table of nodes with scores: Hashtable<Integer,Integer> . Contents will
   *     be modified by the scoring.
   * @param player the player that we are doing the rating for, or <tt>null</tt>; will give a bonus
   *     to numbers the player isn't already touching
   * @param weight a number that is multiplied by the score
   */
  protected void bestSpotForNumbers(
      Hashtable<Integer, Integer> nodes, SOCPlayer player, int weight) {
    final int[] numRating = SOCNumberProbabilities.INT_VALUES;
    final SOCPlayerNumbers playerNumbers = (player != null) ? player.getNumbers() : null;
    final SOCBoard board = game.getBoard();

    // 80 is highest practical score (40 if player == null)
    final int maxScore = (player != null) ? 80 : 40;

    int oldScore;
    Enumeration<Integer> nodesEnum = nodes.keys();

    while (nodesEnum.hasMoreElements()) {
      final Integer node = nodesEnum.nextElement();

      // log.debug("BSN - looking at node "+Integer.toHexString(node.intValue()));
      oldScore = nodes.get(node).intValue();

      int score = 0;
      Enumeration<Integer> hexesEnum = board.getAdjacentHexesToNode(node.intValue()).elements();

      while (hexesEnum.hasMoreElements()) {
        final int hex = hexesEnum.nextElement().intValue();
        final int number = board.getNumberOnHexFromCoord(hex);
        score += numRating[number];

        if ((number != 0) && (playerNumbers != null) && !playerNumbers.hasNumber(number)) {
          /** add a bonus for numbers that the player doesn't already have */

          // log.debug("ADDING BONUS FOR NOT HAVING "+number);
          score += numRating[number];
        }

        // log.debug(" -- -- Adding "+numRating[board.getNumberOnHexFromCoord(hex)]);
      }

      /*
       * normalize score and multiply by weight
       * 80 is highest practical score (40 if player == null)
       * lowest score is 0
       */
      final int nScore = ((score * 100) / maxScore) * weight;
      final Integer finalScore = new Integer(nScore + oldScore);
      nodes.put(node, finalScore);

      // log.debug("BSN -- put node "+Integer.toHexString(node.intValue())+" with old score
      // "+oldScore+" + new score "+nScore);
    }
  }
コード例 #2
0
  /**
   * Estimate the rolls for this player to obtain each resource. Will construct a
   * <tt>SOCBuildingSpeedEstimate</tt> from {@link SOCPlayer#getNumbers() pl.getNumbers()}, and call
   * {@link #getRollsPerResource()}.
   *
   * @param pl Player to check numbers
   * @return Resource order, sorted by rolls per resource descending; a 5-element array containing
   *     {@link SOCResourceConstants#CLAY}, {@link SOCResourceConstants#WHEAT}, etc, where the
   *     resource in [0] has the highest rolls per resource.
   * @since 2.0.00
   */
  public static final int[] getRollsForResourcesSorted(final SOCPlayer pl) {
    SOCBuildingSpeedEstimate estimate = new SOCBuildingSpeedEstimate(pl.getNumbers());
    final int[] rollsPerResource = estimate.getRollsPerResource();
    int[] resourceOrder = {
      SOCResourceConstants.CLAY, SOCResourceConstants.ORE,
      SOCResourceConstants.SHEEP, SOCResourceConstants.WHEAT,
      SOCResourceConstants.WOOD
    };

    // Sort descending; resourceOrder[0] will have the highest rollsPerResource.
    for (int j = 4; j >= 0; j--) {
      for (int i = 0; i < j; i++) {
        if (rollsPerResource[resourceOrder[i]] < rollsPerResource[resourceOrder[i + 1]]) {
          int tmp = resourceOrder[i];
          resourceOrder[i] = resourceOrder[i + 1];
          resourceOrder[i + 1] = tmp;
        }
      }
    }

    return resourceOrder;
  }