**JAVA files including PlayingCard.java and VideoPoker.java,**

- Implement poker game program in package PJ4: Part I (40%) Implement Decks class Part II (60%) Implement VideoPoker class Bonus (30%) Add GUI, only after you have completed I & II Must complete by same due date. Submit both non-GUI and GUI versions See PJ4/PlayingCard.java and PJ4/VideoPoker.java for more info.

- Use TestVideoPoker.java to test correctness of your program

- Compile programs (you are in directory containing Readme file): javac PJ4/*.java javac TestVideoPoker.java

- Run programs (you are in directory containing Readme file):

// Run tests in PJ4 classes java PJ4.Decks java PJ4.VideoPoker

// Run main test program java TestVideoPoker

//////////////////////////////////////////////////////////////////////////////////////

package PJ4; import java.util.*;

/* * Ref: http://en.wikipedia.org/wiki/Video_poker * http://www.freeslots.com/poker.htm * * * Short Description and Poker rules: * * Video poker is also known as draw poker. * The dealer uses a 52-card deck, which is played fresh after each playerHand. * The player is dealt one five-card poker playerHand. * After the first draw, which is automatic, you may hold any of the cards and draw * again to replace the cards that you haven't chosen to hold. * Your cards are compared to a table of winning combinations. * The object is to get the best possible combination so that you earn the highest * payout on the bet you placed. * * Winning Combinations * * 1. One Pair: one pair of the same card * 2. Two Pair: two sets of pairs of the same card denomination. * 3. Three of a Kind: three cards of the same denomination. * 4. Straight: five consecutive denomination cards of different suit. * 5. Flush: five non-consecutive denomination cards of the same suit. * 6. Full House: a set of three cards of the same denomination plus * a set of two cards of the same denomination. * 7. Four of a kind: four cards of the same denomination. * 8. Straight Flush: five consecutive denomination cards of the same suit. * 9. Royal Flush: five consecutive denomination cards of the same suit, * starting from 10 and ending with an ace * */

/* This is the video poker game class. * It uses Decks and Card objects to implement video poker game. * Please do not modify any data fields or defined methods * You may add new data fields and methods * Note: You must implement defined methods */

public class VideoPoker {

// default constant values private static final int startingBalance=100; private static final int numberOfCards=5;

// default constant payout value and playerHand types private static final int[] multipliers={1,2,3,5,6,10,25,50,1000}; private static final String[] goodHandTypes={ "One Pair" , "Two Pairs" , "Three of a Kind", "Straight", "Flush ", "Full House", "Four of a Kind", "Straight Flush", "Royal Flush" };

// must use only one deck private final Decks oneDeck;

// holding current poker 5-card hand, balance, bet private List playerHand; private int playerBalance; private int playerBet;

/** default constructor, set balance = startingBalance */ public VideoPoker() { this(startingBalance); }

/** constructor, set given balance */ public VideoPoker(int balance) { this.playerBalance= balance; oneDeck = new Decks(1, false); }

/** This display the payout table based on multipliers and goodHandTypes arrays */ private void showPayoutTable() { System.out.println(" "); System.out.println("Payout Table Multiplier "); System.out.println("======================================="); int size = multipliers.length; for (int i=size-1; i >= 0; i--) { System.out.println(goodHandTypes[i]+"\t|\t"+multipliers[i]); } System.out.println(" "); }

/** Check current playerHand using multipliers and goodHandTypes arrays * Must print yourHandType (default is "Sorry, you lost") at the end of function. * This can be checked by testCheckHands() and main() method. */ private void checkHands() { // implement this method! }

/************************************************* * add new private methods here .... * *************************************************/

public void play() { /** The main algorithm for single player poker game * * Steps: * showPayoutTable() * * ++ * show balance, get bet * verify bet value, update balance * reset deck, shuffle deck, * deal cards and display cards * ask for positions of cards to replace * get positions in one input line * update cards * check hands, display proper messages * update balance if there is a payout * if balance = O: * end of program * else * ask if the player wants to play a new game * if the answer is "no" : end of program * else : showPayoutTable() if user wants to see it * goto ++ */

// implement this method!

}

/************************************************* * Do not modify methods below /*************************************************

/** testCheckHands() is used to test checkHands() method * checkHands() should print your current hand type */

public void testCheckHands() { try { playerHand = new ArrayList();

// set Royal Flush playerHand.add(new Card(3,1)); playerHand.add(new Card(3,10)); playerHand.add(new Card(3,12)); playerHand.add(new Card(3,11)); playerHand.add(new Card(3,13)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set Straight Flush playerHand.set(0,new Card(3,9)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set Straight playerHand.set(4, new Card(1,8)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set Flush playerHand.set(4, new Card(3,5)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// "Royal Pair" , "Two Pairs" , "Three of a Kind", "Straight", "Flush ", // "Full House", "Four of a Kind", "Straight Flush", "Royal Flush" };

// set Four of a Kind playerHand.clear(); playerHand.add(new Card(4,8)); playerHand.add(new Card(1,8)); playerHand.add(new Card(4,12)); playerHand.add(new Card(2,8)); playerHand.add(new Card(3,8)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set Three of a Kind playerHand.set(4, new Card(4,11)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set Full House playerHand.set(2, new Card(2,11)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set Two Pairs playerHand.set(1, new Card(2,9)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set One Pair playerHand.set(0, new Card(2,3)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set One Pair playerHand.set(2, new Card(4,3)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------");

// set no Pair playerHand.set(2, new Card(4,6)); System.out.println(playerHand); checkHands(); System.out.println("-----------------------------------"); } catch (Exception e) { System.out.println(e.getMessage()); } }

/* Quick testCheckHands() */ public static void main(String args[]) { VideoPoker pokergame = new VideoPoker(); pokergame.testCheckHands(); } }

//////////////////////////////////////////////////////////////////////////////////////

package PJ4;

import java.util.*;

//================================================================================= /** class PlayingCardException: It is used for errors related to Card and Deck objects * Do not modify this class! */ class PlayingCardException extends Exception {

/* Constructor to create a PlayingCardException object */ PlayingCardException (){ super (); }

PlayingCardException ( String reason ){ super ( reason ); } }

//================================================================================= /** class Card : for creating playing card objects * it is an immutable class. * Rank - valid values are 1 to 13 * Suit - valid values are 0 to 4 * Do not modify this class! */ class Card { /* constant suits and ranks */ static final String[] Suit = {"Joker","Clubs", "Diamonds", "Hearts", "Spades" }; static final String[] Rank = {"","A","2","3","4","5","6","7","8","9","10","J","Q","K"};

/* Data field of a card: rank and suit */ private int cardRank; /* values: 1-13 (see Rank[] above) */ private int cardSuit; /* values: 0-4 (see Suit[] above) */

/* Constructor to create a card */ /* throw PlayingCardException if rank or suit is invalid */ public Card(int suit, int rank) throws PlayingCardException {

// suit =0 is joker, rank must be 1 or 2 if (suit==0) { if ((rank <1) || (rank >2)) throw new PlayingCardException("Invalid rank for Joker:"+rank); cardRank=rank; cardSuit=0; } else {

if ((rank < 1) || (rank > 13)) throw new PlayingCardException("Invalid rank:"+rank); else cardRank = rank;

if ((suit < 1) || (suit > 4)) throw new PlayingCardException("Invalid suit:"+suit); else cardSuit = suit; } }

/* Accessor and toString */ /* You may impelemnt equals(), but it will not be used */ public int getRank() { return cardRank; } public int getSuit() { return cardSuit; } public String toString() { if (cardSuit == 0) return Suit[cardSuit]+" #"+cardRank; else return Rank[cardRank] + " " + Suit[cardSuit]; }

/* Few quick tests here */ public static void main(String args[]) { try { Card c1 = new Card(4,1); // A Spades System.out.println(c1); c1 = new Card(1,10); // 10 Clubs System.out.println(c1); c1 = new Card(0,2); // Joker #2 System.out.println(c1); c1 = new Card(5,10); // generate exception here } catch (PlayingCardException e) { System.out.println("PlayingCardException: "+e.getMessage()); } } }

//================================================================================= /** class Decks represents : n decks of 52 (or 54) playing cards * Use class Card to construct n * 52 (or 54) playing cards! * * Do not add new data fields! * Do not modify any methods * You may add private methods */

class Decks {

/* this is used to keep track of original n*52 or n*54 cards */ private List originalDecks;

/* this starts with copying cards from originalDecks */ /* it is used to play the card game */ /* see reset(): resets gameDecks to originalDecks */ private List gameDecks;

/* number of decks in this object */ private int numberDecks; private boolean withJokers;

/** * Constructor: Creates one deck of 52 or 54 (withJokers = false or true) * playing cards in originalDecks and copy them to gameDecks. * initialize numberDecks=1 * Note: You need to catch PlayingCardException from Card constructor * Use ArrayList for both originalDecks & gameDecks */ public Decks(boolean withJokers) { // implement this method! }

/** * Constructor: Creates n decks (54 or 52 cards each deck - with or without Jokers) * of playing cards in originalDecks and copy them to gameDecks. * initialize numberDecks=n * Note: You need to catch PlayingCardException from Card constructor * Use ArrayList for both originalDecks & gameDecks */ public Decks(int n, boolean withJokers) { // implement this method! }

/** * Task: Shuffles cards in gameDecks. * Hint: Look at java.util.Collections */ public void shuffle() { // implement this method! }

/** * Task: Deals cards from the gameDecks. * * @param numberCards number of cards to deal * @return a list containing cards that were dealt * @throw PlayingCardException if numberCard > number of remaining cards * * Note: You need to create ArrayList to stored dealt cards * and should removed dealt cards from gameDecks * */ public List deal(int numberCards) throws PlayingCardException { // implement this method! return null; }

/** * Task: Resets gameDecks by getting all cards from the originalDecks. */ public void reset() { // implement this method!

}

/** * Task: Return number of decks. */ public int getNumberDecks() { return numberDecks; }

/** * Task: Return withJokers. */ public boolean getWithJokers() { return withJokers; }

/** * Task: Return number of remaining cards in gameDecks. */ public int remainSize() { return gameDecks.size(); }

/** * Task: Returns a string representing cards in the gameDecks */ public String toString() { return ""+gameDecks; }

/* Quick test */ /* */ /* Do not modify these tests */ /* Generate 2 decks of 54 cards */ /* Loop 2 times: */ /* Deal 27 cards for 5 times */ /* Expect exception at 5th time*/ /* reset() */

public static void main(String args[]) {

System.out.println("******* Create 2 decks of cards ******** "); Decks decks = new Decks(2, true); System.out.println("getNumberDecks:" + decks.getNumberDecks()); System.out.println("getWithJokers:" + decks.getWithJokers()); for (int j=0; j < 2; j++) { System.out.println(" ************************************************ "); System.out.println("Loop # " + j + " "); System.out.println("Before shuffle:"+decks.remainSize()+" cards"); System.out.println(" \t"+decks); System.out.println(" ============================================== ");

int numHands = 5; int cardsPerHand = 27;

for (int i=0; i < numHands; i++) { decks.shuffle(); System.out.println("After shuffle:"+decks.remainSize()+" cards"); System.out.println(" \t"+decks); try { System.out.println(" Hand "+i+":"+cardsPerHand+" cards"); System.out.println(" \t"+decks.deal(cardsPerHand)); System.out.println(" Remain:"+decks.remainSize()+" cards"); System.out.println(" \t"+decks); System.out.println(" ============================================== "); } catch (PlayingCardException e) { System.out.println("*** In catch block:PlayingCardException:Error Msg: "+e.getMessage()); } }

decks.reset(); } }

}

/************************************************************************************* * * This program is used to test PJ4.VideoPoker class * More info are given in Readme file * * PJ4 class allows user to run program as follows: * * java PJ4 // default credit is $100 * or java PJ4 NNN // set initial credit to NNN * * Do not modify this file! * **************************************************************************************/

import PJ4.VideoPoker;

class TestVideoPoker {

public static void main(String args[]) { VideoPoker pokergame; if (args.length > 0) pokergame = new VideoPoker(Integer.parseInt(args[0])); else pokergame = new VideoPoker(); pokergame.play(); } }