Can someone help me code this please. CSC220 Programming Project#4 =============
ID: 3835474 • Letter: C
Question
Can someone help me code this please.
CSC220 Programming Project#4
============================
- 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 javafx.scene.image.*;
open class Card actualizes Comparable<Card>{
private static last String IMAGE_FOLDER_DIR = "picture";
private static last String IMAGE_FORMAT = ".png";
private static last String BACK_IMAGE_DIR = ("picture/back_image.png");
private Image cardImage;
private Image backImage;
private SuitEnum suit;
private RankEnum rank;
open Card(){
}
open Card(SuitEnum suit, RankEnum rank){
this.suit = suit;
this.rank = rank;
String area = generateImageLocation();
attempt {
cardImage = new Image(location);
} get (Exception ex) {
System.out.println(String.format("cannot stack picture from: (%s)", area));
cardImage = invalid;
}
attempt {
backImage = new Image(BACK_IMAGE_DIR);
} get (Exception ex){
System.out.println(String.format("cannot stack picture from: (%s)", BACK_IMAGE_DIR));
backImage = invalid;
}
}
open SuitEnum getSuit() {
return suit;
}
open RankEnum getRank() {
return rank;
}
open Image getCardImage(){
return cardImage;
}
private String generateImageLocation(){
StringBuilder sb = new StringBuilder();
sb.append(IMAGE_FOLDER_DIR);
sb.append("/");
sb.append(suit.toString());
sb.append("_");
sb.append(rank.toString());
sb.append(IMAGE_FORMAT);
return sb.toString().toLowerCase();
}
@Override
open String toString(){
return (suit + " + rank);
}
open int compareTo(Card card) {
on the off chance that (this.rank.compareTo(card.rank) > 0){
return 1;
} else if (this.rank.compareTo(card.rank) < 0){
return - 1;
} else {
if(this.suit.compareTo(card.suit) > 0){
return 1;
} else if (this.suit.compareTo(card.suit) < 0){
return - 1;
} else {
return 0;
}
}
}
@Override
open int hashCode() {
last int prime = 31;
int result = 1;
result = prime * result + ((rank == invalid) ? 0 : rank.hashCode());
result = prime * result + ((suit == invalid) ? 0 : suit.hashCode());
return result;
}
@Override
open boolean equals(Object obj) {
in the event that (this == obj)
return genuine;
in the event that (obj == invalid)
return false;
in the event that (getClass() != obj.getClass())
return false;
Card other = (Card) obj;
in the event that (rank != other.rank)
return false;
in the event that (suit != other.suit)
return false;
return genuine;
}
open Image getBackImage() {
return backImage;
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.