Java Write a game of 5 card stud, where you play against the computer. The compu
ID: 3694926 • Letter: J
Question
Java
Write a game of 5 card stud, where you play against the computer. The computer will be the dealer.
Guide
5 Card Stud Final Project
Description of the Game
The computer will always be the dealer, and will always match all bets by the player. The dealer will start out with 5 times as much money as the player
(Remember, the house always wins, so they can afford it)
The player will put money on the table to enter the game (an initial bet), called the ante.
Both players are dealt 1 card face down, then one card face up.
Loop until each player has 5 cards – each round gives both players 1 card
Each player can bet, check (a bet of 0), or fold (give up this game)
Once all bets have been made, another card is dealt face up to all players
Once all players have 5 cards, a final bet is made, or the player can fold
All players show all cards
The player with the best hand wins the pot
The dealer collects all cards and shuffles the deck, and another hand is played until the player chooses to quit or one of the two players is out of money.
If a player folds, the dealer wins the pot automatically. For simplicity, our dealer (the computer) will never fold, and will match all bets from the player.
Object Design
Your client class will use five different objects, which you will have to create (listed above)
You will present a welcome message and a description to the user
Ask the user for their name and other information to create the Player object
Start the loop to control the game
Create a dealer (this will make a new deck of cards for each hand)
Create a table
Add the player and the dealer to the table
Call table.play()
Ask if the player wants to play again, or quit if they are out of money
Print a thanks for playing message
Your Card class
value: Represents a point value of the card
Note: Aces can be a low or high card in poker
suit: Represents one of the four card suits in a standard 52 card deck. This will be done with an Enumeration.
visible: A Boolean. Used to show or hide the first card dealt.
name: A String, and will be either the number of the card (i.e. 3 or 10), or the actual name if it is a face card (i.e. Queen or Ace)
show() and hide(): change the visible Boolean
toString(): Represent the card. It should output the name and suit of the card, like this: 3 of Spades, or Queen of Hearts, or Hidden Card if visible == false
compareTo(): compare cards to each other based on their value
Your Deck class
cards: An ArrayList of Cards, with all 52 cards put in the list when the deck is created
shuffle(): A method to shuffle the ArrayList (use Collections.shuffle), call this as part of the constructor
deal(): A method to remove a Card from the deck and return it
Your Player class
name: a String that holds the player’s name, or the word Dealer
stash: an Int that holds the money the player can bet with. It must be a positive number
hand: an ArrayList of cards that have been dealt to the player
bet(): Get the bet for this round from the player. Return the Int of the bet, or -1 if the bet is invalid (they bet more than they have, or bet a – number)
fold(): Give up this hand before the hand is done being dealt
scoreHand(): Return an Integer with a score based on the hand – use this for a guide http://www.mathcs.emory.edu/~cheung/Courses/170/Syllabus/10/pokerCheck.html
See https://en.wikipedia.org/wiki/List_of_poker_hands
toString(): Return a String showing the player’s name and the cards in their hand, along with their stash of money
Your Dealer object
Inherits from Player
deck: A deck of cards
dealToPlayer(Player player): A method to get a card from the deck and put it in the player’s hand
Your Table object
Pot: An Int that holds the bets from both players for each hand. Will initially be 0
Players: A two element array of Player objects. One is the dealer, and the other is the player
declareWinner(): A method to use each player’s scoreHand() results to pick a winner. See UML diagram above and https://en.wikipedia.org/wiki/List_of_poker_hands
show(): A method to show all cards face up on the table. Used after the last bet
getBets(): A method to ask the player for a bet, and if valid, get the same bet from the dealer
play(): A method to actually play the game – see pseudo code in description above
Explanation / Answer
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class poker2 extends JFrame {
private Card deck[]; //this is an array of objects of Card type. See the Card class at the end
private int currentCard; //this keeps track of the number of cards dealt
private JButton dealButton, shuffleButton, testButtton; //GUI stuff, the two buttons
private JTextField displayField; //GUI stuff, the textfield that displays the card dealt
private JLabel statusLabel; //GUI stuff, Displays the number of cards dealt
private JLabel cardback, card1, card2,card3,card4,card5,card6,card7,card8,card9,card10;//GUI stuff The labels that displays the cards
private JTextField hand1TF, hand2TF;
Card dealt; //this is an object of Card type for a dealt card
Icon card = new ImageIcon(".\cards\back2.GIF"); //this is the cardback graphics file
Card hand1[];
Card hand2[];
int handNums[];
int test;
// set up deck of cards and GUI
public poker2()
{
super( "5-Card Stud" ); //Title
String faces[] = { "Ace", "Deuce", "Three", "Four", "Five", "Six",
"Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };
String suits[] = { "Hearts", "Diamonds", "Clubs", "Spades" };
deck = new Card[ 52 ];
hand1 = new Card[5];
hand2 = new Card[5];
handNums = new int[13]; //creates array to hold 52 cards
currentCard = -1;
test = 4;
// populate deck with Card objects
for ( int count = 0; count < deck.length; count++ )
deck[ count ] = new Card( faces[ count % 13 ],suits[ count / 13 ] );
// set up GUI and event handling
Container container = getContentPane();
container.setLayout( new FlowLayout() );
//Diplay the cardbacks
card1 = new JLabel();
card1.setIcon(card);
container.add( card1 );
card3 = new JLabel();
card3.setIcon(card);
container.add( card3 );
card5 = new JLabel();
card5.setIcon(card);
container.add( card5 );
card7 = new JLabel();
card7.setIcon(card);
container.add( card7 );
card9 = new JLabel();
card9.setIcon(card);
container.add( card9 );
hand1TF = new JTextField(32);
hand1TF.setEditable( false );
hand1TF.setText( "Here it Is" );
container.add( hand1TF );
card2 = new JLabel();
card2.setIcon(card);
container.add( card2 );
card4 = new JLabel();
card4.setIcon(card);
container.add( card4 );
card6 = new JLabel();
card6.setIcon(card);
container.add( card6 );
card8 = new JLabel();
card8.setIcon(card);
container.add( card8 );
card10 = new JLabel();
card10.setIcon(card);
container.add( card10 );
hand2TF = new JTextField(32);
hand2TF.setEditable( false );
hand2TF.setText( "Here Theirs Are" );
container.add( hand2TF );
// Initialize the "Deal Button"
dealButton = new JButton( "DEAL 'EM" );
dealButton.addActionListener(
new ActionListener() { // anonymous inner class
// deal a card. This listens for the "Deal CArd" button to be clicked
public void actionPerformed( ActionEvent actionEvent )
{
dealt = dealCard();
if ( dealt != null ) {
displayField.setText( dealt.viewcard() );
showcard(currentCard);
statusLabel.setText( "Card #: " + (currentCard + 1) );
}
else {
displayField.setText( "NO MORE CARDS TO DEAL" );
statusLabel.setText( "Shuffle cards to continue" );
}
//This is the right spot1 ???
int i;
i = 0;
if(currentCard % 2 == 0)
{hand2 = dealt;
i++;}
else
hand1[currentCard / 2] = dealt;
}
} // end anonymous inner class
); // end call to addActionListener
container.add( dealButton ); //this adds the button to the GUI
dealButton.setEnabled(false); //this disables the button. Don't deal a card until the deck is shuffled
//initialize the "Shuffle Deck" button
shuffleButton = new JButton( "Shuffle cards" );
shuffleButton.addActionListener(
new ActionListener() { // anonymous inner class
// shuffle deck. This listens for the "Shuffle cards" button to be clicked
public void actionPerformed( ActionEvent actionEvent )
{
displayField.setText( "SHUFFLING ..." );
shuffle();
displayField.setText( "DECK IS SHUFFLED" );
//reset the card graphics to the back every shuffle
card = new ImageIcon(".\cards\back2.GIF");
card1.setIcon(card);
card2.setIcon(card);
card3.setIcon(card);
card4.setIcon(card);
card5.setIcon(card);
card6.setIcon(card);
card7.setIcon(card);
card8.setIcon(card);
card9.setIcon(card);
card10.setIcon(card);
dealButton.setEnabled(true); //enable the dealbutton after every shuffle
}
private void evalHand()
{
int i;
for(i = 0; i < hand1.length;i++)
{
if(hand1.face.equals("Ace"))
handNums[0]++;
}
}
} // end anonymous inner class
); // end call to addActionListener
container.add( shuffleButton );
displayField = new JTextField( 20 );
displayField.setEditable( false );
container.add( displayField );
statusLabel = new JLabel();
container.add( statusLabel );
setSize( 400, 400 ); // set window size
setVisible( true ); // show window
setResizable(false);
}
// shuffle deck of cards with one-pass algorithm
private void shuffle()
{
currentCard = -1;
// for each card, pick another random card and swap them
for ( int first = 0; first < deck.length; first++ ) {
int second = ( int ) ( Math.random() * 52 );
Card temp = deck[ first ];
deck[ first ] = deck[ second ];
deck[ second ] = temp;
}
//dealButton.setEnabled( true );
}
// deal one card
private Card dealCard()
{
if ( ++currentCard < deck.length )
return deck[ currentCard ];
else {
dealButton.setEnabled( false );
return null;
}
}
// c is the currentcard, just check for the card value and suit and display the appropriate graphics file
private void showcard(int c)
{
// CASES 0,2,4,6,8 Are your Cards
// CASES 1,3,5,7,9 are your opponents cards
card = new ImageIcon(getCard(dealt));
switch (c)
{
case 0: card1.setIcon(card); break;
case 1: card2.setIcon(card); break;
case 2: card3.setIcon(card); break;
case 3: card4.setIcon(card); break;
case 4: card5.setIcon(card); break;
case 5: card6.setIcon(card); break;
case 6: card7.setIcon(card); break;
case 7: card8.setIcon(card); break;
case 8: card9.setIcon(card); break;
case 9: card10.setIcon(card);
dealButton.setEnabled(false);
break;
}//end card switch
}//end showcard
private String getCard(Card myCard)
{
String str_return = ".\cards\";
// Suits Thingy
if (myCard.suit.equals("Hearts")) str_return += "H";
if (myCard.suit.equals("Diamonds")) str_return += "D";
if (myCard.suit.equals("Clubs")) str_return += "C";
if (myCard.suit.equals("Spades")) str_return += "S";
// Face Thingy
if (myCard.face.equals("Ace")) str_return += "14";
if (myCard.face.equals("Deuce")) str_return += "2";
if (myCard.face.equals("Three")) str_return += "3";
if (myCard.face.equals("Four")) str_return += "4";
if (myCard.face.equals("Five")) str_return += "5";
if (myCard.face.equals("Six")) str_return += "6";
if (myCard.face.equals("Seven")) str_return += "7";
if (myCard.face.equals("Eight")) str_return += "8";
if (myCard.face.equals("Nine")) str_return += "9";
if (myCard.face.equals("Ten")) str_return += "10";
if (myCard.face.equals("Jack")) str_return += "11";
if (myCard.face.equals("Queen")) str_return += "12";
if (myCard.face.equals("King")) str_return += "13";
return (str_return += ".gif");
}//end getCard
// execute application
public static void main( String args[] )
{
poker application = new poker();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
} // end class poker
// class to represent a card
class Card {
public String face;
public String suit;
// constructor to initialize a card
public Card( String cardFace, String cardSuit )
{
face = cardFace;
suit = cardSuit;
}
// return String represenation of Card
public String viewcard()
{
return face + " of " + suit;
}//end viewcard
} // end class Card
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.