Page History

Denne delen av oppgaven omhandler Dice-klassen, som brukes til å representere (verdien av) én eller flere terninger (engelsk: dice = terninger, die = terning). En slik klasse kan være nyttig i mange typer terningspill, for å representere terninger som nettopp er slått eller de av et sett terninger som en får poeng for.

Merk at poengene ikkeer en del av Dice-klassen, de håndteres av andre klasser som beskrives senere.

Dice-klassen er vist under, ??? erstatter kodefragmenter som det spørres om i oppgaveteksten., mens ... står for kode som er utelatt fordi det ikke er viktig. Vi kreverher at terningverdiene skal representeres på en bestemt måte, som et sett tellere for hver mulig terningverdi, og har derfor oppgitt deklarasjonen av valueCounters. Det skal ikkevære nødvendig å deklarere andre felt enn dette.

Eksempel: Hvis et Dice-objekt representerer de fire verdiene 1, 2, 2 og 4, så vil tellerverdiene i valueCountersvære 1, 2, 0, 1, 0 og 0, altså 1 ener, 2 toere, ingen treere, 1 firer, ingen femmere og ingen seksere. For getDieValue-metoden sin del, vil eneren være på indeks 0, de 2 toerne vil være på indeks 1 og 2, og fireren vil være på indeks 3.

/**
 * Represents a set of die values.
 */
public class Dice implements Iterable<Integer> {
    /**
     * Counters for each possible die value.
     * The counter at index i (0-5) is the counter for the die value i+1 (1-6).
     * I.e. the value at index 2 is the counter for die value 3.
     */
    private final int[] valueCounters;
 
    /**
     * Initializes this Dice with the values in dieValues.
     * @param dieValues sequence of die values, not counter values
     */
    public Dice(Iterator<Integer> dieValues) {
        ???
    }

    /**
     * Initializes this Dice with the values in dieValues.
     * @param dieValues sequence of die values, not counter values
     */
    public Dice(Iterable<Integer> dieValues) {
        ???
    }
 
    @Override
    public Iterator<Integer> iterator() {
        return new DiceIterator(this);
    }
 
    /**
     * @return the number of die values
     */
    public int getDieCount() {
        ???
    }
 
    /**
     * Die values are considered ordered, with the smallest die values
     * at the lowest index. The value at a specific index
     * must be computed from the counters in valueCounters.
     * @param dieNum
     * @return the value of die number dieNum
     * @throws an appropriate exception, if dieNum is out of range
     */
    public int getDieValue(int dieNum) {
        ???
    }
 
    /**
     * @param value
     * @return the number of dice with the provided value
     */
    public int getValueCount(int value) {
        ???
    }

    /**
     * @param dice
     * @return true if all die values in the Dice argument appear in this Dice
     */
    public boolean contains(Dice dice) {
        ???
    }
 
    /**
     * @param dice
     * @return true if this Dice and the one provided have exactly the same die values
     */
    public boolean isSame(Dice dice) {
        ???
    }
 
    /**
     * @param dice a Dice object
     * @return a new Dice instance with the all the die values in
     * this Dice and the Dice argument combined
     */
    public Dice add(Dice dice) {
        ???
    }
 
    /**
     * @param dice
     * @return a new Dice instance with the die values from this Dice, but
     * without those from the Dice argument
     */
    public Dice remove(Dice dice) {
        ???
    }
}

Vanlige feil:

Vanlige feil:

• Et ekstra kommaskilletegn i toString-resultatet.
• Ikke sjekke om score var ulik -1, før en evt. legger den til på slutten etter likhetstegnet.
• Ideelt sett skal en sjekke syntaks og utløse hjelpsomme unntak. Men hvis en antar at syntaksen er riktig, og implisitt blir utløst unntak likevel, når en f.eks. antar at strengen inneholder et likhetstegn, så går det i praksis for det samme. Det er nesten verre å å lage så vanntett valueOf-kode at det ikke utløses unntak når syntaksen er feil.
• Bruk av en annen type enn String[] for resultatet fra split, f.eks. List.

Vanlige feil:

Vanlige feil:

Denne deloppgaven handler om representasjon av poeng og poengberegning basert på et sett terningverdier. Felles for mange terningspill er at man kaster terninger og så finner ut hvor mange poeng en får basert på terningverdiene. Visse kombinasjoner gir mer eller mindre poeng, og noen gir ingen. I Yatzy har en mange poenggivende kombinasjoner, f.eks. ett par (to like), to par, tre og fire like, liten (1-5) og stor (2-6) straight, hus (ett par og tre like) og Yatzy (fem like), og poengene en får er stort sett summen av terningverdiene som inngår i kombinasjonen. I Farkle er det andre regler, og her begrenser vi oss til å implementere tre regler (se nedenfor).

DiceScore-klassen innføres (se kode nedenfor) for å knytte poeng til et sett poenggivende terninger. Et DiceScore-objekt har data om:

• Dice-objektet med de poenggivende terningverdiene
• Poengene selv

Eksempel:

Et Dice-objekt representerer terningverdiene 1, 2, 2, 2, 3, og en får 200 poeng for de tre toerne. Dette representeres av et DiceScore-objekt med:

• et (nytt) Dice-objekt som representerer 2, 2, 2, (altså de som gir poeng) og
• tallet 200 (poengene selv)

/**
* 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
}

Selve beregningen av poeng, og dermed opprettelsen av DiceScore-objekter, gjøres av implementasjoner av DiceScorer-grensesnittet. DiceScorer-grensesnittet representerer altså en poengregel generelt, og det er én implementasjonsklasse for hver (type) regel. DiceScorer-grensesnittet har kun én metode, getScore, som tar inn et Dice-objekt med alle terningverdiene som skal vurderes samlet og returnerer et nytt DiceScore-objekt med poengene en får og de av terningene som ga poeng, som beskrevet over.

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

Vi begrenser oss som nevnt til tre poengregler, representert ved tre DiceScorer-implementasjoner:

• SingleValue - gir poeng for enkeltvise enere og -femmere
• Straight- gir poeng når alle terningverdiene utgjør en serie
• Nothing- gir poeng når en slår minst et visst antall terninger og de andre reglene ikke gir poeng!

Vanlige feil/svakheter:

/**
* 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) {
        ???
    }
}

Vanlige feil/svakheter:

/**
* 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) {
        ???
    }
 
    /**
    * 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) {
        ???
    }
}

/**
* 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 getScore(Dice dice) {
        ???
    }
}