Page History

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!

Rett frem koding av verdi-klasse.

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

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

Her skal det bare sjekkes om Dice-argumentet har minst én av den aktuelle verdien. I så fall returneres et DiceScore-objekt med et Dice-objekt med denne ene verdien og de aktuelle poengene. Det er strengt tatt galt å regne med alle terningene av den aktuelle verdien og gange opp poengene, men det er vi ikke så nøye på. Men da må selvsagt også Dice-objektet ha tilsvarende mange av den verdien.

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

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

Her kan man velge to fremgangsmåter, enten se på sekvensen av terningverdier (det enkleste) eller sekvensen av verditellere (det mest opplagte). Den første blir enkel iterasjon, hvor man sjekker at differansen til forrige verdi er 1, hvis ikke returneres null. Det er kanskje mer opplagt å se på verditellerne, siden det er de som er eksplisitt representert, men det er i praksis mer kinkig, en må skjønne at en straight er en sammenhengende serie 1-er-tellere, med evt. 0-er-tellere før og etter. En må først spole seg over evt. 0-ere og frem til den første 1-ern og så over 1-erne og frem til en 0. Hvis antall 1-ere man har avgrenset tilsvarer antall terninger i Dice-argumentet, så har man en straight. Det er denne fremgangsmåten vi har brukt under. Vi bruker getValueCount-metoden for å hente ut tellerne, siden valueCounters-feltet ikke nødvendigvis er synlig.

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

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

Her må en skjønne hvordan Nothing skal bruke (andre) instanser av DiceScorer til å gjøre sin jobb. Her bruker vi ...-notasjonen, altså varargs som tilsvarer DiceScorer[], men det er greit å bruke andre typer som en kan iterere over, f.eks. Collection eller List.

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, getScore()this.score);
	}
}

Dette er delegeringsteknikken i praksis, hvor en instans av (en implementasjon av) et grensesnitt bruker en eller flere andre instanser av (implementasjoner av) samme grensesnitt, til å gjøre jobben.

Regelen er at typen på venstre side på være lik eller en supertype av typen på høyre side. Dermed kan en bruke SingleValue selv, DiceScorer-grensesnittet som den implementerer, og Object, som er superklassen til alle klasser.

Det som avgjør valget er hvilke metoder man ønsker å (kunne) bruke. Dersom man ikke trenger metodene som er spesifikke for en subtype, så velger man supertypen. Her er det naturlig å velge DiceScorer, siden SingleValue uansett ikke har andre metoder som kan være relevante å (ønske å) bruke. Hvis en bare skal bruke Object-metoder, som toString og equals, så kan en velge Object, men det er sjeldent bare Object-metodene er relevante.

Det disse tre implementasjonene har felles er score-verdien, så denne kan legges i den abstrakte AbstractScorer-klassen, initialiseres ved å kalle super(score) øverst i subklasse-konstruktørene og leses med getScore():

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