- Upload a zip file, including PlayingCard.java and VideoPoker.java, - Implement
ID: 3838639 • 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;
import java.util.Arrays;
import java.util.Random;
open class rearrange {
/Make it simpler to discover exhibit things
static int esteem = 0;
static int suit = 1;
static int remaining = 2;
open static void main(String Args[]) {
int[][] deck;
String clabel;
/number of decks to create
int deckcount = 1;
int decksize = deckcount * 52;
deck = new int[decksize][2];
/circle through deck working until deck achieves card number
for (int c = 0; c < decksize;) {
for (int s = 0; s < 4; s++) {
for (int v = 1; v <= 13; v++) {
deck[c][value] = v;
deck[c][suit] = s;
System.out.println(getCard(deck[c]));
c++;
}
}
/test parameters for troubleshooting
/System.out.println(""+c);
/pressAnyKeyToContinue();
}
System.out.println(" SHUFFLING ");
int order[];
arrange = new int[decksize];
arrange = shuffle(decksize);
for(int i = 0;i < decksize;i++) {
System.out.println(getCard(deck[order[i]]));
}
}
/strategy to get cards amend name
open static String getCard(int[] card) {
String c_label, s_name = "", v_name = "";
/get suit name
switch (card[suit]) {
case 0:
s_name = "Clubs";
break;
case 1:
s_name = "Jewels";
break;
case 2:
s_name = "Hearts";
break;
case 3:
s_name = "Spades";
break;
}
/get card mark
on the off chance that (card[value] > 10 || card[value] == 1) {
switch (card[value]) {
case 1:
v_name = "Pro";
break;
case 11:
v_name = "Jack";
break;
case 12:
v_name = "Ruler";
break;
case 13:
v_name = "Ruler";
break;
}
} else {
v_name = "" + card[value];
}
c_label = v_name + " of " + s_name;
return c_label;
}
/rearrange deck
open static int[] shuffle(int measure) {
Irregular rgen = new Random();/Random number generator
int[] arrange;
arrange = new int[size];
for(int i = 0; i < order.length; i++) {
order[i] = i;
}
for (int i = 0; i < order.length; i++) {
int randomPosition = rgen.nextInt(order.length);
int temp = order[i];
order[i] = order[randomPosition];
order[randomPosition] = temp;
}
return arrange;
}
private static void pressAnyKeyToContinue() {
System.out.println("Press any key to continue...");
attempt {
System.in.read();
} get (Exception e) {}
}
}
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import javax.media.*;
open class MediaPlayerDemo expands JFrame
{
private player;
private File record;
open MediaPlayerDemo()
{
super( "Exhibiting the Java Media Player" );
JButton openFile = new JButton( "Open record to play" );
openFile.addActionListener( new ActionListener()
{
open void actionPerformed( ActionEvent e )
{
openFile();
createPlayer();
}
});
getContentPane().add( openFile, BorderLayout.NORTH );
setSize( 300, 300 );
appear();
}
private void openFile()
{
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode( JFileChooser.FILES_ONLY );
int result = fileChooser.showOpenDialog( this );
/client clicked Cancel catch on discourse
on the off chance that ( result == JFileChooser.CANCEL_OPTION )
record = invalid;
else
record = fileChooser.getSelectedFile();
}
private void createPlayer()
{
on the off chance that ( record == invalid )
return;
removePreviousPlayer();
attempt
{
/make another player and include audience
player = Manager.createPlayer( file.toURL() );
player.addControllerListener( new EventHandler() );
player.start();/begin player
}
get ( Exception e )
{
JOptionPane.showMessageDialog( this, "Invalid record or area", "Mistake stacking document",
JOptionPane.ERROR_MESSAGE );
}
}
private void removePreviousPlayer()
{
on the off chance that ( player == invalid )
return;
player.close();
Segment visual = player.getVisualComponent();
Segment control = player.getControlPanelComponent();
Holder c = getContentPane();
on the off chance that ( visual != invalid )
c.remove( visual );
on the off chance that ( control != invalid )
c.remove( control );
}
open static void main(String args[])
{
MediaPlayerDemo application = new MediaPlayerDemo();
app.addWindowListener( new WindowAdapter()
{
open void windowClosing( WindowEvent e )
{
System.exit(0);
}
});
}
/inward class to handler occasions from media player
private class EventHandler executes ControllerListener
{
open void controllerUpdate( ControllerEvent e )
{
on the off chance that ( e instanceof RealizeCompleteEvent )
{
Holder c = getContentPane();
/stack Visual and Control segments in the event that they exist
Part visualComponent = player.getVisualComponent();
in the event that ( visualComponent != invalid )
c.add( visualComponent, BorderLayout.CENTER );
Part controlsComponent = player.getControlPanelComponent();
in the event that ( controlsComponent != invalid )
c.add( controlsComponent, BorderLayout.SOUTH );
c.doLayout();
}
}
}
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.