- Upload a zip file, including PlayingCard.java and VideoPoker.java, - Implement
ID: 3838550 • Letter: #
Question
- 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
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<Card> 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;
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]+" | "+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<Card>();
// 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<Card> originalDecks;
/* this starts with copying cards from originalDecks */
/* it is used to play the card game */
/* see reset(): resets gameDecks to originalDecks */
private List<Card> 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<Card> 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(" "+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(" "+decks);
try {
System.out.println(" Hand "+i+":"+cardsPerHand+" cards");
System.out.println(" "+decks.deal(cardsPerHand));
System.out.println(" Remain:"+decks.remainSize()+" cards");
System.out.println(" "+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();
}
}
Explanation / Answer
import java.util.Scanner;
public class PokerPokerGame {
public PokerPokerPokerGame{
}
public void check(Card[] h) {
if (isRoyalFlush(h)) {
System.out.println("YOU GOT A ROYAL FLUSH!!!!");
return;
} else if (isStraightFlush(h)) {
System.out.println("YOU GOT A STRAIGHT FLUSH!!");
return;
} else if (isFourOfaKind(h)) {
System.out.println("YOU GOT A FOUR OF A KIND!");
return;
} else if (isFullHouse(h)) {
System.out.println("You got a Full House!!!");
return;
} else if (isFlush(h)) {
System.out.println("You got a flush!!");
return;
} else if (isStraight(h)) {
System.out.println("You got a straight!");
return;
} else if (isThreeOfaKind(h)) {
System.out.println("You got a three of a kind!");
return;
} else if (isTwoPair(h)) {
System.out.println("You got a Two Pair.");
return;
} else if (isPair(h)) {
System.out.println("You got a pair.");
return;
} else {
// Makes sure that there if an Ace in your hand, it is considered
// the high card not low card
if (h[0].getValue() == 0)
System.out.println("You only got a high card: "
+ h[0].toString());
else
System.out.println("You only got a high card: "
+ h[4].toString());
}
}
private boolean isRoyalFlush(Card[] h) {
boolean royalFlush = false;
if (isStraight(h) && isFlush(h) && h[1].getValue() == 9)
royalFlush = true;
return royalFlush;
}
// method to check if hand is a straight flush (hand is a straight, a flush,
// and NOT a royal flush)
private boolean isStraightFlush(Card[] h) {
boolean straightFlush = false;
if (isStraight(h) && isFlush(h) && !(h[1].getValue() == 10))
straightFlush = true;
return straightFlush;
}
private boolean isFourOfaKind(Card[] h) {
boolean fourOfaKind = false;
Card[] hand;
hand = h;
// since my hand is in order, the middle card MUST be one of the four
int commonValue = hand[2].getValue();
int counter = 0;
for (int i = 0; i < 5; i++) {
if (hand[i].getValue() == commonValue)
counter++;
}
if (counter == 4)
fourOfaKind = true;
return fourOfaKind;
}
private boolean isFullHouse(Card[] h) {
boolean fullHouse = false;
Card[] hand = h;
if (isThreeOfaKind(hand) && isPair(hand))
fullHouse = true;
return fullHouse;
}
private boolean isFlush(Card[] h) {
boolean flush = false;
Card[] hand;
hand = h;
int commonSuit = hand[0].getSuit();
int counter = 0;
// for loop to count number of repeat suits (needs to be 5)
for (int i = 0; i < 5; i++) {
if (hand[i].getSuit() == commonSuit)
counter++;
}
if (counter == 5)
flush = true;
return flush;
}
// method to check if hand is a straight
private boolean isStraight(Card[] h) {
boolean straight = false;
Card[] hand;
hand = h;
int startValue = hand[0].getValue();
)
if (hand[0].getValue() == 0 && hand[1].getValue() == 9
&& hand[2].getValue() == 10 && hand[3].getValue() == 11
&& hand[4].getValue() == 12) {
straight = true;
return straight;
} else {
for (int i = 1; i < 5; i++) {
if (hand[i].getValue() == startValue + i)
straight = true;
else {
straight = false;
return straight;
}
}
}
return straight;
}
private boolean isThreeOfaKind(Card[] h) {
boolean threeOfaKind = false;
Card[] hand = h;
// since hand is in order, middle card MUST be one of the 3
int commonValue = hand[2].getValue();
int counter = 0;
for (int i = 0; i < 5; i++) {
if (hand[i].getValue() == commonValue)
counter++;
}
if (counter == 3)
threeOfaKind = true;
return threeOfaKind;
}
private boolean isTwoPair(Card[] h) {
boolean twoPair = false;
Card[] hand = h;
int counter = 0;
for (int i = 0; i < 4; i++) {
if (hand[i].getValue() == hand[i + 1].getValue())
counter++;
}
if (counter == 2)
twoPair = true;
return twoPair;
}
private boolean isPair(Card[] h) {
boolean pair = false;
Card[] hand = h;
int pairCounter = 0;
for (int i = 0; i < 4; i++) {
if (hand[i].getValue() == hand[i + 1].getValue())
pairCounter++;
}
if (!(pairCounter == 0 || pairCounter == 2))
pair = true;
return pair;
}
public void play() {
String repeat = "y";
Scanner input = new Scanner(System.in);
while (repeat.equals("y")) {
Deck PokerPokerGameDeck = new Deck();
Player user = new Player(PokerPokerGameDeck);
PokerPokerGameDeck.shuffle();
user.dealHand();
user.sayHand();
user.play();
user.sayHand();
check(user.getHand());// checks and prints results
System.out
.println(" Would you like to play again? (y-yes/n-no)");
do {
repeat = input.next();
if (!(repeat.equals("y") || repeat.equals("n")))
System.out
.println("That is an invalid response (y-yes/n-no)");
} while (!(repeat.equals("y") || repeat.equals("n")));
}
}
}
import java.util.Scanner;
import java.util.Arrays;
public class PokerPlayer{
private Card[] hand;
private Scanner input;
private Deck playersDeck;
public Player(Deck d) {
hand = new Card[5];
playersDeck = d;
input = new Scanner(System.in);
}
public void dealHand() {
for (int i = 0; i < 5; i++) {
hand[i] = playersDeck.getTop();
}
}
public void sayHand() {
System.out.println("Here is your hand: ");
System.out.println("");
sort();
for (int i = 1; i < 6; i++) {
System.out.println(i + ": " + hand[i - 1]);
}
}
private void sort() {
Card[] temp = new Card[5];
for (int i = 0; i < 5; i++)
temp[i] = hand[i];
Arrays.sort(temp);
for (int i = 0; i < 5; i++)
hand[i] = temp[i];
}
private boolean containsCharacters(String n) {
boolean isCharacter = false;
String temp;
for (int i = 0; i < n.length(); i++) {
temp = n.substring(i, i + 1);
if (!Character.isDigit(n.charAt(i)))
isCharacter = true;
if (temp.equals("6") || temp.equals("7") || temp.equals("8")
|| temp.equals("9") || temp.equals("0"))
isCharacter = true;
}
return isCharacter;
}
private boolean hasDuplicates(String check) {
int counter = 0;
String temp;
String compare;
.
for (int i = 0; i < check.length(); i++) {
temp = check.substring(i, i + 1);
for (int j = 0; j < check.length(); j++) {
compare = check.substring(j, j + 1);
if (temp.equals(compare)) {
counter++;
}
}
}
if (counter == check.length())
return false;
else
return true;
}
public void play() {
int[] positionsList;
String exchange = "";
System.out.println("");
int error = 0;
System.out.println("Please enter the position of the cards to be" +
" Do not put spaces in between numbers. For " +
"example, if you would like to exchange the " + hand[1] +
" and " + hand[3] + " enter 24. If you don't want to " +
"exchange any cards," + " just press enter");
while (error == 0) {
exchange = input.nextLine();
if (containsCharacters(exchange))
System.out
.println("Please do enter any characters, spaces, or invalid numbers. Only enter numbers 1-5");
else if (hasDuplicates(exchange))
System.out
.println("You cannot exchange a number more than once");
else
error++;
}
positionsList = new int[exchange.length()];
for (int i = 0; i < exchange.length(); i++) {
positionsList[i] = Integer.parseInt(exchange.substring(i, i + 1));
}
for (int i = 0; i < positionsList.length; i++) {
hand[positionsList[i] - 1] = playersDeck.getTop();
}
}
public Card[] getHand() {
return hand;
}
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.