Fall CMPU-101-02, 2008
Asmt 7
Due: Monday, Nov. 17 @ 1:30 p.m.
For this assignment, you will design a more complete Yahtzee game
using object-oriented programming. A big difference will be that you
will take care of scoring. In addition, you will provide a toString
method, as described in the text.
A QUICK REVIEW OF THE RULES OF THIS MINI-VERSION OF YAHTZEE.
A game consists of six turns. Each turn is begun by rolling all of
the dice. The player then has two more chances to roll some or all
of the dice. Each time, the player chooses zero or more dice to
re-roll, and then rolls them. After completing the dice-rolling
phase, the player must score the hand.
A Yahtzee score sheet contains six slots, numbered 1 through 6.
Each of the slots represents a scoring category. Initially, all the
slots are empty. After each turn, as described above, the player
must choose a category for scoring the hand. Once a category
receives a score, it cannot be changed or used again. Thus, after
six turns, the score sheet will be completely filled out and the
game is over. The score for the game is simply the sum of the
scores in the six categories.
The choice of category determines how the score for a given hand
will be computed. For example, suppose the dice are: 2 2 4 5 2.
Scoring this hand in category 2 yields a score of 6 points (i.e., 3
* 2, since there are three 2s in the hand). However, scoring it in
category 4 yields a score of 4 points (i.e., 4 * 1, since there is
only one 4 in the hand). However, scoring the hand in category 6
yields a score of 0 points (i.e., 6 * 0, since there are no 6s in
the hand).
Here's how a game might proceed:
Initially, score sheet is empty: _ _ _ _ _ _.
First turn: Initial dice are: 2 2 4 1 3.
Re-roll the last three dice: 2 2 5 2 6.
Re-roll the 5 and 6: 2 2 3 2 5.
Choose category 2; the score is 6 points (i.e., 2 * 3).
Score sheet now looks like this: _ 6 _ _ _ _.
Second turn: Initial dice are: 1 2 4 3 6.
Re-roll first four: 2 5 6 1 6.
Re-roll 2,5,1: 3 4 6 2 6.
Choose category 6; the score is 12 points (i.e., 6 * 2).
Score sheet now looks like this: _ 6 _ _ _ 12.
Etc.
NOTE
For this assignment you will define a class called Yahtzee that
implements the functionality for a game of Yahtzee as described
above. Your class will include the following object-oriented
methods:
sumScores -- sums the scores in all the categories
rollDice -- rolls the indicated dice
scoreHand -- computes score for the hand using the indicated
category; enters the score into the appropriate
slot in the score sheet
resetGame -- resets the game in preparation for a new game
resetDice -- resets the dice in preparation for a new turn
toString -- returns a String representation of the current
state of the game (e.g., the dice, the number
of rolls left, the current score sheet).
In addition, you will define a static method, validKeeperString,
that returns true if the input String has five characters, each of
which is either 'r' or 'k'.
Finally, you will define a constructor method (that simply calls
the resetGame method).
To see how your methods should behave, have a look at the sample
interactions file, asmt6-inters.txt, provided in the assignment
directory. Below, you will be guided through the process of
defining these methods. Initially, they won't print out as much
information as you see in the sample Interactions Window session;
however, by the time you finish, they should generate results that
are essentially the same as what you see in the sample session.
GETTING STARTED
Define a new class, called Yahtzee.
Be sure to include comments that clearly partition the body of your
class into the following categories:
** the object-oriented data structure
** the constructor(s)
** the object-oriented methods
** the class-oriented methods
OBJECT-ORIENTED DATA STRUCTURE
The object-oriented data structure should contain the following
fields:
** an array of six ints representing the score sheet
NOTE: Be sure to initialize the array so that each slot is
set to -1. We will use the value -1 to indicate that
a category is available for scoring. (Remember, a
slot might receive a score of zero during the game; so
initializing the array with zeros would not be good.)
** an array of five ints representing the dice
** an int called numTurnsLeft that represents the number of
turns the player has left in the game
** an int called numRollsLeft that represents the number of
rolls the player has left in the current turn
** a boolean called currentHandScored that keeps track of
whether or not the player has entered a score for the
current hand in the score sheet
CONSTRUCTOR METHOD
You need supply only one constructor method. It should not take any
arguments. It should simply call the "resetGame" method, described
below. (To enable your code to compile successfully, you should
comment out the call to resetGame until you have actually defined
it. That way you can test your code, even though it's not complete.)
STATIC METHOD
validKeeperString -- This method should take a single String as its
only input. It should return boolean true if
that String contains exactly five characters,
each of which is either 'k' or 'r'
(representing "keep" or "re-roll",
respectively).
NOTE: You can test this method in the Interactions Window
even if you haven't written any other methods yet.
> Yahtzee.validKeeperString("abc")
false
> Yahtzee.validKeeperString("rkrrk")
true
OBJECT-ORIENTED METHODS
rollDice ... This method should take a single String as its only
input. It should first call the validKeeperString
method to determine whether the given String is valid.
If not, then it should print out a warning message.
Next, this method should check whether the player has
any rolls left. If not, it should print out a warning
message.
On the other hand, if the keeper string is valid and
the player has at least one roll left, this method
should:
** Print out a message saying that the dice are
being rolled!
** Re-roll the dice indicated by the keeper string.
** Decrement the number of rolls left.
==> For now, the return type of this method can be void.
Later on, we'll make some changes.
NOTE: You can test this method in the Interactions Window, as
follows.
> y = new Yahtzee()
> y.numRollsLeft = 2;
> y.dice
{ 0, 0, 0, 0, 0 }
> y.rollDice("rrrrr")
Rolling...
> y.dice
{ 3, 2, 6, 6, 5 }
> y.rollDice("rrkkr")
> y.dice
{ 4, 3, 6, 6, 1 }
> y.rollDice("rrkkr")
Hey! No more rolls left!!
resetDice -- This method should do the following, in order:
** set the number of rolls left to 3;
** roll all of the dice;
** set the currentHandScored field to false.
Its return type should be void.
NOTE: You can test this method in the Interactions Window, as
follows.
> y = new Yahtzee()
> y.dice
{ 0, 0, 0, 0, 0 }
> y.resetDice()
> y.dice
{ 2, 1, 3, 4, 5 }
> y.numRollsLeft
2
Notice that the value of numRollsLeft has been
decremented by the act of rolling all the dice.
resetGame -- This method should reset the game in preparation for a
new game of Yahtzee. In particular, it should:
** Print out a message saying that the game is being
reset
** Set each of the slots in the score sheet to -1
(indicating that they are available for use)
** Set the number of turns left to 6
** Call the resetDice method.
The return type of this method should be void.
NOTE: You can test this method in the Interactions Window,
as illustrated below.
> y = new Yahtzee()
> y.resetGame()
Resetting game...
Rolling...
> y.scores
{ -1, -1, -1, -1, -1, -1 }
> y.numTurnsLeft
6
> y.numRollsLeft
2
> y.dice
{ 4, 1, 4, 1, 5 }
=====> After you have written this method, change the
body of the constructor method so that it calls
the resetGame method!
sumScores -- This method should add all of the LEGITIMATE scores in
the score sheet. In particular, it should sum only
those entries in the scores array that are positive or
zero; it should IGNORE the entries that are -1.
This method should return the computed sum (an INT).
NOTE: You can test this method in the Interactions Window
as illustrated below.
> y = new Yahtzee()
Resetting game...
Rolling...
> y.scores
{ -1, -1, -1, -1, -1, -1 }
> y.sumScores()
0
Notice that the answer is zero, not -6.
toString -- Before defining this method, check out the following
Interactions Window session:
> String stree = "hi"
> stree = stree + ":bye"
"hi:bye"
> stree = stree + ":" + 84 + ":"
"hi:bye:84:"
> stree = stree + "so long!!"
"hi:bye:84:so long!!"
Notice that the stree variable initially referred
to the String "hi", but then we successively
concatenated other Strings onto it. At the end,
stree refers to the String "hi:bye:84:so long!!".
If we want to, we can ask println to print out stree:
> System.out.println(stree)
hi:bye:84:so long!!
Okay, back to the toString method....
The definition of this method should begin with the
keyword public, as described in the text. It should not
take any inputs, and it should return a String. That
String should be constructed by concatenating various
bits of information just like in the preceding example.
However, keep in mind that you should RETURN the String,
not print it out!! Here's an example of what should
happen when you call this method explicitly:
> y.toString()
"Dice: 4 6 5 1 5 ; numRollsLeft = 2 ; Scores: _ _ _ _ _ _ ; Total Score: 0"
Notice that the return value is (a reference to) a
String obejct.
Once you have defined this method, you can make
drJava call it automatically, as follows:
> y = new Yahtzee()
Resetting game...
Rolling...
> y
Dice: 4 6 5 1 5 ; numRollsLeft = 2 ; Scores: _ _ _ _ _ _ ; Total Score: 0
Notice that now, because you have defined a toString
method, drJava uses it to describe the Yahtzee object
that y refers to. (Before, drJava would just have
displayed a reference such as Yahtzee@1a204e.)
scoreHand -- This method should take an integer input that represents
one of the scoring categories. It should check several
things before computing the score:
** The category should be an integer from 1 to 6
** The corresponding slot in the scores array
should be -1 indicating that it is available.
** The number of turns left should be positive,
indicating that there is at least one blank
category.
** The currentHandScored field should be false,
indicating that the current hand has not yet been
scored. (You only want to score each hand once.)
If all these...