Page History

/**
* Represents a set of die values. A die has six possible values 1-6,
* but the number of dice may vary from Dice instance to Dice instance.
* In addition, a Dice-instance can have a score.
*/
public class Dice implements Iterable<Integer> {

   /**
   * @param dieCount
   * @return a collection of random integer values in the range 1-6
   */
   public static Collection<Integer> randomDieValues(int dieCount) {
      ...
   }

   ... fields (part 1) ...

   /** (part 1)
   * Initializes this Dice with the values in dieValues, and a score.
   * @param dieValues
   * @param score the score to set, may be -1 for yet unknown
   * @throws a suitable exception if the die values are outside the valid range
   */
   public Dice(Collection<Integer> dieValues, int score) {
      ...
   }

   /** (part 1)
   * Initializes this Dice with dieCount random values (using Math.random())
   * @param dieCount
   */
   public Dice(int dieCount) {
      ...
   }

   /** (part 1)
   * Initializes this Dice with the values in dice, and a score
   * @param dieValues // Denne skulle vært bare "dice", ikke "dieValues"
   * @param score the score to set, may be -1 for yet unknown
   */
   public Dice(Dice dice, int score) {
      ...
   }

   /** (part 2)
   * Format: [die1, die2, ...] = score (score is omitted when < 0)
   */
   ... method for generating a String representation of a Dice instance ...

   /** (part 2)
   * Parses a string using the toString format (see above) and
   * returns a corresponding Dice.
   * @param s
   * @return a new Dice instance initialized with die values and score from the String argument
   */
   public static Dice valueOf(String s) {
      ...
   }

   /** (part 3)
   * @return the number of die values
   */
   public int getDieCount() {
      ...
   }

   /** (part 3)
   * @param dieNum
   * @return the value of die number dieNum
   */
   public int getDieValue(int dieNum) {
      ...
   }

   /** (part 3)
   * @param value
   * @return the number of dice with the provided value
   */
   public int getValueCount(int value) {
      ...
   }

   /** (part 4)
   * @return the current score
   */
   public int getScore() {
      ...
   }

   /** (part 4)
   * Sets the score, but only if it isn't already set to a non-negative value
   * @param score
   * @throws a suitable exception if score already is set to a non-negative value
   */
   public void setScore(int score) {
      ...
   }

   ... Iterable methods (part 5) ...

   /** (part 6) // Denne ble det ikke spurt om, og det var ikke meningen at den skulle implementeres, men den kunne brukes
   * @param dice
   * @return true if all die values in the argument appear in this Dice
   */
   public boolean contains(Dice dice) {
      ...
   }

   /** (part 6)
   * @param dices a Collection of Dice // Denne linja var feil, det skulle være bare "dice a Dice"
   * @return a new Dice instance with the all the die values this Dice and
   * all Dice in the argument, without any specific order
   */
   public Dice add(Dice dice) {
      ...
   }

   /** (part 6)
   * @param dice
   * @return a new Dice instance with the die values from this Dice, but
   * without those from the argument, without any specific order
   */
   public Dice remove(Dice dice) {
      ...
   }
}

/** (part 7)
* Interface for scoring rules, i.e.
* logic for computing a score for a subset of dice in a Dice
*/
public interface DiceScorer {
   /**
   * Computes a score for (a subset of) the dice in the Dice argument.
   * The return value includes those dice that gives the score, and
   * of course the score itself.
   * @param dice
   * @return The dice for which the rule computes a score, and the score itself, or
   * null, if this rule isn't applicable
   */
   Dice getScore(Dice dice);
}

public static Collection<Integer> randomDieValues(int dieCount) {
   Collection<Integer> dieValues = new ArrayList<>(dieCount);
   while (dieValues.size() < dieCount) {
      dieValues.add((int) (Math.random() * 6 + 1));
   }
   return dieValues;
   // Evt. med Stream-teknikken:
   // return new Random().ints(dieCount, 1,6).boxed().collect(Collectors.toList())
}
 
private final List<Integer> dieValues = new ArrayList<>(); // Kunne også brukt int[]-typen og lage den i konstruktøren
private int score = -1;

public Dice(Collection<Integer> dieValues, int score) {
   // Kunne brukt this.dieValues.addAll(dieValues), en da får en ikke validert enkeltverdiene
   for (int dieValue : dieValues) {
      if (! (dieValue >= 1 && dieValue <= 6)) {
         throw new IllegalArgumentException("A die value must be in the range 1-6");
      }
      this.dieValues.add(dieValue);
   }
   this.score = score;
}

public Dice(int dieCount) {
   this(Dice.randomDieValues(dieCount), -1);
}

public Dice(Dice dice, int score) {
   this(dice.dieValues, score);
}

@Override
public String toString() {
   String result = "[";
   for (int dieValue : dieValues) {
      if (result.length() > 1) {
         result = result + ", ";
      }
      result = result + dieValue;
   }
   result = result + "]";
   // Det over er samme som: result = dieValues.toString()
   if (getScore() >= 0) {
      result = result + " = " + getScore();
   }
   return result;
}
 
public static Dice valueOf(String s) {
   int score = -1;
   int scorePos = s.indexOf("=");
   if (scorePos >= 0) {
      score = Integer.valueOf(s.substring(scorePos + 1).trim());
      s = s.substring(0, scorePos).trim();
   }
   if (s.startsWith("[") && s.endsWith("]")) {
      s = s.substring(1, s.length() - 1);
   } else {
      throw new IllegalArgumentException("Illegal format");
   }
   String[] dieValueStrings = s.split(",");
   Collection<Integer> dieValues = new ArrayList<>();
   for (int i = 0; i < dieValueStrings.length; i++) {i < dieValueStrings.length; i++) {
      dieValues.add(Integer.valueOf(dieValueStrings[i].trim()));
   }
   return new  dieValues.add(Integer.valueOf(dieValueStrings[i].trim()));
   }
   return new Dice(dieValues, score);
}Dice(dieValues, score);
}

public int getDieCount() {
   return this.dieValues.size();
}


public int getDieValue(int dieNum) {
   return this.dieValues.get(dieNum);
}

public int getValueCount(int value) {
   int count = 0;
   for (int dieValue : this.dieValues) {
      if (dieValue == value) {
         count++;
      }
   }
   return count;
   // Alternativ med streams: return (int) this.dieValues.stream().filter(dieValue -> value == dieValue).count();
 }

public int getScore() {
   return score;
}

public void setScore(final int score) {
   if (this.score >= 0) {
      throw new IllegalStateException("Cannot set score more than once");
   }
   this.score = score;
}

@Override
public Iterator<Integer> iterator() {
   return this.dieValues.iterator();
}
 

Dice dice = ...
for (int dieValue : dice) {
   ... her er dieValue neste verdi i dice sin dieValues-liste
}

public Dice add(Dice dice) {
   Collection<Integer> dieValues = new ArrayList<>(this.dieValues);
   for (int dieValue : dice.dieValues) {
      dieValues.add(dieValue);
   }
   // evt. dieValue.addAll(dice.dieValues) i stedet for løkka
   return new Dice(dieValues, -1);
}

public Dice remove(final Dice dice) {
   List<Integer> dieValues = new ArrayList<>(this.dieValues);
   for (int dieValue : dice.dieValues) {
      dieValues.remove(dieValue);
      // evt.
      // int pos = dieValues.indexOf(dieValue);
      // if (pos >= 0) {
      //    dieValues.remove(pos);
      // }
   }
   return new Dice(dieValues, -1);
}