Eksamen 2018

/**
* 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.indexOf(dieValue);
      if (pos >= 0) {
         dieValues.remove(pos);
      }
      // kan ikke bruke remove(dieValue) fordi da blir dieValue brukt som om den er en indeks
   }
   return new Dice(dieValues, -1);
}

/**
* 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 class ThreeOrMoreOfAKind implements DiceScorer {


   // hjelpemetode som beregner poengsum for count antall av value
   private int getScore(final int value, int count) {
      int score = value * 100;
      while (count > 3) {
         score = score * 2;
         count--;
      }
      return score;
      // Samme som: return value * 100 * (int) Math.pow(count - 3, 2);
   }

   // går gjennom hver mulige verdi 1-6 og finner den med nok like som gir flest poeng
   protected int getBestValue(final Dice dice) {
      int value = 0, max = 0;
      for (int i = 1; i <= 6; i++) {
         int count = dice.getValueCount(i);
         int score = getScore(i, count);
         if (count >= 3 && score > max) {
            value = i;
            max = score;
         }
      }
      return value;
   }

   @Override
   // finner den beste og lager et nytt Dice-objekt med riktig antall terningverdier og poengsum
   public Dice getScore(final Dice dice) {
      int best = getBestValue(dice);
      if (best == 0) {
         return null;
      }
      int count = dice.getValueCount(best);
      Collection<Integer> dieValues = new ArrayList<Integer>(count);
      for (int i = 0; i < count; i++) {
         dieValues.add(best);
      }
      return new Dice(dieValues, getScore(best, count));
   }
}

private Collection<DiceScorer> diceScorers;

public Collection<Dice> computeDiceScores(Dice dice) {
   Collection<Dice> result = new ArrayList<>();
   // Vi følger algoritmen gitt over:
   // Så lenge det er terninger igjen, så
   //   finner vi regelen som gir flest poeng og sparer på de terningene den "brukte" og
   //   fjerner dem fra gjenværende terninger
   while (dice.getDieCount() > 0) {
      Dice best = null;
      for (DiceScorer diceScorer : diceScorers) {
         Dice score = diceScorer.getScore(dice);
         if (score != null && (best == null || score.getScore() > best.getScore())) {
            best = score;
         }
      }
      if (best == null) {
         break;
      } else {
         result.add(best);
         dice = dice.remove(best);
      }
   }
   return result;
}

// Med reduce
diceCol.stream().map(Dice::getScore).reduce(0, (n1, n2) -> n1 + n2)
 
// Med sum (må bruke mapToInt i stedet for map for å få en IntStream, men det er vi ikke så nøye på ved sensur)
diceCol.stream().mapToInt(Dice::getScore).sum()
 
// Dice::getScore er her det samme som dice -> dice.getScore()

public abstract class AbstractDice implements Dice {

   private int score = -1;
 
   protected AbstractDiceImpl(int score) {
     this.score = score;
   }
 
   @Override
   public String toString() {
      ... kan implementeres fordi getDieCount og getDieValue er deklarert (selv om de er abstrakte) ...
   }
 
   // implementasjon som bare er avhengig av at Dice utvider Iterable
   public int getValueCount(int value) {
      int count = 0;
      // Iterable er implementert!
      for (int dieValue : this) {
         if (dieValue == value) {
            count++;
         }
      }
      return count;
   }
 
   @Override
   public int getScore() {
      return score;
   }
 
   @Override
   public void setScore(int score) {
      if (this.score >= 0) {
         throw new IllegalStateException("Cannot set score more than once");
      }
      this.score = score;
    }
}

public class DiceAdder implements Dice {
 
   private final Dice dice1, dice2;
 
   public DiceAdder(Dice dice1, final Dice dice2) {
      super(score);
      this.dice1 = dice1;
      this.dice2 = dice2;
   }
 
   @Override
   public int getDieCount() {
      // Rett frem bruk av delegering, som vist i oppgaveteksten
      return dice1.getDieCount() + dice2.getDieCount();
   }
 
   @Override
   public int getDieValue(final int dieNum) {
      int dieCount1 = dice1.getDieCount();
      // Vi henter de første verdiene fra dice1,
      // så sjekker om indeksen er lav nok
      if (dieNum < dieCount1) {
         return dice1.getDieValue(dieNum);
      }
      // De neste verdiene hentes fra dice2, med (ned)justert indeks 
      return dice2.getDieValue(dieNum - dieCount1);
   }
 
   @Override
   public int getValueCount(final int value) {
      // Rett frem bruk av delegering, som vist i oppgaveteksten
      return dice1.getValueCount(value) + dice2.getValueCount(value);
   }
 
   @Override
   public Dice add(final Dice dice) {
      // Vi lager en instans av denne klassen,
      // den representerer jo nettopp to Dice slått sammen
      return new DiceAdder(this, dice);
   }
 
   @Override
   public boolean contains(final Dice dice) {
      // Dette er ikke så rett frem, men
      // algoritmen bruker delegering til getValueCount
      for (int dieValue = 1; dieValue <= 6; dieValue++) {
         if (dice.getValueCount(dieValue) > getValueCount(dieValue)) {
            return false;
         }
      }
      return true;
   }
 
   @Override
   public Dice remove(final Dice dice) {
      // Denne er ikke rett frem i det hele tatt, så den utelater vi...
   }
}

/**
 * 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);

public Dice(int dieCount, Supplier<Integer> supplier) { 
   this.dieValues = new ArrayList<>(dieCount);
   while (this.dieValues.size() < dieCount) { // evt. for (int i = 0; i < dieCount; i++) {
      this.dieValues.add(supplier.get());
   }
}
 

@Test
public void testValueOf() {
   Dice dice1 = Dice.valueOf("[1, 1, 2]");
   assertDieValues(dice1, 1, 1, 2);
   Assert.assertEquals(-1, dice1.getScore());

   Dice dice2 = Dice.valueOf("[1, 1, 2] = 200");
   assertDieValues(dice2, 1, 1, 2);
   Assert.assertEquals(200, dice2.getScore());

   try {
      Dice.valueOf("1, 5, 2 = 200");
      Assert.fail();
   } catch (final Exception e) {
      Assert.assertTrue(e instanceof IllegalArgumentException);
   }
   try {
      Dice.valueOf("1, x, 2 = 200");
      Assert.fail();
   } catch (final Exception e) {
      Assert.assertTrue(e instanceof IllegalArgumentException);
   }
   try {
      Dice.valueOf("1, 5, 2 = x");
      Assert.fail();
   } catch (final Exception e) {
      Assert.assertTrue(e instanceof IllegalArgumentException);
   }
}

public class DiceController {
 
   @FXML
   private TextField dieCountInput;
 
   @FXML
   private Label diceOutput;
 
   @FXML
   public void handleThrowDice() {
      Dice dice = new Dice(Integer.valueOf(dieCountInput.getText()));
      computeFarkleScore(dice); // var jo oppgitt
      diceOutput.setText(dice.toString());
   }
}