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++) {
      dieValues.add(Integer.valueOf(dieValueStrings[i].trim()));
   }
   return new 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(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) {
      int pos = dieValues.removeindexOf(dieValue);
      // evt.
 if (pos >= 0) {
     // int pos = dieValues.indexOfremove(dieValuepos);
      // if (pos >= 0) {}
      // kan ikke bruke dieValues.remove(pos);
      // }dieValue) fordi da blir dieValue brukt som om den er en indeks
   }
   return new Dice(dieValues, -1);
}

/**
 * Represents a round of Farkle, where a player throws and keeps dice,
 * until s/he either "bank", i.e. save your points, or
 * farkle, i.e. get no points in a throw and hence looses all gathered points.
 * During and after a finished round, kept sets of dice and their scores are available.
 * During a round, the remaining dice are also available.
 */
public class FarkleRound {
    private int dieCount;
    private Collection<Dice> kept = new ArrayList<>();
    private Dice currentDice;
 
    /**
     * Initializes a new round, where dieCount number of dice is immediately rolled.
     * Note that the round may be immedielately finished, if the initial roll give no points.
     * @param dieCount the number of dice rolled
     * @param scoring the object responsible for computing the score
     */
    public FarkleRound(int dieCount) {
        this.dieCount = dieCount;
        roll(dieCount);
    }
    private void roll(int dieCount) {
        this.currentDice = new Dice(Dice.randomDieValues(dieCount), -1);
        if (computeDiceScores(currentDice).isEmpty()) {
            this.kept.clear();
            this.currentDice = null;
        }
    }
    private Collection<Dice> computeDiceScores(Dice dice) {
       ... implemented earlier in this exam ...
    }
 
    /**
     * @return true of the round is finised, false otherwise
     */
    public boolean isFinished() {
        return this.currentDice == null;
    }

    /**
     * Called when the player decides to stop and secure points.
     * Finishes the round, by keeping all scoring Dice, as computed by the scoring object.
     */
    public void bank() {
        if (isFinished()) {
            throw new ... which exception class ? ...
        }
        this.kept.addAll(computeDiceScores(currentDice));
        ... put this object in a state that indicates this round is finished ...
    }
 
    /**
     * Called when the player decides to keep specific dice and roll the rest.
     * All the dice kept must be scoring ones, but not all scoring dice need to be kept.
     * @param dice the dice to keep, the rest of the current dice should be thrown.
     */
    public void keepAndRoll(final Dice dice) {
        if (isFinished()) {
            throw new ... which exception class ? ...
        }
        if (! currentDice.contains(dice)) {
            throw new ... which exception class ? ...
        }
        final Collection<Dice> scores = computeDiceScores(dice);
        if (scores.stream().mapToInt(Dice::getDieCount).sum() != dice.getDieCount()) {
            throw new SomeKindOfException("You can only set aside dice that contribute to the score");
        }
        kept.addAll(scores);
        currentDice = currentDice.remove(dice);
        // roll remaining dice or all, if there are none left
        ... what code needs to be here ? ...
    }
}

int dieCount2 = currentDice.getDieCount();
if (dieCount2 == 0) {
   dieCount2 = this.dieCount;
}
roll(dieCount2);

// Evt. bareint dieCount2 = currentDice.getDieCount();
roll(dieCount2 == 0 ? this.dieCount : dieCount2);