CS 312 - Programming Project 9
The Game of War

Practice with: Writing your own classes


This assignment is a pair assignment. You may work with one other person on this project using the pair programming technique (as described on the course webpage - read, and follow, the rules carefully). You are not required to work with a partner; you may work alone. If you choose to work with a partner, you are allowed to work with any CS 312 student - your partner does not need to be in your discussion section. If you work as a pair, only one of you should submit your solution. Once you start working on the assignment, you are not allowed to switch partners! If you do not want to work with your partner after starting the assignment, you must both complete the assignment individually, and you must both email the instructor to explain why you are not completing the assignment as a pair. Failure to follow the pair programming rules (and include the necessary documentation in your files) will result in significant point deductions.


For this project, you may only use concepts that are covered in class.


As for all CS 312 projects, your file comment header should look like this:
/**
*  author: <Your Name Here>
*  date:  <Submission Date>
*  CS 312 Assignment 9
*  On my honor, <Your Name>,  (or <Your Name>, and <Your Partner's Name>) this programming assignment is my (our) own work.
*
*  EID: <Your EID> (include for both partners, if applicable)
*  Section: <Unique Number>, <Thursday discussion time> (include for both partners, if applicable)
*
* <Brief Description - what does the program do?>
*
* Slip Days I am using on this project: <Your Slip Days>
* Slip Days I have used this semester: <Your Total, including for this project>
*/


There are 3 basic parts to the assignment. Each is described in detail below. Do these parts in the order in which they are described, and make sure that each part is working correctly before you continue on to the next part.


1. The Card class

For this class you will be simulating one card - a card in a deck of playing cards. A playing card has two properties: a suit and a value. We encode each of these as an integer using the following scheme:

Suit

Spades - 3
Hearts - 2
Diamonds - 1
Clubs - 0

(Note: This is a good opportunity to use a constant - you are required to do so. See the "getSuitAsString()" method below.)

Value

Ace - 1
2-10 will be represented by the actual value
Jack - 11
Queen - 12
King - 13

1) You will need to write two constructors and accessor methods for each property. One constructor creates a random, valid card. The second constructor will accept two parameters. The first parameter is the suit and the second parameter is the card value.

2) Also override the clone(), toString(), and equals() methods from the Object class.

3) Write a compareValue() method that takes another Card object and returns true if the current object has greater value and false otherwise. The header for this method is
public boolean compareValue(Card other) - it returns true if this card's value is greater than other's value.

4) You should also include the following methods in your class:

  public String getSuitAsString() {
// Return a String representing the card's suit.
// (If the card's suit is invalid, "??" is returned.)
switch ( suit ) {
case SPADES: return "Spades";
case HEARTS: return "Hearts";
case DIAMONDS: return "Diamonds";
case CLUBS: return "Clubs";
default: return "??";
}
}
    public String getValueAsString() {
// Return a String representing the card's value.
// If the card's value is invalid, "??" is returned.
switch ( value ) {
case 1: return "Ace";
case 2: return "2";
case 3: return "3";
case 4: return "4";
case 5: return "5";
case 6: return "6";
case 7: return "7";
case 8: return "8";
case 9: return "9";
case 10: return "10";
case 11: return "Jack";
case 12: return "Queen";
case 13: return "King";
default: return "??";
}
}
 
public String toString() {
// Return a String representation of this card, such as
// "10 of Hearts" or "Queen of Spades".
return getValueAsString() + " of " + getSuitAsString();
}



2. The Deck class

The Deck class represents a standard deck of 52 playing cards. It has three instance variables:

1.  An array of 52 cards (ie Card objects)
2.  An integer index into the array called top. If top is 4, that means that cards 0 to 3 have already been dealt. The next card to deal is at position 4 in the array.
3. the number of cards currently in the deck, deckSize.

Your Deck class should contain the following public methods:

1. A constructor that takes no arguments, and initializes a deck in order by suit and rank. Ie the constructor creates 52 new Card objects, and puts them in order in the deck: ace of clubs, two of clubs, ... king of clubs, ace of diamonds, two of diamonds, ... etc.

2. void shuffle(): this method shuffles the deck. Remember to ignore the cards which have been dealt when  shuffling. To shuffle the deck, consider repeatedly (say 500 times or so) picking two cards in the deck at random and swapping their positions.

3. Card dealCard(): deal the card on top of the deck and return it.

4. Accessor methods for instance variables top and deckSize.

5. toString(): override toString() from Object class. This method returns a string representation of each card currently in the deck.

6. Overwritten version of clone() that returns a copy of this deck.


3. Playing the game of War

The card game War has the following rules:


For this project, you will implement the game of War. Your program should play War until one player wins, or until 5000 rounds have been played. If you stop after 5000 rounds, your program should display how many cards each player has at that point, and if the game ends because one player won, your program should indicate who won.

You will need to use your Card and Deck classes. Include a compareTo() method in your Card class so that you can compare two cards. This method should have this signature:


You will also need some other classes:


Output:

First print each player's hand after the cards are dealt. Then print each player's hand at the end of the game. If the game ended because one player won, you will only print the winner's hand. If the game ended because 5000 rounds have been played, print the hands of both players. After you display the hand(s) at the end of the game:
If there is a winner, print the winner (Player 1 or Player 2) and the number of rounds played. If there was no winner, print the number of cards each player has at the end of the game. For example:

Playing War!
Cards dealt - here are the hands:
Player 1:

Queen of Spades
2 of Diamonds
Jack of Hearts
...

Player 2:
Ace of Clubs
3 of Hearts
...

Hands at the end of the game:
Player 1:
3 of Hearts
4 of Diamonds
...

Player 2:
2 of Spades
6 of Diamonds
King of Spades
...

Results of the game:
No winner.
Player 1 has 34 cards.
Player 2 has 18 cards.

or, alternatively, the Results section if there was a winner:

Results of the game:
Winner: Player 1
Number of rounds: 3050



The main method in your program should be contained in the War class. Submit Card.java, Deck.java, Hand.java and War.java (and other classes, as described in your documentation, if you choose) by the due date. Remember that slip days cannot be used on this project and plan accordingly.

You are allowed, but not required, to work with a partner on this project. If you choose to work with a partner, follow all the rules that have been described previously about pair projects. Only one partner should submit the project.

Did you remember to:
Turn in the project by the due date (since slip days are not allowed)?
Do this project alone (or only with your partner?
Follow the pair programming requirements, if you are working with a partner?
Submit Card.java, Deck.java, Hand.java, War.java via turnin?