Background

You have been asked to develop the logic for a version of a card game that has aspects similar to the popular card game ‘Uno’. The working title for the game is Quattro (as it has four players).

Game Materials:

• There are 40 cards in the pack in total

• Cards can be of: four different colours – Red, Yellow, Green, Blue; and have a number value between 0 – 9

• The game is played with four players.

Rules for Gameplay

1. Each player receives a set number of cards to play (for this game players will receive three cards each). These are referred to as the player ‘hand’.

2. The remaining cards are placed in a ‘draw’ pile.

3. The first card in the draw pile is placed in the ‘discard’ pile and its colour and number revealed. It is now the turn of the first player.

4. The player checks the cards in their hand to see if any match against the top card of the ‘discard’ pile in terms of: a. The numbers of the two cards b. The colours of the two cards

5. If they have a match on colour or number, the player removes the matching card from their hand, and it becomes the first (top) card in the ‘discard’ pile.

6. If they do not have a match, they need to instead take the top card from the ‘draw’ pile and add it to their hand.

7. Play then moves onto the next player, who works their way through steps 4-6

8. Play continues until one player has no cards remaining. This player is declared the winner of the game. There are numerous online videos of people playing ‘Uno’ which is a more complicated version of the game we are developing. Search ‘People Playing Uno’ and check out a couple to get a better idea of gameplay in action if you are unsure of the game mechanics. Note that unlike Uno we are not including any ‘Wild, Draw Two, Reverse, or Skip’ cards into our game. Also review ‘Sample Gameplay’ below for a description of how a game may play out

Items to note in relation to the solution:

• This is a text based game only – i.e. you do not have to implement any imagery of cards.

• You can complete the solution however you like, within the following boundaries

o You must use the class structure as outlined in the ‘Class Diagram’ below

o You need to include the functionality as outlined Task 2 below

o You must complete all Tasks below

Class Diagram

You have done some preliminary work and come up with the following class diagram. Note the following in relation to this diagram

• The classes with a ‘blue’ background are active classes in this project. They will contain code for the solution that you are creating

• The classes with an ‘orange’ background are part of a proposed future ‘expansion’ of the game. They need to be implemented but only as a shell (i.e. they will contain no code towards your current solution)

Tasks

Task 1:

Program Design Create a new NetBeans 8.2 Java 8 project called QuattroTest. Add the eight classes from the UML class diagram in a package called ‘quattrotest’ as shown below.

Create a class stub for each class such as below:

public class ClassName {

}

Add the necessary additional keywords for classes that inherit from interfaces or abstract classes

This should also be done for classes that do not have current functionality (as highlighted in the diagram above)

Task 2: Functionality

It is expected that your solution will implement the following functionality (check ‘Rules for Gameplay’ under ‘Background’ for more context on the functionality.

Check as well the ‘Suggested Tips for Implementing for Ideas

Functionality to Implement:

• The card game has four players

• Only one of the players is a ‘human’ player (the remaining three players are bots)

• The program will ask for the human player to give their name.

• Bot players should have a name as well. This should be given to them by the program.

• The deck of cards will consist of forty cards in total made up of: o 10 Blue cards numbered 0-9 o 10 Yellow cards numbered 0-9 o 10 Red cards numbered 0-9 o 10 Green cards numbered 0-9

• The order of any collection of cards must be randomized (i.e. the cards need to be shuffled)

• Each player will be dealt three cards initially from the deck (or ‘draw’ pile)

• The human (and bot) players will be able to view what cards they have in their ‘hand’

• The human (and bot) players will not be able to view of what cards opponents have.

• Once cards have been distributed to players from the draw pile, the first card from this pile is moved to become the first/top card in the ‘discard’ pile.

• A player needs to ‘match’ the top card of the discard pile with a card they have in their hand. o If they have a matching card, it is selected and is then moved from their hand to become the top card of the discard pile. Play then moves onto the next player o If they do not have a matching card, the first card from the draw pile needs to be selected and added to their hand. Play then moves onto the next player

• Each player should have their turn in order

• Once any player has played their last card a message should be displayed indicating that this player is the winner of the game. The game should end at this point.

• The human player should be asked at the start of the game what their name is

• The human player should be provided with the following information during the game where appropriate o Their name o What cards they hold in their hand o What the top card of the discard pile is o What cards other players played o If other players had to select a card from the draw pile o How many cards the other players have in their hands

• The human player should have some means of indicating which card they would like to play via the console

• If the human does not enter details of a valid card to play, they should be advised to enter details again

• If the human does not have a valid card to play, they should be able to indicate this via the console

• If the ‘draw’ pile is exhausted (i.e. there are no more cards in this pile) o The top card of the ‘discard’ pile should be retained in the ‘discard’ pile o All other cards in the ‘discard’ pile should be moved to the ‘draw’ pile and randomized (shuffled).

Suggested tips for implementing:

• Give each of the cards a ‘code’ to identify it i.e. Red 5 could be given the code ‘R5’ or even just a number like ‘16’. What matters is that the code is unique. This code could then be used for the human player to indicate which card they would like to play (along with other functionality)

• Consider making use of Arraylists for the following reasons:

o Arrays lists can be used to manage cards in the following locations ▪ Hold cards in the ‘deck’ or ‘draw’ pile ▪ Hold cards in the ‘discard’ pile ▪ Hold the cards for individual players (i.e. each player has their own arraylist of cards)

o Arraylists can be used to move cards ▪ i.e. A player that has a valid card to play can have that card moved from their ‘personal’ arraylist of cards to the top of the ‘discard’ arraylist ▪ i.e. a player than has no valid card to play can

o Arraylists can have their contents randomized through the function Collections.shuffle(arraylistname) available through importing java.util.*

• Use the ‘QuattroTest’ class to run and test your program frequently. It may be that much of the logic that you write for the program ends up in this class.

• Start by creating the deck of cards making use of the ‘StandardColourCard’ class. As suggested above consider adding the created cards to an arraylist, and develop logic to move cards between a deck and draw pile as required by the game

• From there, add in a player (Using the Player class), and develop the logic to move cards between the player hand, and the deck and draw piles

• From there add in the logic to manage the three bot players and player turns.

• Note the above are suggestions only – so long as all functionality is included and all directions in Tasks 1-4 are followed you can create the program how you wish.

Task 03 Exceptions

You will need to run some checks on the validity of data been entered. It is expected that the program will throw an exception in the following circumstances:

• If no name is entered for the human player of the game

• If the human player makes an invalid selection when entering details of a card to play You must have a catch block that catches these exceptions and displays an appropriate error message. (You can use the getMessage method of the Throwable class to achieve this).

You do need to manage the exceptions appropriately i.e. the program should alert the user that an exception has occurred, and advise the user how to proceed.

Task 04 - Comments

Ensure you include appropriate comments in your code including:

• Purpose of classes

• Purpose of methods

• Explanatory notes for any potentially confusing items

Task 05: Testing

Testing Tasks

As part of your program implementation you should test to determine how the program performs when the user makes an invalid selection when choosing a card to play (refer Task 03)

1. What is white box testing and how would you use it to test this feature

2. What is black box testing and how would you use it to test this feature.

3. Describe one of the error scenarios that could unfold if a user does enter incorrect data.

4. Design a custom Java Class to represent a custom exception for Q3. Your solution must follow best practices from Java’s Exception class hierarchy including:

• A default constructor

• A one-time argument with a message

• The getMessage() accessor method.
 
 

Standard Colour Card Colour Card Card (Abstract) Special Colour Card Wild Card Key: Special Ability (Interface) Fully Implemented Partially Implemented Player Quattro Test