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();

}

}

}

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("-----------------------------------");

/*************************************************************************************
	*
	* 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();
	}
	}