Page History

/**
* Represents the score given to a set of die values
*/
public class DiceScore {
 
    ??? fields
 
    /**
    * Initialises a DiceScore object with the provided data
    * @param scoringDice the Dice object containing
    * only the die values contibuting to the score
    * @param score the score itself
    */
    public DiceScore(Dice scoringDice, int score) {
        ???
    }
 
    ??? methods
}

/**
* 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 returned DiceScore object stores a Dice object
    * with those die values that contributed to the score and
    * of course the score itself.
    * @param dice
    * @return The result of applying the rule to the provided Dice, or
    * null of the rule doesn't apply.
    */
    DiceScore getScore(Dice dice);
}

Oppgave a) - DiceScore-klassen (6 poeng)

Skriv ferdig DiceScore-klassen, med egnede felt, konstruktørkode og tilgangsmetoder, med utgangspunkt at DiceScore-objekter ikke skal kunne endres etter at de er opprettet.

public class DiceScore {

	private final Dice dice;
	private final int score;

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

	public Dice getDice() {
		return dice;
	}

	public int getScore() {
		return score;
	}
}

Oppgave b) - SingleValue-klassen (6 poeng)

Skriv kode for klassen SingleValue(enkeltverdi), som implementerer DiceScorermed følgende logikk:

For et Dice-argument som ikke inneholder den spesifikke verdien returneres null. Ellers returneres et (nytt) DiceScore-objekt med riktige verdier satt. 

Merk at klassen bare gir poeng for én av den angitte verdien, selv om Dice-objektet inneholder flere av denne verdien.

Eksempel:

Et SingleValue-objekt opprettet med new SingleValue(5, 50), vil gi 50 poeng for et Diceobjekt med én eller flere femmere. DiceScore-objektet som returneres skal inneholde et Dice-objekt med bare én femmer og (poeng)tallet 50.

/**
* Implementation of DiceScorer that gives a specific score til a specific die value.
* In Farkle it is used for giving 50 to fives and 100 to ones.
*/
public class SingleValue implements DiceScorer {
 
    ???
 
    /**
    * Initializes this SingleValue object with the (die) value and the corresponding score.
    * In Farkle you will typically create two of these, with
    * new SingleValue(5, 50) and new SingleValue(1, 100)
    * @param value
    * @param score
    */
    public SingleValue(int value, int score) {
        ???
    }
 
    /**
    * Looks for at least one of the specific value and
    * if found, returns a DiceScore object with a Dice object
    * with the value contributing to the score and
    * the corresponding score.
    */
    @Override
    public DiceScore getScore(Dice dice) {
        ???
    }
}

public class SingleValue implements DiceScorer {


	private final int score;
	private final int value;

	public SingleValue(final int value, final int score) {
		this.score = score;
		this.value = value;
	}

	@Override
	public DiceScore getScore(final Dice dice) {
		if (dice.getValueCount(value) > 0) {
			return new DiceScore(new Dice(Arrays.asList(value)), score);
		}
		return null;
	}
}

Oppgave c) - Straight-klassen (8 poeng)

Skriv kode for klassen Straight(alle terningene utgjør en serie), som implementerer DiceScorermed følgende logikk:

For et Dice-argument uten straightreturneres null. Ellers returneres et (nytt) DiceScore-objekt med riktige verdier satt. Poengene som gis er en spesifikk verdi (konstant) som settes når Straight-objektet opprettes.

Merk at koden skal virke selv om det er (mange) færre eller flere terninger enn mulige terningverdier (1-6). Et Dice-objekt med bare én terningverdi vil f.eks. alltid gi straight, mens et Dice-objekt med flere enn 6 terningverdier aldri kan gi straight.

/**
* Implementation of DiceScorer that gives a specific score til a so-called straight,
* which is when all values give a series of consecutive values, e.g. 1, 2, 3.
* All the die values must be used, so with six dice, the only possibility is 1, 2, 3, 4, 5, 6.
* With five dice, there are two possibilities, 1, 2, 3, 4, 5 and 2, 3, 4, 5, 6.
*/
public class Straight implements DiceScorer {
 
    ???
 
    /**
    * Initializes this Straight object with the specific score.
    * @param score
    */
    public Straight(int score

Det finnes flere måter å implementere Dice-klassen og alle dens metoder, med ulike fordeler og ulemper. En måte å tillate bruk av flere implementasjoner er å gjøre om Dice til et grensesnitt og så ha en eller flere implementasjonsklasser, hvor den eksisterende Dice-klassen blir en av disse:

public interface Dice {

   ...

}

public class DiceImpl1 implements Dice { ... tilsvarer løsningen i deloppgavene 1-6 ... }

public class DiceImpl2 implements Dice { ... alternativ løsning ... }

Navnene på implementasjonsklassene kan selvsagt være mer forklarende.

Oppgave a) - Dice-grensesnittet (4 poeng)

Dette var en flervalgsoppgave med to spørsmål og valg av ett av flere alternativer.

Spørsmål 1: Tre alternative grensesnitt er foreslått, basert på den nåværende Dice-klassen:

// Alternativ 1, alle metoder og konstruktører:
public interface Dice ... {
    static Collection<Integer> randomDieValues(int dieCount);
    Dice(Collection<Integer> dieValues, int score);
    Dice(int dieCount);
    Dice(Dice dice, int score);
    static Dice valueOf(String s);
    int getScore();
    void setScore(int score);
    int getDieCount();
    int getDieValue(int dieNum);
    int getValueCount(int value);
    boolean contains(Dice dice);
    Dice add(Dice dice);
    Dice remove(Dice dice);
}
 
// Alternativ 2, alle metoder:
public interface Dice ... {
    static Collection<Integer> randomDieValues(int dieCount);
    static Dice valueOf(String s);
    int getScore();
    void setScore(int score);
    int getDieCount();
    int getDieValue(int dieNum);
    int getValueCount(int value);
    boolean contains(Dice dice);
    Dice add(Dice dice);
    Dice remove(Dice dice);
}
 
// Alternativ 3, utvalgte metoder:
public interface Dice ... {
    int getScore();
    void setScore(int score);
    int getDieCount();
    int getDieValue(int dieNum);
    int getValueCount(int value);
    boolean contains(Dice dice);
    Dice add(Dice dice);
    Dice remove(Dice dice);
}

Spørsmål 2: Den opprinnelige Dice-klassen implementerer Iterable<Integer>. Spørsmålet er hvordan dette skal håndteres ved overgangen til et Dice-grensesnitt.

1. Dice-grensesnittet må utvide (extends) Iterable<Integer>.
2. Dice-grensesnittet må både utvide (extends) Iterable<Integer> og liste opp metoden(e) fra Iterable.
3. Dice-grensesnittet må liste opp metoden(e) fra Iterable.
4. Dice-grensesnittet må utvide (extends) Iterable<Integer> og kan liste opp metoden(e) fra Iterable.

Oppgave b) - Arv (6 poeng)

Hvis en har flere implementasjoner av det nye Dice-grensesnittet, så kan en regne med at visse deler av disse vil bli nokså eller helt like.

Ett aspekt som typisk vil bli (nokså) likt er håndtering av poengene (score). Forklar med tekst og/eller kode hvordan du vil håndtere det vha. arvingsmekanismen, slik at løsningen tillater stor grad av gjenbruk av kode i subklasser og blir ren og ryddig.  

) {
        ???
 

}
 

/**
    * Checks that all die values 

in the provided Dice form a series of consecutive 

values.
    * 

If this is the case returns a DiceScore object with a Dice with
   

* the die 

values contributing to 

the 

score 

(necessarily all of them) 

and
    * the 

corresponding score

.
   

 */
 

   @Override
    public 

DiceScore 

getScore(

Dice 

dice) {
      

 ???
    

}

Vanlige feil/svakheter:

• Generell beskrivelse av arv og fraser om at arv gir gjenbruk, uten å være spesifikk på hva slags variabler og metoder som er aktuelle å ha i en superklasse i dette tilfellet.
• Forklare hvordan en kan ha en generell superklasse for poengberegning, med subklasser for spesifikk spill som Yatzy og Farkle. Her var det spesifikt snakk om Dice, og poengberegning er ikke en del av Dice-grensesnittet eller naturlig å ha med i en Dice-klasse.
• Ikke nevne muligheten til å implementere flere metoder, f.eks. toString, som bruker deklarerte abstrakte metoder.

Oppgave c) - Delegering (10 poeng)

Dice sin add-metode skal lage en ny Dice-instans (altså instans av en klasse som implementerer Dice) som kombinerer terningverdier fra to andre Dice-instanser (this og argumentet). En kan tenke seg at metoden returnerer en instans av en ny Dice-implementasjon kalt DiceAdder, som bruker delegering. Den vil ha to Dice-felt og en konstruktør som tar inn to Dice-instanser:

DiceAdder(Dice dice1, Dice dice2) { ... feltene settes her ... }

Hver Dice-metode kan da bruke/delegere til disse to Dice-instansene i sin løsning, f.eks. vil getDieCount() returnere summen av getDieCount() for hver av de to Dice-instansene:

public int getDieCount() {

   return dice1.getDieCount() + dice2.getDieCount();

}

Forklar med tekst og/eller kode hvordan delegeringsteknikken vil bli brukt i følgende metoder i en slik DiceAdder-klasse:  getDieValue, getValueCount, contains, add og remove. Kommenter spesielt hvis delegeringsteknikken ikke passer for en spesifikk metode!

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...
   }
}

}

 public class Straight implements DiceScorer {

	private final int score;
	public Straight(int score) {
		this.score = score;
	}

	@Override
	public DiceScore getScore(final Dice dice) {
		int dieCount = dice.getDieCount();
		int start = 1;
		// find start of series
		while (start <= 6) {
			int count = dice.getValueCount(start);
			if (count > 1) {
				return null;
			} else if (count == 1) {
				break;
			}
			start = start + 1;
		}

		// find end of series
		int end = start + 1;
		while (end <= 6) {
			int count = dice.getValueCount(end);
			if (count > 1) {
				return null;
			} else if (count == 0) {
				break;
			}
			end = end + 1;
		}
        // check if the number of ones is wrong
		if (end - start != dieCount) {
			return null;
		}
		return new DiceScore(dice, score);
	}
}

Oppgave d) - Nothing-klassen (8 poeng)

Skriv kode for klassen Nothing, som implementerer DiceScorer med følgende logikk:

Et spesifikt antall poeng gis hvis ingen (andre) poengregler gir poeng. De andre reglene representeres av et sett DiceScore-objekter som gis inn når Nothing-objektet opprettes. Dette gjør at Nothing-klassen ikke trenger å duplisere logikk som er spesifikke for andre regler. Bestem selv typen til diceScorers-argumentet som gis inn.

Merk at denne regelen bare gjelder hvis Dice-argumentet til getScore-metoden inneholder minst et visst antall terninger, typisk like mange som brukes i spillet. Dette minsteantallet gis også inn ved opprettelse av Nothing-objektet.

/**
* Implementation of DiceScorer that gives a specific score
* when no other DiceScore object applies.
* Requires that a certain number of dice have been thrown.
*/
public class Nothing implements DiceScorer {
 
    ??? fields
 
    /**
    * Initializes this Nothing object with the minimum required number of dice,
     * the specific score given and the other DiceScorer objects.
    * @param numDice the min. number of dice required for this rule to apply
    * @param score the specific score to give
    * @param diceScorers the (other) rules to check
    */
    public Nothing(int numDice, int score, ??? diceScorers) {
        ???
   }

 
    /**
    * Checks that 

no 

(other) 

DiceScore 

object 

apply,

    * in case a specific score is given.
    */
    @Override
 

public 

DiceScore 

Oppgave a) - final (2 poeng)

Dette var en flervalgsoppgave med ett spørsmål og to korrekte alternativer og ett galt et.

Spørsmål: Hvilke, om noen, av feltene øverst i FarkleRound-klassen kan ha modifikatoren final? 

1. dieCount
2. kept
3. currentDice

Oppgave b) - Kode i bank (2 poeng)

Dette er en tekstinnfyllingsoppgave som vurderes automatisk.

Spørsmål: Nederst i bank-metoden er en kodelinje erstattet med "... put this object in a state that indicates this round is finished ...". Skriv inn den korrekte kodelinjen. Koden må være korrekt, komplett og konsis, uten kommentarer, siden den sjekkes automatisk.

Oppgave c) - Unntakstyper (3 poeng)

Dette er en flervalgsoppgave med tre spørsmål.

I keepAndRoll-metoden utløses unntak i tre tilfeller.

Spørsmål 1: Hvilken av disse unntakstypene passer i det første tilfellet?

1. Exception
2. RuntimeException
3. IllegalArgumentException
4. IllegalStateException

Spørsmål 2: Hvilken av disse unntakstypene passer i det andre tilfellet?

1. Exception
2. RuntimeException
3. IllegalArgumentException
4. IllegalStateException

Spørsmål 3: I det tredje tilfellet bruker vi unntakstypen SomeKindOfException, som er tenkt som en egendefinert unntakstype. Hvilken unntakstype bør brukes som superklassen til SomeKindOfException?

1. Exception
2. RuntimeException
3. IllegalArgumentException
4. IllegalStateException

Oppgave d) - Kode i keepAndRoll (2 poeng)

Nederst i keepAndRoll-metoden er én eller flere kodelinjer erstattet med "... what code needs to be here ? ...". Skrive linjen(e) som mangler. Koden vil bli lest av sensor.

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

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

Oppgave e) - FarkleRound-objektdiagram (6 poeng)

Underveis i og etter en Farkle-runde vil tilstanden til runden være representert ved hjelp av flere objekter, inkludert et FarkleRound-objekt. Tegn objektdiagram for tilstanden etter runden som er beskrevet i det tredje eksemplet (fremhevet med fet skrift) for Farkle-reglene. 

Bruk blyantikonet til høyre på verktøylinja for tekstfeltet, for å aktivere tegneverktøyet. Det kan være lurt å kladde på forhånd, siden tegneverktøyet er litt begrenset...

object "~#fr: FarkleRound" as fr {
   dieCount = 5
}
object "~#dice1: Dice" as dice1 {
   dieValues = 5
   score = 50
}
object "~#dice2: Dice" as dice2 {
   dieValues = 1, 5
   score = 150
}
fr -> dice1 : kept
fr -> dice2 : kept

getScore(Dice dice) {
        ???
    }
}

public class Nothing implements DiceScorer {

	private final int score;
	private final int numDice;
	private final DiceScorer[] scorers;

	public NothingScorer(final int numDice, final int score, final DiceScorer... diceScorers) {
		this.score = score;
		this.numDice = numDice;
		this.scorers = diceScorers;
	}

	@Override
	public DiceScore getScore(final Dice dice) {
		if (dice.getDieCount() >= numDice) {
			for (DiceScorer diceScorer : scorers) {
				if (diceScorer.getScore(dice) != null) {
					return null;
				}
			}
		}
		return new DiceScore(dice, this.score);
	}
}

Oppgave e) - Mer om Nothing-klassen (4 poeng)

Hva kalles implementasjonsteknikken som det legges opp til at Nothingskal bruke? Begrunn svaret, f.eks. ved å forklare (kort) hva som er karakteristisk for denne teknikken.

Oppgave f) - DiceScorer-deklarasjon (4 poeng)

Når en lager en instans av et DiceScorer-objekt og lagrer (referansen til) det i en variabel, så kreves det at variablen er deklarert med en egnet type. Anta at en har følgende deklarasjon med initialisering:

??? aSingleValueObject = new SingleValue(1, 100);

Hvilke (tre) mulige typer er det lov å skrive der det står ???, hva er avgjørende for valget og hva vil man typisk bruke?

Oppgave g) - Arv med AbstractScorer (6 poeng)

De tre implementasjonene av DiceScorer(SingleValue, Straight og Nothing) har én ting felles. Forklar med tekst og/eller kode hvordan du vil utforme en felles superklasse (f.eks. kalt AbstractScorer) for disse tre, og hvordan de tre implementasjonene vil måtte endres for å fungere som subklasser.

public abstract class AbstractScorer implements DiceScorer {

	private final int score;

	protected AbstractScorer(int score) {
		this.score = score;
	}

	protected int getScore() {
		return score;
	}
}
 
public class SingleValue extends AbstractScorer {

	private final int value;

	public SingleValue(int value, int score) {
		super(score);
		this.value = value;
	}
}

Oppgave a) - Iterasjon (6 poeng)

Du ønsker å skrive ut (med System.out.print(...)) alle terningverdiene som et Dice-objekt representerer, men oppdager at den ikke har en egen toString()-metode som kan brukes. Skriv vanlig iterativ løkkekode som skriver ut alle terningverdiene til et Dice-objekt med mellomrom mellom (det gjør ikke noe om det kommer et ekstra mellomrom bakerst):

Dice dice = new Dice(...);

??? Hva skal stå her for å få skrevet ut alle terningverdiene i dice?

Skriv kode som har samme effekt, men som utnytter et funksjonelt grensesnitt (se ressurs med Java-API) og Java 8 sin lambda-syntaks:

dice. ??? Hva skal stå her for å få skrevet ut alle terningverdiene i dice?

Dice dice = new Dice(...);
for (int dieValue : dice) {
	System.out.println(dieValue + " ");
}

Dice dice = new Dice(...);
dice.forEach(dieValue -> { System.out.println(dieValue + " "); });

Oppgave b) - Testing av Dice-klassen (6 poeng)

Skriv en eller flere test-metoder for Dice sin contains-metode. Tenk spesielt på å teste grensetilfeller, som det kan tenkes ikke håndteres riktig! 

@Test
public void testContains() {
	assertFalse(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList(1, 2, 3))));
	assertTrue(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList(1, 2))));
	assertTrue(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList(1))));
	assertTrue(new Dice(Arrays.asList(1, 2)).contains(new Dice(Arrays.asList())));
 
	assertFalse(new Dice(Arrays.asList(1)).contains(new Dice(Arrays.asList(1, 2))));
	assertTrue(new Dice(Arrays.asList(1)).contains(new Dice(Arrays.asList(1))));
	assertTrue(new Dice(Arrays.asList(1)).contains(new Dice(Arrays.asList())));
	assertTrue(new Dice(Arrays.asList()).contains(new Dice(Arrays.asList())));

	assertFalse(new Dice(Arrays.asList()).contains(new Dice(Arrays.asList(1))));
}

Oppgave c) - Diagramtyper (4 poeng)

Hva er forskjellen (hensikt og innhold) mellom objektdiagrammer og objekttilstandsdiagrammer?

Oppgave d) - Observerbarhet (6 poeng)

Hva er hensikten med observert-observatør-teknikken? Hva vil det si at et objekt er observerbart?

Du blir bedt om å gjøre Dice-objekter observerbare. Forklar med tekst og evt. kode hva du vil gjøre for å møte dette kravet.

Du skal lage en liten JavaFX-app for å teste DiceScorer-implementasjonene dine, altså SingleValue-, Straight- og Nothing-klassene. Følgende oppførsel skal støttes:

• Brukeren skal kunne fylle inn et sett terningverdier i et tekstfelt (TextField). Mellomrom brukes som skilletegn.
• For hver DiceScorer-implementasjon er det en knapp og når den trykkes, kjøres getScore-metoden til en tilsvarende DiceScorer-instans, med de angitt terningverdiene som argument.
• Innholdet i DiceScorer-objektet som returneres, skal vises som tekst (Label). Hvis null returneres skal begge tekstene settes til en tom String.

Illustrasjonen for oppgaven viser resultatet etter at knappen tilsvarende Straight er trykket.

Image Added

Følgende FXML er skrevet for appen:

<VBoxxmlns:fx="http://javafx.com/fxml/1"
    fx:controller="kont2018.farkle.fx.DiceScorerController">
    <HBox>
        <Labeltext="Die values: "/>
        <!--  text field for inputing the die values -->
        <TextFieldfx:id="dieValuesInput"/>
    </HBox>
    <HBox>
        <ButtononAction="#testSingleValue" text="Test SingleValue"/>
        <ButtononAction="#testStraight" text="Test Straight"/>
        <ButtononAction="#testNothing" text="Test Nothing"/>
    </HBox>
    <HBox>
        <Labeltext="Points: "/>
        <!--  label for outputing the score -->
        <Labelfx:id="scoreOutput" text=""/>
    </HBox>
    <HBox>
        <Labeltext="For values: "/>
        <!--  label for outputing the scoring die values -->
        <Labelfx:id="diceOutput" text=""/>
    </HBox>
</VBox>

Skriv en JavaFX-kontroller som implementerer ønsket oppførsel, basert på kodeskjelettet nedenfor. Den skal passe til den oppgitte FXML-en og bruke klasser og metoder beskrevet tidligere i oppgavesettet. Du kan anta at Dice har en passende toString()-metode.

public class DiceScorerController {
 
    private DiceScorer singleValue, straight, nothing;
 
    @FXML
    public void initialize() {
        ??? initialize DiceScorer instances
    }
 
    @FXML private TextField dieValuesInput;
    @FXML private Label scoreOutput;
    @FXML private Label diceOutput;
 
    // helper method for parsing die values input
    private Dice getDiceInput() {
        Collection<Integer> dieValues = new ArrayList<>();
        for (String dieValue : dieValuesInput.getText().split(" ")) {
            ??? parse and add die value
        }
        ??? return new Dice instances
    }
 
    // helper method for 
    private void runDiceScorer(DiceScorer scorer) {
        ??? get DiceScore object by calling scorer's getScore method
        if (score != null) {
            ??? show output
        } else {
            ??? show output
        }
    }
 
    @FXML
    public void testSingleValue() {
        ??? use SingleValue implementation
    }
 
    @FXML
    public void testStraight() {
        ??? use Straight implementation
    }
 
    @FXML
    public void testNothing() {
        ??? use Nothing implementation
    }
}

Hvis det er detaljer du er usikker på, så forklar med tekstkommentarer i koden.

public class DiceScorerController {

	private DiceScorer singleValue, straight, nothing;

	@FXML
	public void initialize() {
		singleValue = new SingleValue(1, 100);
		straight = new Straight(500);
		nothing = new Nothing(5, 1000, singleValue, straight);
	}

	@FXML
	private TextField dieValuesInput;

	@FXML
	private Label scoreOutput;

	@FXML
	private Label diceOutput;

	private Dice getDiceInput() {
		Collection<Integer> dieValues = new ArrayList<>();
		for (String dieValue : dieValuesInput.getText().split(" ")) {
			dieValues.add(Integer.valueOf(dieValue));
		}
		return new Dice(dieValues);
	}

	private void runDiceScorer(final DiceScorer scorer) {
		DiceScore score = scorer.getScore(getDiceInput());
		if (score != null) {
			scoreOutput.setText(String.valueOf(score.getScore()));
			String dieValues = "";
			for (final int dieValue : score.getDice()) {
				dieValues += dieValue + " ";
			}
			diceOutput.setText(dieValues);
		} else {
			scoreOutput.setText("");
			diceOutput.setText("");
		}
	}

	@FXML
	public void testSingleValue() {
		runDiceScorer(singleValue);
	}

	@FXML
	public void testStraight() {
		runDiceScorer(straight);
	}

	@FXML
	public void testNothing() {
		runDiceScorer(nothing);
	}
}