NOTE: THE CODE SHOULD BE written IN JAVA AND INCLUDE Screenshot OF YOUR OUTPUT RESULT BECAUSE I'LL RATE YOUR ANSWER !! (Don't explain just give me the code do not copy and past from pravious assignment the instrctor has changed some stuff look at my code)

============================

- Upload a zip file, 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

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!

ArrayList multiplierCheck = new ArrayList();

String yourhandtype = "Sorry, you lost";

for (int toList = 0; toList<5; toList++) {

multiplierCheck.add(currentHand.get(toList));

}

System.out.println(multiplierCheck);

System.out.println(yourhandtype);

}

/*************************************************

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

}

}