CSci 1902 Assignment 2

• [2008-02-20] Corrected error in description of instance variable of the Deck class. It was private List<Card> deck; the correct declaration is private ArrayList<Card> deck.

• Added clarifying sentences to the B and A level. These only clarify existing requirements and do not impose any new ones.

  1. B Level
     • Put examples to clarify rules for play.
     • Delete unnecessary stop rule 1.
  2. A Level :
     • SortedCardDeck class is a subclass of Deck class.
     • Your program should play two decks (one is an instance of Deck and the other an instance of SortedCardDeck) and show the the results of playing both decks.
     • A SortedCardDeck must always maintain its cards in sorted order. This means that the constructor for SortedCardDeck must create a deck that is sorted. There are several ways to do this: we'll leave it to you to figure one out.
     • There are several operations on a Deck that do not make sense for a SortedCardDeck, shuffle() and add(int n, Card c). You should provide "null implementations" for these methods in SortedCardDeck (i.e., either no code in the body, or just a statement to print a notification message).
     • You don't need to implement a JUnit test case to test add(int n, Card c) method. We asked to implement two JUnit test cases for two overriden add methods. Currently, you are required to implement a JUnit test case to test add(Card c) method.

The purpose of this assignment is to give you some initial experience writing Java code using fundamental Object-Oriented programming concepts and the List Abstract Data Type.

Your task in this assignment is to write a simple card game program for one player. You will define classes to represent cards and decks of cards, define basic operations on decks, and implement rules to play a simple Solitaire game.

At the C level, your program will do basic operations on a deck of cards such as shuffle, draw, look, add, display and so on.

At the B level, you will implement the rules to play a simple Solitaire game.

Following is a sample of the output at the B level:

Queen of Clubs, 4 of Clubs, Queen of Hearts, Queen of Diamonds, 8 of Diamonds
8 of Diamonds, 4 of Clubs, Queen of Hearts
End of the game, 3 cards left.
You win.

At the A level, you will create a new type of Deck, one that always maintains cards in a sorted order (as specified below). You also will write a JUnit test case.

In Eclipse, create a new Java project.

Download the following files, and import them into your project:

• build.xml (import this into your project root folder)

• Suit.java (Suit class; import this into your src/ folder)

• Rank.java (Rank class; import this into your src/ folder)

• CardTest.java (To check your work; import this into your src/ folder)

• DeckTest.java (To check your work; import this into your src/ folder)

• SolitaireTest.java (To check your work; import this into your src/ folder)

To receive a C, you must create a class Card and a class Deck. The Card class has two attributes (suit and rank). The Deck class consists of attributes and operations of a deck of cards.

We provide implementations of Suit and Rank. (Suit.java and Rank.java) using Java's enum construct. You do not need to understand the details of how enums work, but you must use the exact code we provide. Moreover, we encounrage you to look at the Suit and Rank classes before implementing the C level, so that you can see what operations, etc. are available.

You should implement the following in your Card class:

1. Instance variable : You need variables to store the Suit and Rank of the card. You may name them whatever you wish.

2. Card(Suit s, Rank r) : Constructor for Card. It creates a new Card with the specified Rank and Suit.

3. You must implement all the operations specified in Card.html. You must define methods with precisely the names and signatures (number and type of parameters) shown there.

You must implement the following in your Deck class:

1. Instance variable : A Deck keeps track of the list of Cards in it.

   private ArrayList<Card> deck = new ArrayList<Card>()

   OR

   private LinkedList<Card> deck = new LinkedList<Card>() 

   You may create an object that is either an ArrayList<Card> or LinkedList<Card>.

2. Deck () : The constructor creates a new Deck object with 52 cards: the Two through Ace of each of the four Suits.

3. You must implement all the operations specified in Deck.html. You must define methods with precisely the names and signatures (number and type of parameters) shown there.

Add code to your Level C solution to play a Solitaire game. Create a Solitaire class with a main method. You will also need to implement another method for the Solitaire class, playTurn(Deck d)

In the main method, you will create a Deck object. Shuffle it, then call playTurn until the game is over (See rules below). In other words, the logic is:

Deck deck = new Deck();
deck.shuffle();
while ( game not finished )
	playTurn(deck);

public static void playTurn(Deck deck)

Rules

Here are the rules that describe how to play a turn in the game.

1. look at the first 4 cards. If all cards are the same suit, remove all.

2. if all 4 cards are the same rank, remove all.

3. if 1 & 4 are the same rank, remove 1 and 4 cards. After removing cards, put the ones that you didn't remove back into the back of the deck.

   Example
   Queen of Clubs, 4 of Clubs, Queen of Hearts, Queen of Diamonds, 8 of Diamonds
   8 of Diamonds, 4 of Clubs, Queen of Hearts
   

4. if 1 & 4 are the same suit, remove 2 and 3 cards. After removing cards, put the ones that you didn't remove back into the back of the deck.

   Example
   4 of Clubs, 8 of Clubs, Queen of Spades, Queen of Clubs, 8 of Diamonds
   8 of Diamonds, 4 of Clubs, Queen of Clubs
   

5. if 1 & 4 are neither the same rank nor the same suit, if 1 & 4 are from the same color group, (Consider spades and clubs as a black color group and hearts and diamonds as a red color group.) remove 1 card. put the ones that you didn't remove back into the back of the deck.

   Example
   4 of Diamonds, 8 of Clubs, Queen of Spades, Queen of Hearts, 8 of Diamonds
   8 of Diamonds, 8 of Clubs, Queen of Spades, Queen of Hearts
   

6. if all condition are not satisfied, put all of them into the back of the deck.

   Example
   4 of Spades, 8 of Clubs, Queen of Spades, Queen of Hearts, 8 of Diamonds
   8 of Diamonds, 4 of Spades, 8 of Clubs, Queen of Spades, Queen of Hearts
   

Here are the rules that define the stopping condition for the game.

1. if the number of total left cards is less than 5. In this case, you win the game.

2. if you play the game (run the playTurn) more than 1000 times. In this case, you lose the game.

Print the list of cards at every step. Finally indicate "You win" or "You lose". If you drop all cards or the number of total left card is less than 5, "You win". Otherwise, "You lose".

For this level, you need to add the following: First, implement your JUnit test code for OVERRIDING add function (add(Card c)). Second, create a new type of Deck that maintains its cards in a sorted order. To do this, you will have to change the Card class too.

1. Change your Card class so that it implements Comparable. The compareTo() method in Card class returns an ordering by suits: spades > hearts > diamonds > clubs and then by rank A > K > ... > 2.
2. Create a class called SortedCardDeck. SortedCardDeck class is a subclass of Deck class. For the A level, you should change the access modifier for the instance variable deck from private to protected. A SortedCardDeck object must guarantee that the cards in the deck are sorted when it is created. Your constructor must make sure this is the case. Moreover, you must override the two add operations (inherited from the Deck class) so that any time a Card is added to the Deck, it will be added in sorted order.
3. Implement a JUnit test case to test the overridden add method (add(Card c)). The name of your JUnit test should be SortedCardDeckTest.java.
4. Two methods inherited from Deck do not make sense for SortedCardDeck, shuffle() and add(int n, Card c). You should override these methods with 'null implementations' here. That is, the body of the method either should be empty or else should contain just a statement that prints a message saying this method is not implemented for a SortedCardDeck.
5. Open the Solitaire.java. Create one sorted order deck in the main method. (So, you have two decks. One is original deck and the other is sorted order deck.) Play two decks and show two results. (This shouldn't mess up the original Deck.)
6. Finally, you may find it useful (but it is not required) to define another constructor for SortedCardDeck that initializes the deck variable to contain an empty list of Card. You can then invoke the add method a number of times with different Card objects to verify that they are added in the proper order.

Before you submit your assignment, you must create a text file called readme.txt in your project directory. In this file, put your name and x.500 ID.

Copy all your own code and other files (include all given java files such as CardTest.java, DeckTest.java, SolitaireTest.java and so on) to an ITLabs computer for final testing. On the ITLabs computer, run ant run in your code's directory and make sure the program works. Then run ant package to create the HW package, and submit the resulting hw2.tgz file via Submit.