diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..7789b7b7
Binary files /dev/null and b/.DS_Store differ
diff --git a/CR-MacroLabs-OOP-Casino b/CR-MacroLabs-OOP-Casino
new file mode 160000
index 00000000..fc480e97
--- /dev/null
+++ b/CR-MacroLabs-OOP-Casino
@@ -0,0 +1 @@
+Subproject commit fc480e97103f17bf914ea86ad0c6d989e2f97637
diff --git a/GreatestCasinoUML.jpg b/GreatestCasinoUML.jpg
new file mode 100644
index 00000000..0167bf5a
Binary files /dev/null and b/GreatestCasinoUML.jpg differ
diff --git a/pom.xml b/pom.xml
index c6ec0cc8..27223bde 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,5 +15,22 @@
4.12
test
+
+ org.apache.commons
+ commons-lang3
+ 3.7
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+ 1.8
+ 1.8
+
+
+
+
diff --git a/src/.DS_Store b/src/.DS_Store
new file mode 100644
index 00000000..09db0919
Binary files /dev/null and b/src/.DS_Store differ
diff --git a/src/main/.DS_Store b/src/main/.DS_Store
new file mode 100644
index 00000000..b6412615
Binary files /dev/null and b/src/main/.DS_Store differ
diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store
new file mode 100644
index 00000000..e2b359fe
Binary files /dev/null and b/src/main/java/.DS_Store differ
diff --git a/src/main/java/io/.DS_Store b/src/main/java/io/.DS_Store
new file mode 100644
index 00000000..50c537b0
Binary files /dev/null and b/src/main/java/io/.DS_Store differ
diff --git a/src/main/java/io/zipcoder/.DS_Store b/src/main/java/io/zipcoder/.DS_Store
new file mode 100644
index 00000000..5e0c5b36
Binary files /dev/null and b/src/main/java/io/zipcoder/.DS_Store differ
diff --git a/src/main/java/io/zipcoder/casino/Blackjack.java b/src/main/java/io/zipcoder/casino/Blackjack.java
new file mode 100644
index 00000000..9fc8292b
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Blackjack.java
@@ -0,0 +1,356 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class Blackjack extends Game implements GameInterface, CardGameInterface, GamblingInterface {
+
+ private Person player;
+ private Hand playerHand;
+ private Wallet playerWallet;
+ private int playerChips;
+
+ private Dealer dealer;
+ private Hand dealerHand;
+ private Wallet dealerWallet;
+
+ private Deck deck;
+
+ // these 2 args are now in Person constructor for gambling games
+ public Blackjack(Person player) {
+ this.player = player;
+ this.playerHand = player.getHand();
+ this.playerWallet = player.getWallet();
+ //playerWallet.addChipsToAmount(chipsToStart); // add chipsToStart is now in Person constructor for gambl games
+ this.playerChips = playerWallet.checkChipAmount();
+
+ this.dealer = new Dealer();
+ this.dealerHand = dealer.getHand();
+ this.dealerWallet = dealer.getDealerWallet();
+
+ this.deck = new Deck();
+ }
+
+ // can have another constructor that takes a number int of Persons, and places those Persons
+ // into an array of players and one dealer.
+
+ public Person getPlayer() {
+ return player;
+ }
+
+ public Dealer getDealer() {
+ return dealer;
+ }
+
+ public Deck getDeck() {
+ return deck;
+ }
+
+ public int sumOfRanksInHand(Person person) {
+ int sumOfRanksInHand = 0;
+ Card aceRank = new Card(Rank.ACE, Suit.CLUBS);
+ int numberOfAceRankRepetitions = countRankRepetitionsInHand(person, aceRank);
+
+ // If there are 2 or more Aces in handArrayList, treat all Aces as = 1
+ if (numberOfAceRankRepetitions != 1) {
+ for (Card card : person.getHand().getHandArrayList()) {
+ if (card.getRank().toInt() == 11 || card.getRank().toInt() == 12
+ || card.getRank().toInt() == 13) {
+ sumOfRanksInHand += 10;
+ } else {
+ sumOfRanksInHand += card.getRank().toInt();
+ }
+ }
+ } else { // implement Ace = 1 or Ace = 11 sumOfRanksInHand/difference/choice
+ int sumWhenAceEqualsOne = 0;
+ int sumWhenAceEqualsEleven = 0;
+ for (Card card : person.getHand().getHandArrayList()) {
+ if (card.getRank().toInt() == 11 || card.getRank().toInt() == 12
+ || card.getRank().toInt() == 13) {
+ sumWhenAceEqualsOne += 10;
+ sumWhenAceEqualsEleven += 10;
+ } else if (card.getRank().toInt() == 1) {
+ sumWhenAceEqualsOne += 1;
+ sumWhenAceEqualsEleven += 11;
+ } else {
+ sumWhenAceEqualsOne += card.getRank().toInt();
+ sumWhenAceEqualsEleven += card.getRank().toInt();
+ }
+ }
+ if ( (sumWhenAceEqualsOne <= 21) && (sumWhenAceEqualsEleven <= 21) ) {
+ int greaterOfTwoAceSums = findGreaterOfTwoInts(sumWhenAceEqualsOne, sumWhenAceEqualsEleven);
+ sumOfRanksInHand = greaterOfTwoAceSums;
+ } else {
+ int smallerOfTwoAceSums = findSmallerOfTwoInts(sumWhenAceEqualsOne, sumWhenAceEqualsEleven);
+ sumOfRanksInHand = smallerOfTwoAceSums;
+ }
+ }
+
+ return sumOfRanksInHand;
+ }
+
+ public int countRankRepetitionsInHand(Person person, Card cardRankToCount) {
+ int numberOfRankRepetitions = 0;
+ for (Card card : person.getHand().getHandArrayList()) {
+ if (card.getRank().toInt() == cardRankToCount.getRank().toInt()) {
+ numberOfRankRepetitions++;
+ }
+ }
+ return numberOfRankRepetitions;
+ }
+
+ public int findSmallerOfTwoInts(int number1, int number2) {
+ if (number1 <= number2) {
+ return number1;
+ } else {
+ return number2;
+ }
+ }
+
+ public int findGreaterOfTwoInts(int number1, int number2) {
+ if (number1 >= number2) {
+ return number1;
+ } else {
+ return number2;
+ }
+ }
+
+ public void personDecision(Person person) {
+ Scanner scanner = new Scanner(System.in);
+ String playerDecisionString = scanner.nextLine();
+
+ if (playerDecisionString.equals("hit")) {
+ this.hit(person);
+ }
+ }
+
+ public String handToString(ArrayList handArrayList) {
+ StringBuilder sb = new StringBuilder();
+ for (Card card : handArrayList) {
+ sb.append(card.toString() + " ");
+ }
+ sb.deleteCharAt(sb.length()-1);
+ return sb.toString();
+ }
+
+ public void hit(Person person) {
+ Card cardFromDealer = this.getDeck().drawCard();
+ person.getHand().receiveCards(cardFromDealer);
+ }
+
+ // CardGameInterface
+ public int checkNumberOfCards() {
+ return 0;
+ }
+
+ @Override
+ public int checkNumberOfCards(Hand hand) {
+ return 0;
+ }
+
+ // CardGameInterface
+ public void dealCards() {
+
+ }
+
+ // GamblingInterface
+ public int checkChipAmount(Person personToCheck) {
+ return 0;
+ }
+
+ // GamblingInterface
+ public void placeBet(Person personPlacingBet, int betAmount) {
+ personPlacingBet.getWallet().removeChipsFromAmount(betAmount);
+ }
+
+ // GamblingInterface
+ public int getAnte() {
+ return 0;
+ }
+
+ // GamblingInterface
+ public void bootPlayerFromGame(Person personToBoot) {
+
+ }
+
+ // GamblingInterface
+ public int checkPot() {
+ return 0;
+ }
+
+// public String askForPlayerName() {
+// return "nameTest";
+// }
+
+ // GameInterface or Game Class
+ public void start() {
+ this.getDeck().shuffleDeck();
+ Scanner scanner = new Scanner(System.in);
+
+ if (this.getPlayer().getWallet().checkChipAmount() <= 0) {
+ System.out.println("You don't have anymore chips to play");
+ return; // THIS EXITS THE METHOD
+ }
+
+ // Check bet > 0
+ int betPlaced = 0;
+ do {
+ System.out.println("How many chips do you want to bet?");
+ String inputString = scanner.nextLine(); // changed to nextLine to fix next loop
+ try {
+ betPlaced = Integer.parseInt(inputString);
+ if (betPlaced <= 0) {
+ System.out.println("Your bet must be a number greater than zero.");
+ System.out.println();
+ continue;
+ }
+ else if (betPlaced <= this.getPlayer().getWallet().checkChipAmount()) {
+ this.placeBet(this.getPlayer(), betPlaced);
+ break;
+ } else {
+ System.out.println("You only have " + this.getPlayer().getWallet().checkChipAmount() + " chip(s)");
+ System.out.println();
+ }
+ } catch (NumberFormatException ne) {
+ System.out.println("Please try again.");
+ System.out.println();
+ }
+ } while (true);
+
+ this.hit(this.getPlayer());
+ this.hit(this.getPlayer());
+ this.hit(this.getDealer());
+ this.hit(this.getDealer());
+
+ int personHandSum = 0;
+ int dealerHandSum = 0;
+
+ String myHand = "";
+ String dealerHand = "";
+ String playerDecisionString = "";
+
+ System.out.println();
+ System.out.println("+++ PLAY BLACKJACK +++");
+ do {
+ personHandSum = this.sumOfRanksInHand(this.getPlayer());
+ System.out.println();
+ System.out.print(this.getPlayer().getName() + ": " + "\u270B");
+ System.out.print(this.handToString(this.getPlayer().getHand().getHandArrayList()));
+ System.out.print("\u270B" + ", hand = " + personHandSum);
+
+ System.out.println();
+ String dealerCardShown = this.getDealer().getHand().getHandArrayList().get(1).toString();
+ System.out.print("Dealer: " + "\u270B" + "\uD83C\uDCA0" + " " + dealerCardShown + "\u270B");
+
+ if (personHandSum == 21) {
+ System.out.println();
+ System.out.println("++++++++++++++++++++++++++++++++");
+ System.out.println("BLACKJACK!+++ You won " + betPlaced + " chip(s)");
+ System.out.println("++++++++++++++++++++++++++++++++");
+ this.getPlayer().getWallet().addChipsToAmount(2 * betPlaced);
+ break;
+ } else if (personHandSum > 21){
+ System.out.println();
+ System.out.println("+++++++++++++++++++++");
+ System.out.println("BUST! You lost " + betPlaced + " chip(s)");
+ System.out.println("+++++++++++++++++++++");
+ break;
+ }
+
+ // get new deck if card number falls <= 16
+ if (this.getDeck().getDeckOfCards().size() <= 16) {
+ this.deck = new Deck();
+ getDeck().shuffleDeck();
+ }
+
+ System.out.println();
+ System.out.println("Do you want to \"hit\" or \"stay\"?: ");
+ playerDecisionString = scanner.nextLine();
+
+ if (playerDecisionString.equals("hit")) {
+ this.hit(this.getPlayer());
+ } else if (playerDecisionString.equals("stay")) {
+ break;
+ }
+ } while (personHandSum < 21);
+
+ dealerHandSum = this.sumOfRanksInHand(this.getDealer());
+ if ( !(personHandSum >= 21) ) { // If player stayed with a hand < 21
+ if (dealerHandSum <= 16) { // If dealer's hand >= 17, dealer has to stay
+ this.hit(dealer); // Hit dealer only once if dealer's hand <= 16
+ }
+ }
+
+ dealerHandSum = this.sumOfRanksInHand(this.getDealer());
+ if (playerDecisionString.equals("stay")) {
+ if ( (dealerHandSum <= 21) && (dealerHandSum > personHandSum) ) {
+ System.out.println("++++++++++++++++++++++++");
+ System.out.println("Dealer wins!");
+ System.out.println("You lost " + betPlaced + " chip(s)");
+ System.out.println("++++++++++++++++++++++++");
+ } else if ( (dealerHandSum <= 21) && (dealerHandSum == personHandSum) ) {
+ System.out.println("++++++++++++++++++++++++");
+ System.out.println("It's a tie!");
+ System.out.println("You keep your " + betPlaced + " chip(s)");
+ System.out.println("++++++++++++++++++++++++");
+ this.getPlayer().getWallet().addChipsToAmount(betPlaced);
+ } else {
+ System.out.println("+++++++++++++++++++++++++");
+ System.out.println(this.getPlayer().getName() + " wins!");
+ System.out.println("You won " + betPlaced + " chip(s)");
+ System.out.println("+++++++++++++++++++++++++");
+ this.getPlayer().getWallet().addChipsToAmount(2 * betPlaced); }
+ }
+
+ System.out.println();
+ System.out.println("FINAL SCORE:");
+ personHandSum = this.sumOfRanksInHand(this.getPlayer());
+ System.out.print(this.getPlayer().getName() + ": " + "\u270B");
+ System.out.print(this.handToString(this.getPlayer().getHand().getHandArrayList()));
+ System.out.print("\u270B" + ", hand = " + personHandSum);
+
+ dealerHandSum = this.sumOfRanksInHand(this.getDealer());
+ System.out.println();
+ System.out.print("Dealer: " + "\u270B");
+ System.out.print(this.handToString(this.getDealer().getHand().getHandArrayList()));
+ System.out.print("\u270B" + ", hand = " + dealerHandSum);
+ System.out.println();
+ System.out.println();
+ System.out.print(this.getPlayer().getName() + " has ");
+ System.out.println(this.getPlayer().getWallet().checkChipAmount() + " chip(s)");
+
+ System.out.println();
+ this.doYouWantToContinuePlaying();
+ System.out.println();
+ }
+
+ public void doYouWantToContinuePlaying() {
+ Scanner scanner = new Scanner(System.in);
+ String test = "";
+ do {
+ System.out.println("Keep playing? (yes/no) ");
+ test = scanner.nextLine();
+ if (test.equals("yes")) {
+ this.getPlayer().getHand().clearHand();
+ this.getDealer().getHand().clearHand();
+ this.start();
+ break;
+ } if (test.equals("no")) {
+ break;
+ }
+ } while(true);
+ }
+
+ // Game Class
+ public void end() {
+ System.out.print("Thank you for playing");
+ System.out.println();
+ }
+
+// public static void main (String[] args) {
+// Blackjack blackjack = new Blackjack("Anyname", 10);
+// blackjack.start();
+// blackjack.end();
+// }
+}
diff --git a/src/main/java/io/zipcoder/casino/Card.java b/src/main/java/io/zipcoder/casino/Card.java
new file mode 100644
index 00000000..9aacb8bb
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Card.java
@@ -0,0 +1,29 @@
+package io.zipcoder.casino;
+
+public class Card {
+
+ private final Rank rank;
+ private final Suit suit;
+
+ public Card(Rank rank, Suit suit) {
+ this.rank = rank;
+ this.suit = suit;
+ }
+
+ public Rank getRank() {
+ return rank;
+ }
+
+ public Suit getSuit() {
+ return suit;
+ }
+
+ // Modified toString on Sat Feb 24 to: rank + "" + suit;
+// public String toString() {
+// return rank + " of " + suit;
+// }
+ public String toString() {
+ return rank + "" + suit;
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/CardGameInterface.java b/src/main/java/io/zipcoder/casino/CardGameInterface.java
new file mode 100644
index 00000000..fa99b548
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/CardGameInterface.java
@@ -0,0 +1,12 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+
+public interface CardGameInterface {
+
+ ArrayList deck = new ArrayList();
+
+ int checkNumberOfCards(Hand hand);
+
+ void dealCards();
+}
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java
index 74dfdd8c..9f4e8f91 100644
--- a/src/main/java/io/zipcoder/casino/Casino.java
+++ b/src/main/java/io/zipcoder/casino/Casino.java
@@ -1,5 +1,48 @@
package io.zipcoder.casino;
+import java.util.Scanner;
+
+import static io.zipcoder.casino.Person.createNewPlayerFromUserInput;
+
+
public class Casino {
+ //both methods call methods that have Scanner and Wilhelm said you can't do tests on methods with Scanner
+
+ //createNewPlayer creates a new player based on user input of their name
+ //fillPlayerWallet fills the new player's wallet with chips based on user's input
+ public static Person newPlayer() {
+ Person player = createNewPlayerFromUserInput();
+ player.getWallet().fillPlayerWalletFromUserInput();
+ return player;
+ }
+
+ //first call newPlayer, then use the Person it returns as the parameter
+ public static void sendPlayerToGame(Person player) {
+ MainMenu menu = new MainMenu();
+ boolean exitCasino = true;
+ do {
+
+
+ String choice = menu.displayGameChoices();
+ Game myGame = MainMenu.chooseGame(choice, player);
+ myGame.start();
+ exitCasino = exitCasino();
+ }while (exitCasino);
+ }
+
+ private static boolean exitCasino() {
+ Scanner userInput = new Scanner(System.in);
+ String userChoice;
+ do {
+ System.out.println("Would you like to play a different game? Yes or no.");
+ userChoice = userInput.nextLine().toLowerCase();
+ } while (!(userChoice.equals("yes")) && !(userChoice.equals("no")));
+ if (userChoice.equals("yes")) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
}
diff --git a/src/main/java/io/zipcoder/casino/Coin.java b/src/main/java/io/zipcoder/casino/Coin.java
new file mode 100644
index 00000000..55427e3f
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Coin.java
@@ -0,0 +1,22 @@
+package io.zipcoder.casino;
+
+import java.util.Random;
+
+public class Coin {
+
+ Random random = new Random();
+
+ public String flip() {
+ int coinLogicInteger = coinLogic();
+ if (coinLogicInteger == 1) {
+ return "heads";
+ } else {
+ return "tails";
+ }
+ }
+
+ int coinLogic() {
+ return random.nextInt(2) + 1;
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/CoinFlipper.java b/src/main/java/io/zipcoder/casino/CoinFlipper.java
new file mode 100644
index 00000000..77da51ac
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/CoinFlipper.java
@@ -0,0 +1,69 @@
+package io.zipcoder.casino;
+
+import java.util.Scanner;
+
+public class CoinFlipper extends Game implements GameInterface{
+
+ private boolean gameIsRunning;
+ private Person player = new Person("Joe");
+ private Scanner input = new Scanner(System.in);
+ private Coin coin = new Coin();
+
+ public CoinFlipper(Person player) {
+ this.player = player;
+ // Un-note ^ this when added to main
+ }
+
+ public void start() {
+ gameIsRunning = true;
+ System.out.println("Welcome to Coin Flipper!");
+ System.out.println("In this simple game you can bet chips on a lucky coin.");
+ System.out.println("If it lands on heads, you get double your money! But if it lands on tails, you get nothing!");
+ System.out.println("If you're feeling lucky, enter how much you would like to bet and hit enter:");
+ engine();
+ }
+
+ public void engine() {
+ while (gameIsRunning == true) {
+ int thisRoundsBet = 0;
+ if (checkChipAmount(player) == 0) {bootPlayerFromGame();}
+ if (input.hasNextInt()) {
+ thisRoundsBet = input.nextInt();
+ placeBet(player, thisRoundsBet);
+ } else {
+ System.out.println("Invalid input! Bye-bye!");
+ end();
+ }
+ if (gameIsRunning) {
+ String coinFace = coin.flip();
+ if (coinFace.equals("heads")) {
+ int payout = thisRoundsBet * 2;
+ System.out.println("Heads! You win! Your payout: " + payout);
+ player.getWallet().addChipsToAmount(payout);
+ } else {
+ System.out.println("Tails! You lose!");
+ }
+ System.out.println("Enter another bet to play again, or enter anything else to quit");
+ }
+ }
+ }
+
+ public int checkChipAmount(Person personToCheck) {
+ return personToCheck.getWallet().checkChipAmount();
+ }
+
+ public void placeBet(Person personPlacingBet, int betAmount) {
+ personPlacingBet.getWallet().removeChipsFromAmount(betAmount);
+ }
+
+ public void bootPlayerFromGame() {
+ gameIsRunning = false;
+ System.out.println("Sorry, you're out of money! Bye-bye!");
+ }
+
+ public void end() {
+ System.out.println("Thanks for playing!");
+ gameIsRunning = false;
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java
new file mode 100644
index 00000000..e46cda8d
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Craps.java
@@ -0,0 +1,923 @@
+package io.zipcoder.casino;
+
+import java.util.*;
+
+public class Craps extends Game implements GameInterface, DiceGameInterface, GamblingInterface {
+
+ private DiceManager crapsDice = new DiceManager(2);
+ private int point = 0;
+ private int passLineBet = 0;
+ private int dontPassLineBet = 0;
+ private int comeBet = 0;
+ private int dontComeBet = 0;
+ private int fieldBet = 0;
+ private int passOddsBet = 0;
+ private int dontPassOddsBet = 0;
+ private ArrayList fieldValues = new ArrayList();
+ private ArrayList winLosePlaceValues = new ArrayList();
+ private HashMap comeBetPoints = new HashMap();
+ private HashMap dontComeBetPoints = new HashMap();
+ private HashMap comeBetPointOdds = new HashMap();
+ private HashMap dontComeBetPointOdds = new HashMap();
+ private HashMap placeWinBets = new HashMap();
+ private HashMap placeLoseBets = new HashMap();
+ private boolean keepPlaying = true;
+ private Scanner userInput = new Scanner(System.in);
+
+
+ Person player;
+
+
+ public void rollDice() {
+ crapsDice.rollAllDice();
+ }
+
+ public int getNumberOfDice() {
+ return 2;
+ }
+
+ public int checkChipAmount(Person personToCheck) {
+ return personToCheck.getWallet().checkChipAmount();
+ }
+
+ public void placeBet(Person personPlacingBet, int betAmount) {
+ personPlacingBet.getWallet().removeChipsFromAmount(betAmount);
+
+ }
+
+ public int getAnte() {
+ return 5;
+ }
+
+ public void bootPlayerFromGame(Person personToBoot) {
+ System.out.println("You don't have enough money!");
+
+ }
+
+ public int checkPot() {
+ return 0;
+ }
+
+ public Craps(){}
+
+ public Craps(Person player) {
+ this.player = player;
+ }
+
+ public void start() {
+ System.out.println("Welcome to Craps!");
+ do {
+ if (player.getWallet().checkChipAmount() < 5) {
+ bootPlayerFromGame(player);
+ break;
+ }
+ firstBetChecker();
+ comeOutRoll();
+ quitProgram();
+ } while (keepPlaying);
+
+ }
+
+ public void comeOutRoll() {
+ System.out.println("Time to make your first roll!");
+ rollDice();
+ System.out.println("You rolled a " + crapsDice.getTotalValue() + "!");
+ checkComeOutRoll();
+ }
+
+ private void checkComeOutRoll() {
+ if (crapsDice.getTotalValue() == 2 || crapsDice.getTotalValue() == 3) {
+ System.out.println("You crapped out. Pass line bets loose and Don't Pass bets win.");
+ passLineBetLose();
+ dontPassLineBetWin();
+ } else if (crapsDice.getTotalValue() == 7 || crapsDice.getTotalValue() == 11) {
+ System.out.println("You rolled a natural! Pass Line bets win and Don't Pass loses.");
+ passLineBetWin();
+ dontPassLineBetLose();
+ } else if (crapsDice.getTotalValue() == 12) {
+ System.out.println("Pass Line looses and Don't Pass bets are pushed to next round.");
+ passLineBetLose();
+ } else {
+ System.out.println("The point is now " + crapsDice.getTotalValue());
+ point = crapsDice.getTotalValue();
+ phaseTwoRolls();
+ }
+ }
+
+ private void phaseTwoRolls() {
+ System.out.println("Time for phase two! Roll a " + point + " and not a 7!");
+ do {
+ createFieldValues();
+ createWinLosePlaceValues();
+ placeBetPhaseTwoHandler();
+ rollDice();
+ System.out.println("You rolled a " + crapsDice.getTotalValue() + "!");
+ checkPhaseTwoRolls();
+ } while (!(crapsDice.getTotalValue() == point) && !(crapsDice.getTotalValue() == 7));
+ }
+
+ public void checkPhaseTwoRolls() {
+ if (crapsDice.getTotalValue() == point) {
+ System.out.println("You rolled the point! Pass Line wins and Don't Pass loses!");
+ checkBetHandler();
+ } else if (crapsDice.getTotalValue() == 7) {
+ System.out.println("You rolled a 7. Don't Pass wins and Pass Line loses!");
+ checkBetHandler();
+ } else {
+ checkBetHandler();
+ }
+ }
+
+
+ public void checkBetHandler() {
+ passLineChecker();
+ dontPassLineChecker();
+ comeBetPointChecker();
+ comeBetChecker();
+ dontComeBetPointChecker();
+ dontComeBetChecker();
+ checkPassLineOdds();
+ checkDontPassLineOdds();
+ checkComeBetPointOdds();
+ checkDontComeBetPointOdds();
+ checkFieldBet();
+ placeWinBetChecker();
+ placeLoseBetChecker();
+ }
+
+ public void passLineChecker() {
+ if (crapsDice.getTotalValue() == point && passLineBet != 0) {
+ passLineBetWin();
+ } else if (crapsDice.getTotalValue() == 7 && passLineBet != 0) {
+ passLineBetLose();
+ }
+ }
+
+ public void passLineBetWin() {
+ System.out.println("Pass line bets pay 1:1. You won " + passLineBet + " chips!");
+ player.getWallet().addChipsToAmount(passLineBet);
+ passLineBet = 0;
+
+ }
+
+ public void passLineBetLose() {
+ System.out.println("Pass Line lost. You lost " + passLineBet + " chips.");
+ passLineBet = 0;
+ }
+
+ public void dontPassLineChecker() {
+ if (crapsDice.getTotalValue() == point && dontPassLineBet != 0) {
+ dontPassLineBetLose();
+ } else if (crapsDice.getTotalValue() == 7 && dontPassLineBet != 0) {
+ dontPassLineBetWin();
+ }
+ }
+
+ public void dontPassLineBetWin() {
+ System.out.println("Don't Pass bets pay 1:1. You won " + dontPassLineBet + " chips!");
+ player.getWallet().addChipsToAmount(dontPassLineBet);
+ dontPassLineBet = 0;
+ }
+
+ public void dontPassLineBetLose() {
+ System.out.println("Don't Pass Line lost. You lost " + dontPassLineBet + " chips.");
+ dontPassLineBet = 0;
+ }
+
+ public void comeBetChecker() {
+ if ((crapsDice.getTotalValue() == 7 || crapsDice.getTotalValue() == 11) && comeBet != 0) {
+ comeBetWin();
+ } else if ((crapsDice.getTotalValue() == 2 || crapsDice.getTotalValue() == 3 || crapsDice.getTotalValue() == 12)
+ && comeBet != 0) {
+ comeBetLose();
+ } else if (comeBet > 4){
+ comeBetToComePoint();
+ }
+ }
+
+ private void comeBetWin() {
+ System.out.println("Come bet wins! Come bet pays 1:1. You won " + comeBet + " chips!");
+ player.getWallet().addChipsToAmount(comeBet);
+ comeBet = 0;
+ }
+
+ private void comeBetLose() {
+ System.out.println("Come Bet loses. You lost " + comeBet + " chips.");
+ comeBet = 0;
+ }
+
+ public void dontComeBetChecker() {
+ if ((crapsDice.getTotalValue() == 7 || crapsDice.getTotalValue() == 11) && dontComeBet != 0) {
+ dontComeBetLose();
+ } else if ((crapsDice.getTotalValue() == 2 || crapsDice.getTotalValue() == 3)
+ && dontComeBet != 0) {
+ dontComeBetWin();
+ } else if (dontComeBet > 4 && !(crapsDice.getTotalValue() ==12)) {
+ dontCometoDontComePoint();
+ }
+ }
+
+ private void dontComeBetWin() {
+ System.out.println("Don't Come bet wins! You won " + dontComeBet + " chips!");
+ player.getWallet().addChipsToAmount(dontComeBet);
+ dontComeBet = 0;
+ }
+
+ private void dontComeBetLose() {
+ System.out.println("Don't Come bet loses. You lost " + dontComeBet + " chips.");
+ dontComeBet = 0;
+ }
+
+ public void comeBetPointChecker() {
+ if (comeBetPoints.containsKey(crapsDice.getTotalValue())) {
+ comeBetPointWin();
+ } else if (crapsDice.getTotalValue() == 7 && !(comeBetPoints.isEmpty())) {
+ comeBetPointLose();
+ }
+ }
+
+ private void comeBetPointWin() {
+ System.out.println("Your Come bet on point " + crapsDice.getTotalValue() + " wins! Come Bet points are 1:1. " +
+ " You won " + comeBetPoints.get(crapsDice.getTotalValue()) + " chips!");
+ player.getWallet().addChipsToAmount(comeBetPoints.get(crapsDice.getTotalValue()));
+ comeBetPoints.remove(crapsDice.getTotalValue());
+ }
+
+ private void comeBetPointLose() {
+ int totalValueOfPoints = 0;
+ for (Map.Entry entry: comeBetPoints.entrySet()) {
+ totalValueOfPoints += entry.getValue();
+ }
+ System.out.println("Your Come bet points lost! You lost a total of " + totalValueOfPoints + " chips.");
+ comeBetPoints.clear();
+ }
+
+ public void dontComeBetPointChecker() {
+ if (dontComeBetPoints.containsKey(crapsDice.getTotalValue())) {
+ dontComeBetPointLose();
+ } else if (crapsDice.getTotalValue() == 7 && !(dontComeBetPoints.isEmpty())) {
+ dontComeBetPointWin();
+ }
+ }
+
+ private void dontComeBetPointWin() {
+ int totalValueOfPoints = 0;
+ for (Map.Entry entry: dontComeBetPoints.entrySet()) {
+ totalValueOfPoints += entry.getValue();
+ }
+ System.out.println("Your Don't Come bet points won! You won a total of " + totalValueOfPoints + " chips.");
+ player.getWallet().addChipsToAmount(totalValueOfPoints);
+ dontComeBetPoints.clear();
+ }
+
+ private void dontComeBetPointLose() {
+ System.out.println("Your Don't Come bet on point " + crapsDice.getTotalValue() + " lost." +
+ " You lost " + dontComeBetPoints.get(crapsDice.getTotalValue()) + " chips!");
+ dontComeBetPoints.remove(crapsDice.getTotalValue());
+ }
+
+ private void comeBetToComePoint() {
+ System.out.println("Your Come bet is now a point.");
+ comeBetPoints.put(crapsDice.getTotalValue(), comeBet);
+ comeBet = 0;
+ }
+
+ private void dontCometoDontComePoint() {
+ System.out.println("You Don't Come bet is now a point.");
+ dontComeBetPoints.put(crapsDice.getTotalValue(), dontComeBet);
+ dontComeBet = 0;
+ }
+
+ private void checkFieldBet() {
+ if (fieldValues.contains(crapsDice.getTotalValue()) && fieldBet != 0){
+ if (crapsDice.getTotalValue() == 2 || crapsDice.getTotalValue() == 12) {
+ fieldDoubleWin();
+ } else {
+ fieldWin();
+ }
+ } else if (fieldBet != 0) {
+ fieldLose();
+ }
+ }
+
+ private void fieldDoubleWin() {
+ System.out.println("Field win is doubled! You wn " + fieldBet * 2 + " chips!");
+ player.getWallet().addChipsToAmount(fieldBet * 2);
+ fieldBet = 0;
+ }
+
+ private void fieldWin() {
+ System.out.println("Field wins! Payout is 1:1. You won " + fieldBet + " chips!");
+ player.getWallet().addChipsToAmount(fieldBet);
+ fieldBet = 0;
+ }
+
+ private void fieldLose() {
+ System.out.println("Field loses. You lost " + fieldBet + " chips.");
+ fieldBet = 0;
+ }
+
+ public void checkPassLineOdds() {
+ if (passOddsBet != 0 && crapsDice.getTotalValue() == point) {
+ passLineOddsWin();
+ } else if (passOddsBet != 0 && crapsDice.getTotalValue() ==7) {
+ passLineOddsLose();
+ }
+ }
+
+ private void passLineOddsWin() {
+ if (point == 4 || point == 10) {
+ System.out.println("Pass Line odds wins! Payout is 2:1. You won " + (passOddsBet + passOddsBet * 2) + " chips!");
+ player.getWallet().addChipsToAmount(passOddsBet = passOddsBet * 2);
+ passOddsBet = 0;
+ } else if (point == 5 || point == 9) {
+ System.out.println("Pass Line odds wins! Payout is 3:2. You won " + (passOddsBet +(int)
+ Math.floor(passOddsBet * .5)) + " chips!");
+ player.getWallet().addChipsToAmount(passOddsBet + (int)Math.floor(passOddsBet * 1.5));
+ passOddsBet = 0;
+ } else if (point == 6 || point == 8) {
+ System.out.println("Pass Line odds wins! Payout is 6:5. You won " + (passOddsBet + (int)
+ Math.floor(passOddsBet * .2)) + " chips!");
+ player.getWallet().addChipsToAmount(passOddsBet + (int)Math.floor(passOddsBet * 1.2));
+ passOddsBet = 0;
+ }
+ }
+
+ private void passLineOddsLose() {
+ System.out.println("Pass Line odds lose! You lost " + passOddsBet + " chips");
+ passOddsBet = 0;
+ }
+
+ public void checkDontPassLineOdds() {
+ if (dontPassOddsBet !=0 && crapsDice.getTotalValue() == point) {
+ dontPassLineOddsLose();
+ } else if (dontPassOddsBet != 0 && crapsDice.getTotalValue() ==7) {
+ dontPassLineOddsWin();
+ }
+ }
+
+ private void dontPassLineOddsWin() {
+ if (point == 4 || point == 10) {
+ System.out.println("Don't Pass odds wins! Payout is 1:2. You won " + (dontPassOddsBet +
+ (int)Math.floor(dontPassOddsBet * .5)) + " chips!");
+ player.getWallet().addChipsToAmount(dontPassOddsBet + (int)Math.floor(dontPassOddsBet * .5));
+ dontPassOddsBet = 0;
+ } else if (point == 5 || point == 9) {
+ System.out.println("Don't Pass odds wins! Payout is 2:3. You won " + (dontPassOddsBet +
+ (int)Math.floor(dontPassOddsBet * .66)) + " chips!");
+ player.getWallet().addChipsToAmount(dontPassOddsBet + (int)Math.floor(dontPassOddsBet * .66));
+ dontPassOddsBet = 0;
+ } else if (point == 6 || point == 8) {
+ System.out.println("Don't Pass odds wins! Payout is 5:6. You won " +(dontPassOddsBet +
+ (int)Math.floor(dontPassOddsBet * .83)) + " chips!");
+ player.getWallet().addChipsToAmount((dontPassOddsBet + (int)Math.floor(dontPassOddsBet * .83)));
+ dontPassOddsBet = 0;
+ }
+ }
+
+ private void dontPassLineOddsLose() {
+ System.out.println("Don't Pass odds lose! You lost " + dontPassOddsBet + " chips.");
+ dontPassOddsBet = 0;
+ }
+
+ public void checkComeBetPointOdds() {
+ if (comeBetPointOdds.containsKey(crapsDice.getTotalValue())) {
+ comeBetPointOddsWin();
+
+ } else if (crapsDice.getTotalValue() == 7 && !(comeBetPointOdds.isEmpty())) {
+ comeBetPointOddsLose();
+ }
+ }
+
+ private void comeBetPointOddsWin() {
+ if (crapsDice.getTotalValue() == 4 || crapsDice.getTotalValue() == 10) {
+ System.out.println("Your Come bet Odds on point " + crapsDice.getTotalValue() + " wins! Payout is 2:1." +
+ " You won " + (comeBetPointOdds.get(crapsDice.getTotalValue()) +
+ comeBetPointOdds.get(crapsDice.getTotalValue()) * 2) + " chips!");
+ player.getWallet().addChipsToAmount(comeBetPointOdds.get(crapsDice.getTotalValue()) +
+ comeBetPointOdds.get(crapsDice.getTotalValue()) * 2);
+ comeBetPointOdds.remove(crapsDice.getTotalValue());
+ } else if (crapsDice.getTotalValue() == 5 || crapsDice.getTotalValue() == 9) {
+ System.out.println("Your Come bet Odds on point " + crapsDice.getTotalValue() + " wins! Payout is 3:2." +
+ " You won " + (comeBetPointOdds.get(crapsDice.getTotalValue()) +
+ (int) Math.floor(comeBetPointOdds.get(crapsDice.getTotalValue()) * 1.5)) + " chips!");
+ player.getWallet().addChipsToAmount(comeBetPointOdds.get(crapsDice.getTotalValue()) +
+ (int) Math.floor(comeBetPointOdds.get(crapsDice.getTotalValue()) * 1.5));
+ comeBetPointOdds.remove(crapsDice.getTotalValue());
+ } else if (crapsDice.getTotalValue() == 6 || crapsDice.getTotalValue() == 8) {
+ System.out.println("Your Come bet Odds on point " + crapsDice.getTotalValue() + " wins! Payout is 6:5." +
+ " You won " + (comeBetPointOdds.get(crapsDice.getTotalValue()) +
+ (int) Math.floor(comeBetPointOdds.get(crapsDice.getTotalValue()) * 1.2)) + " chips!");
+ player.getWallet().addChipsToAmount(comeBetPointOdds.get(crapsDice.getTotalValue()) +
+ (int) Math.floor(comeBetPointOdds.get(crapsDice.getTotalValue()) * 1.2));
+ comeBetPointOdds.remove(crapsDice.getTotalValue());
+ }
+ }
+
+ private void comeBetPointOddsLose() {
+ int totalValueOfPoints = 0;
+ for (Map.Entry entry: comeBetPointOdds.entrySet()) {
+ totalValueOfPoints += entry.getValue();
+ }
+ System.out.println("Your Come bet odds lost! You lost a total of " + totalValueOfPoints + " chips.");
+ comeBetPointOdds.clear();
+ }
+
+ public void checkDontComeBetPointOdds() {
+ if (dontComeBetPointOdds.containsKey(crapsDice.getTotalValue())) {
+ dontComeBetPointOddsLose();
+
+ } else if (crapsDice.getTotalValue() == 7 && !(dontComeBetPointOdds.isEmpty())) {
+ dontComeBetPointOddsWin();
+ }
+ }
+
+ private void dontComeBetPointOddsLose() {
+ System.out.println("Your Don't Come Odds bet on point " + crapsDice.getTotalValue() + " lost." +
+ " You lost " + dontComeBetPointOdds.get(crapsDice.getTotalValue()) + " chips!");
+ dontComeBetPoints.remove(crapsDice.getTotalValue());
+ }
+
+ private void dontComeBetPointOddsWin() {
+ int grandTotal = 0;
+ for (Map.Entry entry: dontComeBetPointOdds.entrySet()) {
+ if (entry.getKey() == 4 || entry.getKey() == 10) {
+ System.out.println("Your Don't Come bet Odds on point " + entry.getKey() + " wins! Payout is 1:2." +
+ " You won " + (entry.getValue() +
+ (int) Math.floor(entry.getValue() * .5)) + " chips!");
+ player.getWallet().addChipsToAmount(entry.getValue() +
+ (int) Math.floor(entry.getValue() * .5));
+ grandTotal += (entry.getValue() +
+ (int) Math.floor(entry.getValue() * .5));
+ } else if (entry.getKey() == 5 || entry.getKey() == 9) {
+ System.out.println("Your Don't Come bet Odds on point " + entry.getKey() + " wins! Payout is 2:3." +
+ " You won " + (entry.getValue() +
+ (int) Math.floor(entry.getValue() * .66)) + " chips!");
+ player.getWallet().addChipsToAmount(entry.getValue() +
+ (int) Math.floor(entry.getValue() * .66));
+ grandTotal += (entry.getValue() +
+ (int) Math.floor(entry.getValue() * .66));
+ } else if (entry.getKey() == 6 || entry.getKey() == 8) {
+ System.out.println("Your Don't Come bet Odds on point " + entry.getKey() + " wins! Payout is 5:6." +
+ " You won " + (entry.getValue() +
+ (int) Math.floor(entry.getValue() * .83)) + " chips!");
+ player.getWallet().addChipsToAmount(entry.getValue() +
+ (int) Math.floor(entry.getValue() * .83));
+ grandTotal += (entry.getValue() +
+ (int) Math.floor(entry.getValue() * .83));
+ }
+ }
+ dontComeBetPointOdds.clear();
+ System.out.println("You won a total of " + grandTotal + " chips on Don't Come Point Odds bets!");
+ }
+
+
+ private void placeWinBetChecker() {
+ if (placeWinBets.containsKey(crapsDice.getTotalValue())) {
+ placeWinBetWin();
+ } else if (crapsDice.getTotalValue() == 7 && !(placeWinBets.isEmpty())) {
+ placeWinBetLose();
+ }
+ }
+
+ private void placeWinBetWin() {
+ if (crapsDice.getTotalValue() == 6 || crapsDice.getTotalValue() == 8) {
+ System.out.println("Your Place Win bet won! Payout is 7:6. You won " + ((int) Math.floor(
+ placeWinBets.get(crapsDice.getTotalValue()) + placeWinBets.get(crapsDice.getTotalValue())
+ * 1.16)) + " chips!");
+ player.getWallet().addChipsToAmount((int) Math.floor(
+ placeWinBets.get(crapsDice.getTotalValue()) + placeWinBets.get(crapsDice.getTotalValue())
+ * 1.16));
+ placeWinBets.remove(crapsDice.getTotalValue());
+ } else if (crapsDice.getTotalValue() == 5 || crapsDice.getTotalValue() == 9) {
+ System.out.println("Your Place Win bet won! Payout is 7:5. You won " + ((int) Math.floor(
+ placeWinBets.get(crapsDice.getTotalValue()) + placeWinBets.get(crapsDice.getTotalValue())
+ * 1.4)) + " chips!");
+ player.getWallet().addChipsToAmount((int) Math.floor(
+ placeWinBets.get(crapsDice.getTotalValue()) + placeWinBets.get(crapsDice.getTotalValue())
+ * 1.4));
+ placeWinBets.remove(crapsDice.getTotalValue());
+ } else if (crapsDice.getTotalValue() == 4 || crapsDice.getTotalValue() == 10) {
+ System.out.println("Your Place Win bet won! Payout is 9:5. You won " + ((int) Math.floor(
+ placeWinBets.get(crapsDice.getTotalValue()) + placeWinBets.get(crapsDice.getTotalValue())
+ * 1.8)) + " chips!");
+ player.getWallet().addChipsToAmount((int) Math.floor(
+ placeWinBets.get(crapsDice.getTotalValue()) + placeWinBets.get(crapsDice.getTotalValue())
+ * 1.8));
+ placeWinBets.remove(crapsDice.getTotalValue());
+ }
+ }
+
+ private void placeWinBetLose() {
+ int totalValueOfPoints = 0;
+ for (Map.Entry entry: placeWinBets.entrySet()) {
+ totalValueOfPoints += entry.getValue();
+ }
+ System.out.println("Your Place Win bets lost! You lost a total of " + totalValueOfPoints + " chips.");
+ placeWinBets.clear();
+ }
+
+ private void placeLoseBetChecker() {
+ if (placeLoseBets.containsKey(crapsDice.getTotalValue())) {
+ placeLoseBetLose();
+ } else if (crapsDice.getTotalValue() == 7 && !(placeLoseBets.isEmpty())) {
+ placeLoseBetWin();
+ }
+ }
+
+ private void placeLoseBetLose() {
+ System.out.println("Your Place Lose bet on point " + crapsDice.getTotalValue() + " lost." +
+ " You lost " + placeLoseBets.get(crapsDice.getTotalValue()) + " chips!");
+ placeLoseBets.remove(crapsDice.getTotalValue());
+ }
+
+ private void placeLoseBetWin() {
+ int grandTotal = 0;
+ for (Map.Entry entry : placeLoseBets.entrySet()) {
+ if (entry.getKey() == 6 || entry.getKey() == 8) {
+ System.out.println("Your Place Lose bet on " + entry.getKey() + " won! Payout is 4:5. You won " +
+ (entry.getValue() + (int) Math.floor(entry.getValue() * .8)) + " chips!");
+ player.getWallet().addChipsToAmount(entry.getValue() + (int) Math.floor(entry.getValue()
+ * .8));
+ grandTotal += (entry.getValue() + (int) Math.floor(entry.getValue()
+ * .8));
+ } else if (entry.getKey() == 5 || entry.getKey() == 9) {
+ System.out.println("Your Place Lose bet on " + entry.getKey() + " won! Payout is 5:8. You won " +
+ (entry.getValue() + (int) Math.floor(entry.getValue() * .62)) + " chips!");
+ player.getWallet().addChipsToAmount(entry.getValue() + (int) Math.floor(entry.getValue()
+ * .62));
+ grandTotal += (entry.getValue() + (int) Math.floor(entry.getValue()
+ * .62));
+ } else if (entry.getKey() == 4 || entry.getKey() == 10) {
+ System.out.println("Your Place Lose bet on " + entry.getKey() + " won! Payout is 5:11. You won " +
+ (entry.getValue() + (int) Math.floor(entry.getValue() * .45)) + " chips!");
+ player.getWallet().addChipsToAmount(entry.getValue()+ (int) Math.floor(entry.getValue()
+ * .45));
+ grandTotal += (entry.getValue()+ (int) Math.floor(entry.getValue()
+ * .45));
+ }
+ }
+ placeLoseBets.clear();
+ System.out.println("You won a total of " + grandTotal + " chips on Place Lose bets!");
+ }
+
+ private void placeBetPhaseTwoHandler() {
+ String userAnswer = "";
+ do {
+ if (player.getWallet().checkChipAmount() < 5) {
+ System.out.println("You don't have enough money for more bets!");
+ break;
+ }
+ System.out.println("What type of bet would you like to place?" +
+ "\nCome" +
+ "\nDon't Come" +
+ "\nField" +
+ "\nOdds" +
+ "\nPlace Win" +
+ "\nPlace Lose" +
+ "\nCheck Wallet Amount" +
+ "\nRoll Dice");
+ userAnswer= getBetTypeInput();
+ placeBetSelection(userAnswer);
+
+ } while (!(userAnswer.equals("roll dice")));
+
+ }
+
+ public void placeBetSelection(String userAnswer) {
+ if (userAnswer.equals("come")) {
+ placeComeBet();
+ } else if (userAnswer.equals("don't come")) {
+ placeDontComeBet();
+ } else if (userAnswer.equals("field")) {
+ placeFieldBet();
+ } else if (userAnswer.equals("odds")) {
+ oddsTypeHandler();
+ } else if (userAnswer.equals("place win")) {
+ placeWinChecker();
+ } else if (userAnswer.equals("place lose")) {
+ placeLoseChecker();
+ } else if (userAnswer.equals("check wallet amount")) {
+ System.out.println(player.getWallet().checkChipAmount());
+ } else if (userAnswer.equals("roll dice")) {
+ } else {
+ System.out.println("Input not recognized. Please try again.");
+ }
+ }
+
+ private void placeComeBet() {
+ System.out.println("How much would you like to bet for the Come bet?");
+ comeBet += minimumBetChecker();
+ placeBet(player, comeBet);
+ }
+
+ private void placeDontComeBet() {
+ System.out.println("How much would you like to bet for the Don't Come bet?");
+ dontComeBet += minimumBetChecker();
+ placeBet(player, dontComeBet);
+ }
+
+ private void placeFieldBet() {
+ System.out.println("How much would you like to bet on the Field?");
+ fieldBet += minimumBetChecker();
+ placeBet(player, fieldBet);
+ }
+
+ private void placeWinChecker() {
+ System.out.println("Which number would you like to be on? 4, 5, 6, 8, 9, or 10");
+ System.out.println(winLosePlaceValues.toString());
+ int userAnswer = getBetInput();
+ if (winLosePlaceValues.contains(userAnswer)) {
+ System.out.println("How much would you like to bet?");
+ int userBet = getBetInput();
+ placeWinBets.put(userAnswer, userBet);
+ } else {
+ System.out.println("Input not recognized.");
+ }
+
+ }
+
+ private void placeLoseChecker() {
+ System.out.println("Which number would you like to be on? 4, 5, 6, 8, 9, or 10");
+ int userAnswer = getBetInput();
+ if (winLosePlaceValues.contains(userAnswer)) {
+ System.out.println("How much would you like to bet?");
+ int userBet = getBetInput();
+ placeLoseBets.put(userAnswer, userBet);
+ } else {
+ System.out.println("Input not recognized.");
+ }
+ }
+
+ public void firstBetChecker(){
+ do {
+ placePassBetChecker();
+ if (player.getWallet().checkChipAmount() < 5 ) {
+ System.out.println("You don't have enough money for another bet!");
+ } else {
+ placeDontPassLineBetChecker();
+ }
+ if (passLineBet == 0 && dontPassLineBet == 0) {
+ System.out.println("You must place an initial bet!");
+ }
+ } while (passLineBet == 0 && dontPassLineBet == 0);
+ }
+
+ private void placePassBetChecker() {
+ System.out.println("Would you like to place a Pass bet? Yes or no.");
+ String userAnswer = "";
+ do {
+ userAnswer = getBetTypeInput();
+ if (userAnswer.equals("yes")) {
+ placePassLineBet();
+ } else if (!(userAnswer.equals("yes")) && !(userAnswer.equals("no"))) {
+ System.out.println("Answer not recognized. Please try again.");
+ }
+ } while (!(userAnswer.equals("yes")) && !(userAnswer.equals("no")));
+ }
+
+ private void placePassLineBet() {
+ System.out.println("How much would you like to bet on the Pass Line?");
+ passLineBet += minimumBetChecker();
+ placeBet(player, passLineBet);
+ }
+
+ private void placeDontPassLineBetChecker() {
+ System.out.println("Would you like to place a Don't Pass bet? Yes or no.");
+ String userAnswer = "";
+ do {
+ userAnswer = getBetTypeInput();
+ if (userAnswer.equals("yes")) {
+ placeDontPassLineBet();
+ } else if (!(userAnswer.equals("yes")) && !(userAnswer.equals("no"))) {
+ System.out.println("Answer not recognized. Please try again.");
+ }
+ } while (!(userAnswer.equals("yes")) && !(userAnswer.equals("no")));
+ }
+
+ private void placeDontPassLineBet() {
+ System.out.println("How much would you like to bet on the Don't Pass Line?");
+ dontPassLineBet += minimumBetChecker();
+ placeBet(player, dontPassLineBet);
+ }
+
+ private void oddsTypeHandler() {
+ String userAnswer = "";
+ do {
+ System.out.println("What type of odds would you like to place?\n" +
+ "Pass\n" +
+ "Don't Pass\n" +
+ "Come\n" +
+ "Don't Come\n" +
+ "None");
+ userAnswer = getBetTypeInput();
+ oddsTypeSelector(userAnswer);
+ } while (!(userAnswer.equals("none")));
+ }
+
+ public void oddsTypeSelector(String userAnswer) {
+ if (userAnswer.equals("pass")) {
+ placePassOddsBet();
+ } else if (userAnswer.equals("don't pass")) {
+ placeDontPassOddsBet();
+ } else if (userAnswer.equals("come")) {
+ placeComeOddsBet();
+ } else if (userAnswer.equals("don't come")) {
+ placeDontComeOddsBet();
+ } else if (userAnswer.equals("none")) {
+
+ } else {
+ System.out.println("Input is not recognized. Try again.");
+ }
+ }
+
+ private void placePassOddsBet() {
+ if (passLineBet != 0){
+ System.out.println("How much would you like to bet on Pass Line odds?");
+ passOddsBet += minimumBetChecker();
+ placeBet(player, passOddsBet);
+ } else {
+ System.out.println("You don't have a Pass Line bet!");
+ }
+ }
+
+ private void placeDontPassOddsBet() {
+ if (dontPassLineBet != 0) {
+ System.out.println("How much would you like to bet on Don't Pass odds?");
+ dontPassOddsBet += minimumBetChecker();
+ placeBet(player, dontPassOddsBet);
+ } else {
+ System.out.println("You don't have a Don't Pass bet!");
+ }
+ }
+
+ private void placeComeOddsBet() {
+ if (comeBetPoints.isEmpty()) {
+ System.out.println("You have no Come Bet points.");
+ } else if (!(comeBetPoints.isEmpty())) {
+ System.out.println("Which point would you like to put odds on?");
+ System.out.println(comeBetPoints.keySet().toString());
+ comeBetOddsSelector();
+ }
+ }
+
+ private void comeBetOddsSelector() {
+ int userAnswer = getBetInput();
+ if (comeBetPoints.containsKey(userAnswer)) {
+ System.out.println("How much would you like to bet?");
+ int userBet = getBetInput();
+ comeBetPointOdds.put(userAnswer, userBet);
+ } else {
+ System.out.println("That option is not available.");
+ }
+ }
+
+ private void placeDontComeOddsBet() {
+ if (dontComeBetPoints.isEmpty()) {
+ System.out.println("You have no Don't Come Bet points.");
+ } else if (!(dontComeBetPoints.isEmpty())) {
+ System.out.println("Which point would you like to put odds on?");
+ System.out.println(dontComeBetPoints.keySet().toString());
+ dontComeBetOddsSelector();
+ }
+ }
+
+ private void dontComeBetOddsSelector() {
+ int userAnswer = getBetInput();
+ if (dontComeBetPoints.containsKey(userAnswer)) {
+ System.out.println("How much would you like to bet?");
+ int userBet = getBetInput();
+ dontComeBetPointOdds.put(userAnswer, userBet);
+ } else {
+ System.out.println("That option is not available.");
+ }
+ }
+
+ private int minimumBetChecker() {
+ int betAmount = 0;
+ do {
+ betAmount = getBetInput();
+ if (betAmount < getAnte()) {
+ System.out.println("The minimum bet is " + getAnte() + ". Try again.");
+ }
+ } while (betAmount < getAnte());
+ return betAmount;
+ }
+
+ private int getBetInput() {
+ try {
+ int betInput = userInput.nextInt();
+ userInput.nextLine();
+ return betInput;
+ } catch (InputMismatchException e) {
+ System.out.println("That is not a number. Setting bet to 5.");
+ userInput.nextLine();
+ return 5;
+ }
+ }
+
+ private String getBetTypeInput() {
+ return userInput.nextLine().toLowerCase();
+ }
+
+ public void createFieldValues() {
+ fieldValues.add(2);
+ fieldValues.add(3);
+ fieldValues.add(4);
+ fieldValues.add(9);
+ fieldValues.add(10);
+ fieldValues.add(11);
+ fieldValues.add(12);
+ }
+
+ private void createWinLosePlaceValues() {
+ winLosePlaceValues.add(4);
+ winLosePlaceValues.add(5);
+ winLosePlaceValues.add(6);
+ winLosePlaceValues.add(8);
+ winLosePlaceValues.add(9);
+ winLosePlaceValues.add(10);
+ }
+
+ private void quitProgram() {
+ System.out.println("Would you like to keep playing? Yes or no.");
+ String userAnswer = "";
+ do {
+ userAnswer = getBetTypeInput();
+ if (userAnswer.equals("yes")) {
+ System.out.println("New round starting!");
+ } else if (userAnswer.equals("no")) {
+ System.out.println("Thanks for playing!");
+ keepPlaying = false;
+ } else {
+ System.out.println("Your answer was not recognized. Please try again.");
+ }
+ }while (!(userAnswer.equals("yes")) && !(userAnswer.equals("no")));
+ }
+
+
+ //Testing methods
+ public Person getPlayer() {
+ return player;
+ }
+
+ public DiceManager getDiceManager() {
+ return crapsDice;
+ }
+
+ public void setPassLineBet(int testInput) {
+ passLineBet = testInput;
+ }
+
+ public void setDontPassLineBet(int testInput) {
+ dontPassLineBet = testInput;
+ }
+
+ public void setPoint(int testInput) {
+ point = testInput;
+ }
+
+ public void setComeBet(int testInput) {
+ comeBet = testInput;
+ }
+
+ public void setDontComeBet(int testInput) {
+ dontComeBet = testInput;
+ }
+
+ public void setFieldBet( int testInput) {
+ fieldBet = testInput;
+ }
+
+ public void setPassOddsBet(int testInput) {
+ passOddsBet = testInput;
+ }
+
+ public void setDontPassOddsBet(int testInput) {
+ dontPassOddsBet = testInput;
+ }
+
+ public void setComeBetPoints(int testInput1, int testInput2){
+ comeBetPoints.put(testInput1,testInput2);
+ }
+
+ public void setDontComeBetPoints(int testInput1, int testInput2) {
+ dontComeBetPoints.put(testInput1, testInput2);
+ }
+
+ public void setComeBetPointOdds(int testInput1, int testInput2) {
+ comeBetPointOdds.put(testInput1, testInput2);
+ }
+
+ public void setDontComeBetPointOdds(int testInput1, int testInput2) {
+ dontComeBetPointOdds.put(testInput1,testInput2);
+ }
+
+ public void setPlaceWinBets(int testInput1, int testInput2) {
+ placeWinBets.put(testInput1, testInput2);
+ }
+
+ public void setPlaceLoseBets(int testInput1, int testInput2) {
+ placeLoseBets.put(testInput1, testInput2);
+ }
+}
diff --git a/src/main/java/io/zipcoder/casino/Dealer.java b/src/main/java/io/zipcoder/casino/Dealer.java
new file mode 100644
index 00000000..f730b51f
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Dealer.java
@@ -0,0 +1,18 @@
+package io.zipcoder.casino;
+
+public class Dealer extends Person{
+
+
+ private DealerWallet dealerWallet;
+
+ public Dealer() {
+ super("Dealer");
+ this.dealerWallet = new DealerWallet();
+ }
+
+ public DealerWallet getDealerWallet() {
+ return this.dealerWallet;
+ }
+
+
+}
diff --git a/src/main/java/io/zipcoder/casino/DealerWallet.java b/src/main/java/io/zipcoder/casino/DealerWallet.java
new file mode 100644
index 00000000..59652d16
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/DealerWallet.java
@@ -0,0 +1,21 @@
+package io.zipcoder.casino;
+
+public class DealerWallet extends Wallet {
+ private int chipAmount = Integer.MAX_VALUE;
+
+ @Override
+ public void addChipsToAmount(int chipsToAdd) {
+
+ }
+
+ @Override
+ public void removeChipsFromAmount(int chipsToRemove) {
+
+ }
+
+ @Override
+ public int checkChipAmount() {
+ return chipAmount;
+
+ }
+}
diff --git a/src/main/java/io/zipcoder/casino/Deck.java b/src/main/java/io/zipcoder/casino/Deck.java
new file mode 100644
index 00000000..4138c779
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Deck.java
@@ -0,0 +1,44 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+
+public class Deck {
+
+ private ArrayList deckOfCards;
+ private Rank rank;
+ private Suit suit;
+
+ public Deck() {
+
+ this.deckOfCards = new ArrayList();
+
+ for (Suit suit : Suit.values()){
+ for(Rank rank : Rank.values()){
+ deckOfCards.add(new Card(rank, suit));
+ }
+ }
+ }
+
+ public ArrayList getDeckOfCards(){
+
+ return this.deckOfCards;
+ }
+
+ public void shuffleDeck(){
+ Collections.shuffle(this.deckOfCards);
+ }
+
+ public Card drawCard(){
+
+ return this.deckOfCards.remove(deckOfCards.size() - 1);
+ }
+
+ public void clearDeck(){
+ this.deckOfCards.clear();
+ }
+
+}
+
diff --git a/src/main/java/io/zipcoder/casino/DiceGameInterface.java b/src/main/java/io/zipcoder/casino/DiceGameInterface.java
new file mode 100644
index 00000000..f32fc2e6
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/DiceGameInterface.java
@@ -0,0 +1,6 @@
+package io.zipcoder.casino;
+
+public interface DiceGameInterface {
+ void rollDice();
+ int getNumberOfDice();
+}
diff --git a/src/main/java/io/zipcoder/casino/DiceManager.java b/src/main/java/io/zipcoder/casino/DiceManager.java
new file mode 100644
index 00000000..df672aa1
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/DiceManager.java
@@ -0,0 +1,53 @@
+package io.zipcoder.casino;
+
+import java.util.Arrays;
+
+public class DiceManager {
+
+ // Die faces will be stored in an array
+ private Die[] diceArray;
+
+ public DiceManager(int amountOfDice) {
+ this.diceArray = new Die[amountOfDice];
+ for(int i = 0; i < this.diceArray.length; i++) {
+ this.diceArray[i] = new Die();
+ }
+ }
+
+ public Die rollSpecificDie(int index) {
+ diceArray[index].rollDie();
+ return diceArray[index];
+ }
+
+ public void setSpecificDie(int index, DieFace desiredFace) {
+ this.diceArray[index].setDieFace(desiredFace);
+ }
+
+ public Die getDie(int indexOfDie) {
+ return this.diceArray[indexOfDie];
+ }
+
+ public void rollAllDice() {
+ for (int i = 0; i < diceArray.length; i++) {
+ rollSpecificDie(i);
+ }
+ }
+
+ public DieFace[] getAllDieFaces() {
+ Die[] copyOfDiceArray = Arrays.copyOf(this.diceArray, this.diceArray.length);
+ DieFace[] dieFaces = new DieFace[copyOfDiceArray.length];
+ for(int i = 0; i < this.diceArray.length; i++) {
+ dieFaces[i] = this.diceArray[i].getDieFace();
+ }
+ return dieFaces;
+ }
+
+ public int getTotalValue() {
+ int sum = 0;
+ for (int i = 0; i < diceArray.length; i++) {
+ sum += diceArray[i].getDieFace().toInt();
+ }
+ return sum;
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/Die.java b/src/main/java/io/zipcoder/casino/Die.java
new file mode 100644
index 00000000..08606c1a
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Die.java
@@ -0,0 +1,46 @@
+package io.zipcoder.casino;
+
+import java.util.Random;
+
+public class Die {
+
+ private DieFace dieFace;
+ Random random = new Random();
+
+ public Die() {
+ this.dieFace = null;
+ }
+
+ public DieFace getDieFace() {
+ return this.dieFace;
+ }
+
+ public void setDieFace(DieFace desiredDieFace) {
+ this.dieFace = desiredDieFace;
+ }
+
+
+ public void rollDie() {
+ int randomNumber = random.nextInt(6) + 1;
+ switch (randomNumber) {
+ case 1:
+ this.setDieFace(DieFace.ONE);
+ break;
+ case 2:
+ this.setDieFace(DieFace.TWO);
+ break;
+ case 3:
+ this.setDieFace(DieFace.THREE);
+ break;
+ case 4:
+ this.setDieFace(DieFace.FOUR);
+ break;
+ case 5:
+ this.setDieFace(DieFace.FIVE);
+ break;
+ case 6:
+ this.setDieFace(DieFace.SIX);
+ break;
+ }
+ }
+}
diff --git a/src/main/java/io/zipcoder/casino/DieFace.java b/src/main/java/io/zipcoder/casino/DieFace.java
new file mode 100644
index 00000000..8c945f48
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/DieFace.java
@@ -0,0 +1,24 @@
+package io.zipcoder.casino;
+
+public enum DieFace {
+ ONE(1),
+ TWO(2),
+ THREE(3),
+ FOUR(4),
+ FIVE(5),
+ SIX(6);
+
+ private final int faceValue;
+
+ DieFace(int faceValue) {
+ this.faceValue = faceValue;
+ }
+
+ public boolean equalsFaceValue(int faceValue) {
+ return this.faceValue == faceValue;
+ }
+
+ public int toInt() {
+ return this.faceValue;
+ }
+}
diff --git a/src/main/java/io/zipcoder/casino/GamblingInterface.java b/src/main/java/io/zipcoder/casino/GamblingInterface.java
new file mode 100644
index 00000000..4c36f198
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GamblingInterface.java
@@ -0,0 +1,11 @@
+package io.zipcoder.casino;
+
+import java.util.Map;
+
+public interface GamblingInterface {
+ int checkChipAmount(Person personToCheck);
+ void placeBet(Person personPlacingBet, int betAmount);
+ int getAnte();
+ void bootPlayerFromGame(Person personToBoot);
+ int checkPot();
+}
diff --git a/src/main/java/io/zipcoder/casino/Game.java b/src/main/java/io/zipcoder/casino/Game.java
new file mode 100644
index 00000000..e8dbab87
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Game.java
@@ -0,0 +1,9 @@
+package io.zipcoder.casino;
+
+public abstract class Game implements GameInterface{
+
+ // default constructor for 2 players? (minimum number of players);
+
+ public abstract void start();
+
+}
diff --git a/src/main/java/io/zipcoder/casino/GameInterface.java b/src/main/java/io/zipcoder/casino/GameInterface.java
new file mode 100644
index 00000000..9584e0ea
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GameInterface.java
@@ -0,0 +1,5 @@
+package io.zipcoder.casino;
+
+public interface GameInterface {
+ void start();
+}
diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java
new file mode 100644
index 00000000..44f1bd70
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GoFish.java
@@ -0,0 +1,419 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+import java.util.Random;
+import java.util.Scanner;
+
+public class GoFish extends Game implements GameInterface, CardGameInterface {
+
+ private Person player1;
+ private Person dealer = new Person("Dealer");
+ private Deck houseDeck = new Deck();
+
+ private Scanner userInputScanner = new Scanner(System.in);
+ private int userInputSave = 0;
+
+ private Scanner anotherRoundScanner = new Scanner(System.in);
+
+ private int booksTotalPlayer = 0;
+ private int booksTotalDealer = 0;
+
+ private Random random = new Random();
+ private int randomCardFromDealersHand = 0;
+
+ public void GoFish(Person player) {
+ this.player1 = player;
+ }
+
+ public void start() {
+ System.out.println("************************* Welcome to Go Fish! *************************");
+ System.out.println("\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B");
+ System.out.println("************************* Welcome to Go Fish! *************************\n");
+
+ houseDeck = new Deck();
+ startingDrawDeck(houseDeck);
+
+ userTurn();
+ }
+
+ public GoFish(Person player1) {
+ this.player1 = player1;
+ }
+
+ public GoFish() {
+
+ }
+
+ public void startingDrawDeck(Deck houseDeck){
+ // Add 7 cards to player1 hands
+
+ houseDeck.shuffleDeck();
+ for (int i = 0; i < 7; i++){
+ player1.getHand().getHandArrayList().add(houseDeck.drawCard());
+ }
+ // Add 7 cards to dealer hands
+ for (int i = 0; i < 7; i++){
+ dealer.getHand().getHandArrayList().add(houseDeck.drawCard());
+ }
+ houseDeck.shuffleDeck();
+ }
+
+ public void userTurn(){
+ do {
+ System.out.println("****** Player's turn ******");
+ System.out.println("Enter: 1 for Ace, 11 for Jack, 12 for Queen, & 13 for King\n");
+ System.out.println("**** Choose a card to request from dealer ****");
+ checkNumberOfCard();
+ while(!userInputScanner.hasNextInt()) {
+ userInputScanner.next();
+ }
+ /*SAVE*/ int userInput = userInputScanner.nextInt();
+ userInputSave = userInput;
+ } while (userInputSave <= 0 || userInputSave > 13);
+
+ doYouHaveTheCardThatIWantFromComputer(userInputSave, dealer);
+ }
+
+ public void dealerTurn(){
+
+ ArrayList dealerRandomNumberList = new ArrayList();
+
+ dealerRandomNumberList.add(1);
+ dealerRandomNumberList.add(2);
+ dealerRandomNumberList.add(3);
+ dealerRandomNumberList.add(4);
+ dealerRandomNumberList.add(5);
+ dealerRandomNumberList.add(6);
+ dealerRandomNumberList.add(7);
+ dealerRandomNumberList.add(8);
+ dealerRandomNumberList.add(9);
+ dealerRandomNumberList.add(10);
+ dealerRandomNumberList.add(11);
+ dealerRandomNumberList.add(12);
+ dealerRandomNumberList.add(13);
+
+ for (int x = 0; x < 13; x++) {
+ randomCardFromDealersHand = (dealerRandomNumberList.get(random.nextInt(dealerRandomNumberList.size())));
+ }
+ System.out.println("**** Dealer's turn ****");
+ System.out.println("\nDealer has chosen card: " + randomCardFromDealersHand);
+
+ doYouHaveTheCardThatIWantFromPlayer(randomCardFromDealersHand, player1);
+ }
+
+ //Will check the players hand for books and delete them
+ // Need to add in score for completed books
+ public void checkBookCount(int userInputSave, Person handOfCards){
+
+ int num = 0;
+
+ for(int i = 0; i < handOfCards.getHand().getHandArrayList().size(); i++) {
+ if (userInputSave == handOfCards.getHand().getHandArrayList().get(i).getRank().toInt()) {
+ num++;
+ }
+ }
+ if (num == 4) {
+ for (int j = handOfCards.getHand().getHandArrayList().size() - 1; j >= 0 ; j--) {
+ if (userInputSave == handOfCards.getHand().getHandArrayList().get(j).getRank().toInt()){
+
+ handOfCards.getHand().getHandArrayList().remove(handOfCards.getHand().getHandArrayList().get(j));
+ }
+ }
+ booksTotalPlayer++;
+ System.out.println("\n!$!$!$!$!$!$! You Scored a Book! (Four of a kind) !$!$!$!$!$!$!\n");
+ System.out.println("!!!!Your Book Total: " + booksTotalPlayer + "\n");
+ }
+
+ checkForEmptyDeckOrHandOfUserAfterCardFromComputer();
+ //return 0;
+ }
+
+ public void checkBookCountAfterGoFish(int userInputSave, Person handOfCards){
+
+ int num = 0;
+
+ for(int i = 0; i < handOfCards.getHand().getHandArrayList().size(); i++) {
+ if (userInputSave == handOfCards.getHand().getHandArrayList().get(i).getRank().toInt()) {
+ num++;
+ }
+ }
+ if (num == 4) {
+ for (int j = handOfCards.getHand().getHandArrayList().size() - 1; j >= 0 ; j--) {
+ if (userInputSave == handOfCards.getHand().getHandArrayList().get(j).getRank().toInt()){
+ handOfCards.getHand().getHandArrayList().remove(handOfCards.getHand().getHandArrayList().get(j));
+ }
+ }
+ booksTotalPlayer++;
+ System.out.println("\n!$!$!$!$!$!$! You Scored a Book! (Four of a kind) !$!$!$!$!$!$!\n");
+ System.out.println("!!!!Your Book total: " + booksTotalPlayer + "\n");
+ }
+ checkForEmptyDeckOrHandOfUserAfterGoFish();
+ }
+
+ public void checkBookCountDealer(int randomCardFromDealersHand, Person handOfCards){
+
+ int num = 0;
+
+ for(int i = 0; i < handOfCards.getHand().getHandArrayList().size(); i++) {
+ if (randomCardFromDealersHand == handOfCards.getHand().getHandArrayList().get(i).getRank().toInt()) {
+ num++;
+ }
+ }
+ if (num == 4) {
+ for (int j = handOfCards.getHand().getHandArrayList().size() - 1; j >= 0 ; j--) {
+ if (randomCardFromDealersHand == handOfCards.getHand().getHandArrayList().get(j).getRank().toInt()){
+ handOfCards.getHand().getHandArrayList().remove(handOfCards.getHand().getHandArrayList().get(j));
+ }
+ }
+ booksTotalDealer++;
+ System.out.println("\n!$!$!$!$!$!$! Dealer Scored a Book! (Four of a kind) !$!$!$!$!$!$!\n");
+ System.out.println("!!!!Dealer's Book total: " + booksTotalDealer + "\n");
+ }
+ checkForEmptyDeckOrHandOfDealerAfterCardFromPlayer();
+ }
+
+ public void checkBookCountDealerAfterGoFish(int randomCardFromDealersHand, Person handOfCards){
+
+ int num = 0;
+
+ for(int i = 0; i < handOfCards.getHand().getHandArrayList().size(); i++) {
+ if (randomCardFromDealersHand == handOfCards.getHand().getHandArrayList().get(i).getRank().toInt()) {
+ num++;
+ }
+ }
+ if (num == 4) {
+
+ for (int j = handOfCards.getHand().getHandArrayList().size() - 1; j >= 0 ; j--) {
+ if (randomCardFromDealersHand == handOfCards.getHand().getHandArrayList().get(j).getRank().toInt()){
+ handOfCards.getHand().getHandArrayList().remove(handOfCards.getHand().getHandArrayList().get(j));
+ }
+ }
+ booksTotalDealer++;
+ System.out.println("\n!$!$!$!$!$!$! Dealer Scored a Book! (Four of a kind) !$!$!$!$!$!$!\n");
+ System.out.println("!!!!Dealer's Book total: " + booksTotalDealer + "\n");
+ }
+ checkForEmptyDeckOrHandOfDealerAfterGoFish();
+ }
+
+ // Asks Player if they have the card requested
+ public int doYouHaveTheCardThatIWantFromComputer(int userInputSave, Person handOfCards){
+
+ int counter = 0;
+
+ for(int i = 0; i < handOfCards.getHand().getHandArrayList().size(); i++){
+ if (userInputSave == handOfCards.getHand().getHandArrayList().get(i).getRank().toInt()){
+ counter++;
+ }
+ }
+
+ if (counter > 0){
+ System.out.println("\n*** You found requested Card : " + userInputSave + "!***\n");
+ removeCardsFromComputerPlayerAndIntoHand(userInputSave, dealer, player1);
+ return 1;
+
+ } else {
+ System.out.println("\n*** Computer's hand does not have card ***\n");
+ goFishPlayer(player1);
+ //checkNumberOfCards();
+ return 0;
+ }
+
+ }
+
+ public int doYouHaveTheCardThatIWantFromPlayer(int randomCardFromDealersHand, Person handOfCards){
+
+ int counter = 0;
+
+ for(int i = 0; i < handOfCards.getHand().getHandArrayList().size(); i++){
+ if (randomCardFromDealersHand == handOfCards.getHand().getHandArrayList().get(i).getRank().toInt()){
+ counter++;
+ }
+ }
+ if (counter > 0){
+ System.out.println("\n*** Computer found requested Card : " + randomCardFromDealersHand + "!***\n");
+ removeCardsFromPlayerAndIntoComputerHand(randomCardFromDealersHand, player1, dealer);
+ return 1;
+
+ } else {
+ System.out.println("\n*** Player's hand does not have card ***\n");
+ goFishDealer(dealer);
+ //userTurn();
+ return 0;
+ }
+
+ }
+
+ // Removes Cards from player that has been asked and returns card to player that asked
+ public int removeCardsFromComputerPlayerAndIntoHand(int userInputSave, Person giveHandOfCards, Person receiveHandOfCards){
+
+ for(int i = giveHandOfCards.getHand().getHandArrayList().size() - 1; i >= 0; i--){
+ if (userInputSave == giveHandOfCards.getHand().getHandArrayList().get(i).getRank().toInt()){
+ receiveHandOfCards.getHand().getHandArrayList().add(giveHandOfCards.getHand().getHandArrayList().get(i));
+ giveHandOfCards.getHand().getHandArrayList().remove(i);
+ }
+ }
+ checkBookCount(userInputSave, player1);
+ return userInputSave;
+ }
+
+ public int removeCardsFromPlayerAndIntoComputerHand(int randomCardFromDealersHand, Person giveHandOfCards, Person receiveHandOfCards){
+
+ for(int i = giveHandOfCards.getHand().getHandArrayList().size() - 1; i >= 0; i--){
+ if (userInputSave == giveHandOfCards.getHand().getHandArrayList().get(i).getRank().toInt()){
+ receiveHandOfCards.getHand().getHandArrayList().add(giveHandOfCards.getHand().getHandArrayList().get(i));
+ giveHandOfCards.getHand().getHandArrayList().remove(i);
+ }
+ }
+ checkBookCountDealer(userInputSave, dealer);
+ return randomCardFromDealersHand;
+ }
+
+ public void goFishPlayer(Person recieveCardFromDeck){
+ System.out.println("********************");
+ System.out.println(" Player Go Fish!");
+ System.out.println("********************");
+ System.out.println("");
+
+ player1.getHand().getHandArrayList().add(houseDeck.drawCard());
+
+ for(int i = 0; i < player1.getHand().getHandArrayList().size(); i++){
+ userInputSave = player1.getHand().getHandArrayList().get(i).getRank().toInt();
+ }
+
+ System.out.println("\u270B Total deck of cards count: " + houseDeck.getDeckOfCards().size() + "\n");
+ checkBookCountAfterGoFish(userInputSave, player1);
+ //return houseDeck.drawCard();
+ }
+
+ public void goFishDealer(Person recieveCardFromDeck){
+ System.out.println("********************");
+ System.out.println(" Dealer Go Fish!");
+ System.out.println("********************");
+ System.out.println("");
+
+ if (houseDeck.getDeckOfCards().size() == 0 || dealer.getHand().getHandArrayList().size() == 0) {
+ System.out.println("Out of Cards!");
+ whoWonTheGame();
+
+ } else {
+ dealer.getHand().getHandArrayList().add(houseDeck.drawCard());
+
+ for(int i = 0; i < dealer.getHand().getHandArrayList().size(); i++){
+ randomCardFromDealersHand = dealer.getHand().getHandArrayList().get(i).getRank().toInt();
+ }
+ System.out.println("\u270B Total deck of cards count: " + houseDeck.getDeckOfCards().size() + "\n");
+ checkBookCountDealerAfterGoFish(randomCardFromDealersHand, dealer);
+ }
+
+ }
+
+ public void dealCards() {
+
+ }
+
+ public int checkNumberOfCards(Hand hand) {
+
+ System.out.println("Your hand: " + "\u270B" + player1.getHand().getHandArrayList() + "\u270B");
+
+ return player1.getHand().getHandArrayList().size();
+ }
+
+ public int checkNumberOfCard() {
+
+ System.out.println("Your hand: " + "\u270B" + player1.getHand().getHandArrayList() + "\u270B");
+
+ return player1.getHand().getHandArrayList().size();
+ }
+
+ public void checkForEmptyDeckOrHandOfUserAfterGoFish(){
+ if (houseDeck.getDeckOfCards().size() == 0 || player1.getHand().getHandArrayList().size() == 0){
+ whoWonTheGame();
+ } else {
+ dealerTurn();
+ }
+ }
+ public void checkForEmptyDeckOrHandOfUserAfterCardFromComputer(){
+ if (houseDeck.getDeckOfCards().size() == 0 || player1.getHand().getHandArrayList().size() == 0){
+ whoWonTheGame();
+ } else {
+ userTurn();
+ }
+ }
+
+ public void checkForEmptyDeckOrHandOfDealerAfterGoFish(){
+ if (houseDeck.getDeckOfCards().size() == 0 || dealer.getHand().getHandArrayList().size() == 0){
+ whoWonTheGame();
+ } else {
+ userTurn();
+ }
+ }
+
+ public void checkForEmptyDeckOrHandOfDealerAfterCardFromPlayer(){
+ if (houseDeck.getDeckOfCards().size() == 0 || dealer.getHand().getHandArrayList().size() == 0){
+ whoWonTheGame();
+ } else {
+ dealerTurn();
+ }
+ }
+
+ public void whoWonTheGame(){
+ if (booksTotalPlayer > booksTotalDealer){
+ System.out.println("************************* You Won! *************************");
+ System.out.println("\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\n" +
+ " You won the game with a total Book Score of " + booksTotalPlayer + "!\n" +
+ " Dealer lost game with a total Book Score of " + booksTotalDealer + "!\n" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B");
+ System.out.println("************************* You Won! *************************\n");
+ } else if (booksTotalPlayer == booksTotalDealer) {
+ System.out.println("************************* You Tied! *************************");
+ System.out.println("\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\n" +
+ " Both Players Tied with a total Book Score of " + booksTotalPlayer + "!\n" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B");
+ System.out.println("************************* You Tied! *************************\n");
+ } else {
+ System.out.println("************************* You Lost! *************************");
+ System.out.println("\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\n" +
+ " You Lost! Dealer had a Book Score of " + booksTotalDealer + "!\n" +
+ " You had a Book Score of " + booksTotalPlayer + "!\n" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B" +
+ "\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B\u270B");
+ System.out.println("************************* You Lost! *************************\n");
+ }
+ end();
+ }
+
+ public void end() {
+
+ booksTotalPlayer = 0;
+ booksTotalDealer = 0;
+
+ player1.getHand().getHandArrayList().clear();
+ dealer.getHand().getHandArrayList().clear();
+
+ System.out.println("Play another round? yes or no...");
+ if (anotherRoundScanner.nextLine().equalsIgnoreCase("yes")) {
+ start();
+ } else {
+ System.out.println("Thanks for playing!");
+ }
+ }
+
+// public static void main(String[] args) {
+// GoFish game = new GoFish();
+// game.start();
+//
+// }
+}
diff --git a/src/main/java/io/zipcoder/casino/Hand.java b/src/main/java/io/zipcoder/casino/Hand.java
new file mode 100644
index 00000000..639bf8d5
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Hand.java
@@ -0,0 +1,52 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+
+public class Hand {
+
+ private ArrayList handArrayList;
+ private ArrayList specificCardsArrayList;
+ private Rank rank;
+ private Suit suit;
+
+ public Hand() {
+ this.handArrayList = new ArrayList();
+ this.specificCardsArrayList = new ArrayList();
+ }
+
+ public ArrayList getHandArrayList() {
+ return handArrayList;
+ }
+
+ public ArrayList getSpecificCardsArrayList(Card... cards) {
+
+ for (Card card : cards) {
+ handArrayList.remove(card);
+ specificCardsArrayList.add(card);
+ }
+
+ return specificCardsArrayList;
+ }
+
+ public void receiveCards(Card... cards) {
+ for (Card card : cards) {
+ handArrayList.add(0, card);
+ }
+ }
+
+ public Card drawCardfromHand() {
+
+ return handArrayList.remove(handArrayList.size() - 1);
+ }
+
+ public void clearHand() {
+ handArrayList.clear();
+ }
+
+ public void shuffleHand() {
+ Collections.shuffle(handArrayList);
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Main.java b/src/main/java/io/zipcoder/casino/Main.java
new file mode 100644
index 00000000..c40acd09
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Main.java
@@ -0,0 +1,10 @@
+package io.zipcoder.casino;
+
+public class Main {
+
+ public static void main(String[] args) {
+ Person player = Casino.newPlayer();
+ Casino.sendPlayerToGame(player);
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/MainMenu.java b/src/main/java/io/zipcoder/casino/MainMenu.java
new file mode 100644
index 00000000..b7b21817
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/MainMenu.java
@@ -0,0 +1,65 @@
+package io.zipcoder.casino;
+
+import java.awt.*;
+import java.util.*;
+import java.util.Scanner;
+
+
+public class MainMenu {
+
+ Game game;
+
+ public MainMenu() {
+ this.game = game;
+ }
+
+ public void setMainMenu(Game game) {
+ this.game = game;
+ }
+
+ public Game getMainMenu() {
+ return game;
+ }
+
+ public String displayGameChoices() {
+ Scanner in = new Scanner(System.in);
+ String choice;
+ do {
+ System.out.println("Please choose a game from the following menu:\nWar\nGo Fish\nBlackJack\nCraps" +
+ "\nCoin Flipper");
+ choice = in.nextLine().toLowerCase();
+ } while ( !(choice.equals("craps")) && !(choice.equals("go fish")) && !(choice.equals("war")) &&
+ !(choice.equals("blackjack")) && !(choice.equals("coin flipper")));
+ return choice;
+ }
+
+
+
+ public static Game chooseGame(String choice, Person player) {
+
+ Game game;
+ switch (choice) {
+ case "war":
+ game = new War(player);
+ break;
+ case "go fish":
+ game = new GoFish(player);
+ break;
+ case "blackjack":
+ game = new Blackjack(player);
+ break;
+ case "craps":
+ game = new Craps(player);
+ break;
+ case "coin flipper":
+ game = new CoinFlipper(player);
+ break;
+
+ default:
+ return null;
+ }
+
+ return game;
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/Person.java b/src/main/java/io/zipcoder/casino/Person.java
new file mode 100644
index 00000000..67d83e6b
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Person.java
@@ -0,0 +1,44 @@
+package io.zipcoder.casino;
+
+
+import java.util.Scanner;
+
+public class Person {
+ private String name = "";
+ private Hand hand = null;
+ private Wallet wallet = null;
+
+
+ protected Person(){ }
+
+ public Person(String name) {
+ this.name = name;
+ this.hand = new Hand();
+ this.wallet = new Wallet();
+ }
+
+
+ public String getName() {
+ return this.name;
+ }
+
+ public Hand getHand() {
+ return this.hand;
+ }
+
+ public Wallet getWallet() {
+ return this.wallet;
+ }
+
+ //has Scanner and Wilhelm told me not to test methods with Scanner
+ public static Person createNewPlayerFromUserInput() {
+ String playerName;
+ Scanner in = new Scanner(System.in);
+ System.out.println("Welcome to our casino! Please enter your name");
+ playerName = in.nextLine();
+ return new Person(playerName);
+ }
+
+
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Rank.java b/src/main/java/io/zipcoder/casino/Rank.java
new file mode 100644
index 00000000..fe546b9c
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Rank.java
@@ -0,0 +1,35 @@
+package io.zipcoder.casino;
+
+public enum Rank {
+
+ DEUCE(2,"2"),
+ THREE(3,"3"),
+ FOUR(4,"4"),
+ FIVE(5,"5"),
+ SIX(6,"6"),
+ SEVEN(7,"7"),
+ EIGHT(8,"8"),
+ NINE(9,"9"),
+ TEN(10,"10"),
+ JACK(11,"J"),
+ QUEEN(12,"Q"),
+ KING(13,"K"),
+ ACE(1,"A");
+
+ final int rankValue;
+ final String rankSymbol;
+
+ Rank(int rankValue, String rankSymbol) {
+ this.rankValue = rankValue;
+ this.rankSymbol = rankSymbol;
+ }
+
+ public int toInt() {
+ return this.rankValue;
+ }
+
+ public String toString() {
+ return this.rankSymbol;
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Scoreboard.java b/src/main/java/io/zipcoder/casino/Scoreboard.java
new file mode 100644
index 00000000..de93a58a
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Scoreboard.java
@@ -0,0 +1,115 @@
+package io.zipcoder.casino;
+
+import java.util.*;
+
+
+
+public class Scoreboard {
+
+ private LinkedHashMap scoreboard;
+
+
+
+ public Scoreboard() {
+ this.scoreboard = new LinkedHashMap();
+ }
+
+ public Scoreboard(Person... people) {
+ this.scoreboard = new LinkedHashMap();
+ for(int i = 0; i scoreboard) {
+ this.scoreboard = scoreboard;
+
+ }
+
+ public void setScoreboard(LinkedHashMap scoreboard) {
+ this.scoreboard = scoreboard;
+ }
+
+ public LinkedHashMap getScoreboard() {
+ return scoreboard;
+ }
+
+ public Person[] getPlayers() {
+ Set players = scoreboard.keySet();
+ Person[] playerArray = players.toArray(new Person[players.size()]);
+ return playerArray;
+ }
+
+ public void addPlayer(Person person) {
+ this.scoreboard.put(person, 0);
+ }
+
+ public void removePlayer(Person person) {
+ this.scoreboard.remove(person);
+ }
+
+ public void updateScore(Person person, Integer newScore){
+ for(Map.Entry entry: this.scoreboard.entrySet()) {
+ if(scoreboard.containsKey(person) && person.equals(entry.getKey())) {
+ scoreboard.put(person, newScore);
+ }
+ }
+ }
+
+
+ public void resetScoreboardForSamePlayers() {
+ for(Map.Entry entry: this.scoreboard.entrySet()) {
+ if(entry.getKey().equals(entry.getKey())) {
+ scoreboard.put(entry.getKey(), 0);
+ }
+ }
+ }
+
+ public void clearScoreboardOfPlayersAndScores() {
+ this.scoreboard.clear();
+ }
+
+
+ //single player score at request of player during game
+ public Integer getScore(Person person) {
+ return scoreboard.get(person);
+ }
+
+
+ public String displayScoreboardSingleGame() {
+ String display = String.format("%-15s | %-10s\n", "Name", "Score");
+ display += "------------------------\n";
+ for(Map.Entry entry: scoreboard.entrySet()) {
+ String name = entry.getKey().getName();
+ String score = entry.getValue().toString();
+ display += String.format("%-15s | ", name);
+ display += String.format("%-10s\n", score);
+ }
+ return display;
+ }
+
+/* public String displayRunningGameTally() {
+ LinkedHashMap> runningTally = new LinkedHashMap>();
+ String tally = String.format("%-15s | %-10s \n", "Name", "Games");
+ tally += "---------------------------------------\n";
+ for(Map.Entry entry: scoreboard.entrySet()) {
+ for(Map.Entry> secondEntry: runningTally.entrySet()) {
+ if(!(runningTally.containsKey(entry.getKey()))) {
+ ArrayList tallyList = new ArrayList(Arrays.asList(entry.getValue()));
+ runningTally.put(entry.getKey(), tallyList);
+ }
+ if((runningTally.containsKey(entry.getKey()))) {
+ secondEntry.getValue().add(entry.getValue());
+ }
+ }
+ }
+ for(Map.Entry> secondEntry: runningTally.entrySet()) {
+ String key = secondEntry.getKey().getName();
+ tally += String.format("%-15s | \n", key);
+ }
+ return tally;
+ }
+ */
+
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Suit.java b/src/main/java/io/zipcoder/casino/Suit.java
new file mode 100644
index 00000000..8e5a58de
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Suit.java
@@ -0,0 +1,31 @@
+package io.zipcoder.casino;
+
+public enum Suit {
+
+ CLUBS("clubs", "\u2663"),
+ DIAMONDS("diamonds", "\u2666"),
+ HEARTS("hearts", "\u2665"),
+ SPADES("spades", "\u2660");
+
+ final String suitWord;
+ final String suitSymbol;
+
+ Suit(String suitWord, String suitSymbol) {
+ this.suitWord = suitWord;
+ this.suitSymbol = suitSymbol;
+ }
+
+ // Modified toString on Sat Feb 24 to return suitSymbol and not suitWord
+// public String toString() {
+// return this.suitWord;
+// }
+
+ public String toString() {
+ return this.suitSymbol;
+ }
+
+ public String toSymbol() {
+ return this.suitSymbol;
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Wallet.java b/src/main/java/io/zipcoder/casino/Wallet.java
new file mode 100644
index 00000000..6eae3e4b
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Wallet.java
@@ -0,0 +1,53 @@
+package io.zipcoder.casino;
+
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+public class Wallet {
+
+ private int chipAmount;
+
+ public Wallet(){
+ this.chipAmount = 0;
+ }
+
+ public void addChipsToAmount(int chipsToAdd) {
+ this.chipAmount = this.chipAmount + chipsToAdd;
+ }
+
+ public void removeChipsFromAmount(int chipsToRemove) {
+ this.chipAmount = this.chipAmount - chipsToRemove;
+ }
+
+ public int checkChipAmount(){
+ return this.chipAmount;
+ }
+
+ //has Scanner and Wilhelm told me not to test methods with Scanner
+ //is called in sendNewPlayerToGame in Casino
+ public void fillPlayerWalletFromUserInput() {
+ String isGambling;
+ int walletAmount;
+ Scanner in = new Scanner(System.in);
+ do {
+ System.out.println("If you will be playing a gambling game press y, if not, press n.");
+ isGambling = in.nextLine();
+ } while (!(isGambling.equals("y")) && !(isGambling.equals("n")));
+ if(isGambling.equals("y")) {
+ System.out.println("Please enter number of chips you would like to begin with");
+ walletAmount = getUserInput();
+ addChipsToAmount(walletAmount);
+ }
+ }
+
+ private int getUserInput(){
+ Scanner in = new Scanner(System.in);
+ try {
+ return in.nextInt();
+ } catch (InputMismatchException e){
+ System.out.println("Input not recognized. Setting chips to 500.");
+ return 500;
+ }
+ }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/War.java b/src/main/java/io/zipcoder/casino/War.java
new file mode 100644
index 00000000..d1942b62
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/War.java
@@ -0,0 +1,176 @@
+package io.zipcoder.casino;
+
+import java.util.*;
+
+public class War extends Game implements GameInterface, CardGameInterface {
+
+ private boolean gameIsRunning;
+ private Dealer dealer = new Dealer();
+ private Person player;
+ private ArrayList playerPlayedCards = new ArrayList();
+ private ArrayList dealerPlayedCards = new ArrayList();
+ private Scanner input = new Scanner(System.in);
+
+ public War(Person player) {
+ this.player = player;
+ }
+
+ public void start() {
+ gameIsRunning = true;
+ System.out.println("Welcome to WAR! Enter anything into the console to play a card");
+ System.out.println("Enter 'exit' at any time to end the game");
+ Deck dealerDeck = new Deck();
+ for (int i = 0; i < dealerDeck.getDeckOfCards().size(); i++) {
+ dealer.getHand().receiveCards(dealerDeck.getDeckOfCards().get(i));
+ }
+ dealer.getHand().shuffleHand();
+ dealCards();
+ engine();
+ }
+
+ // Make private after testing / Make public for testing
+ public void engine() {
+ // String playerInput = input.nextLine();
+ if (nextLineIsNotExit()) {
+ while (gameIsRunning == true) {
+ while (!handOfPersonIsEmpty(dealer) && !handOfPersonIsEmpty(player)) {
+ playerPlayedCards.add(player.getHand().drawCardfromHand());
+ dealerPlayedCards.add(dealer.getHand().drawCardfromHand());
+ System.out.println("You played " + playerPlayedCards + " and the dealer played " + dealerPlayedCards);
+ int winner =
+ compareCards(
+ getLastCardPlayedOnTable(playerPlayedCards),
+ getLastCardPlayedOnTable(dealerPlayedCards));
+ announceWinner(winner);
+ if (!nextLineIsNotExit()) {
+ end();
+ }
+ checkIfGameIsOver();
+ }
+ }
+ } else {end();}
+ }
+
+ private void checkIfGameIsOver() {
+ if (handOfPersonIsEmpty(player) || handOfPersonIsEmpty(dealer)) {
+ end();
+ }
+ }
+
+ private boolean handOfPersonIsEmpty(Person person) {
+ return person.getHand().getHandArrayList().size() == 0;
+ }
+
+ private void announceWinner(int winnerNumber) {
+ if (winnerNumber == 1) {
+ playerWins();
+ } else if (winnerNumber == 2) {
+ dealerWins();
+ }
+ }
+
+ private Card getLastCardPlayedOnTable(ArrayList cardsOnTable) {
+ return cardsOnTable.get(cardsOnTable.size() - 1);
+ }
+
+ private boolean nextLineIsNotExit() {
+ return !("exit").equals(input.nextLine());
+ }
+
+ public int compareCards(Card p1card, Card p2card) {
+ if (p1card.getRank().toInt() == p2card.getRank().toInt()) {
+ iDeclareWar();
+ } else if (p1card.getRank().toInt() > p2card.getRank().toInt()) {
+ return 1;
+ } else {return 2;}
+ return 0;
+ }
+
+ // Make private after testing / Make public for testing
+ public void playerWins() {
+ System.out.println("You won this round!");
+ giveCardsFromTheTableToTheWinner(playerPlayedCards, player);
+ giveCardsFromTheTableToTheWinner(dealerPlayedCards, player);
+ somebodyWonMessage();
+ }
+
+ // Make private after testing / Make public for testing
+ public void dealerWins() {
+ System.out.println("You lost this round!");
+ giveCardsFromTheTableToTheWinner(playerPlayedCards, dealer);
+ giveCardsFromTheTableToTheWinner(dealerPlayedCards, dealer);
+ somebodyWonMessage();
+ }
+
+ public void giveCardsFromTheTableToTheWinner(ArrayList tableDeck, Person person) {
+ while (tableDeck.size() != 0) {
+ person.getHand().receiveCards(tableDeck.remove(0));
+ }
+ }
+
+ public void somebodyWonMessage() {
+ System.out.println("You have " + player.getHand().getHandArrayList().size() + " cards and the dealer has " + dealer.getHand().getHandArrayList().size() + " cards");
+ }
+
+ // Make private after testing / Make public for testing
+ public void iDeclareWar() {
+ System.out.println("I D E C L A R E W A R!");
+ int amountOfPlayerAvailibleCards = checkNumberOfCards(player.getHand());
+ int amountOfDealerAvailibleCards = checkNumberOfCards(dealer.getHand());
+ iDeclareWarLogic(playerPlayedCards, player, amountOfPlayerAvailibleCards);
+ iDeclareWarLogic(dealerPlayedCards, dealer, amountOfDealerAvailibleCards);
+ }
+
+ // Make private after testing / Make public for testing
+ public void iDeclareWarLogic(ArrayList playedCards, Person person, int amountOfCardsAvailable) {
+ for (int i = 0; i < decideOnHowManyTimesToIterateBasedOn(amountOfCardsAvailable); i++) {
+ playCardInHandForPerson(playedCards, person, i);
+ }
+ }
+
+ // Make private after testing / Make public for testing
+ public int decideOnHowManyTimesToIterateBasedOn(int amountOfCardsAvailable) {
+ if(amountOfCardsAvailable <= 4) {
+ return amountOfCardsAvailable -1;
+ }
+ return 4;
+ }
+
+ // Make private after testing / Make public for testing
+ public void playCardInHandForPerson(ArrayList playedCards, Person person, int i) {
+ playedCards.add(person.getHand().drawCardfromHand());
+ }
+
+ public void dealCards() {
+ for (int i = dealer.getHand().getHandArrayList().size()-1; i >= 26; i--) {
+ player.getHand()
+ .getHandArrayList()
+ .add(dealer
+ .getHand()
+ .getHandArrayList()
+ .remove(i));
+ }
+ }
+
+ public void end() {
+ String winner = "";
+ if (player.getHand().getHandArrayList().size() > 25) {
+ winner += "you!";
+ } else {
+ winner += "the dealer!";
+ }
+ System.out.println("And the winner is " + winner);
+ player.getHand().clearHand();
+ dealer.getHand().clearHand();
+ System.out.println("If you want to play again, enter 'yes', or enter anything else to return to the casino");
+ if (input.nextLine().equals("yes")) {
+ start();
+ }
+ gameIsRunning = false;
+ }
+
+ public int checkNumberOfCards(Hand handToCheck) {
+ return handToCheck.getHandArrayList().size();
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/BlackjackTest.java b/src/test/java/io/zipcoder/casino/BlackjackTest.java
new file mode 100644
index 00000000..506dedf6
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/BlackjackTest.java
@@ -0,0 +1,198 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class BlackjackTest {
+
+ private Blackjack blackjack;
+ Person player = new Person("test");
+
+ @Before public void setUp() {
+ player.getWallet().addChipsToAmount(500);
+
+ }
+
+ @Test
+ public void BlackJackDefaultConstructorTest() {
+ /**
+ * construct a blackjack game
+ * - extends class Game
+ * - implements Card interface
+ * - implements Gambling interface
+ */
+ // Given
+ String expectedPlayerName = "test";
+ // When
+ Blackjack blackjack = new Blackjack(player);
+ String actualPlayerName = blackjack.getPlayer().getName();
+ // Then
+ Assert.assertEquals(expectedPlayerName, actualPlayerName);
+ }
+
+ @Test
+ public void sumOfRanksInHandTest() {
+ Blackjack blackjack = new Blackjack(player);
+ // Add cards to player1 Hand
+ Card notShuffled0 = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card notShuffled1 = new Card(Rank.ACE, Suit.DIAMONDS);
+ Card notShuffled2 = new Card(Rank.ACE, Suit.HEARTS);
+ Card notShuffled3 = new Card(Rank.ACE, Suit.SPADES);
+ blackjack.getPlayer().getHand().receiveCards(notShuffled0, notShuffled1, notShuffled2, notShuffled3);
+
+ // Add cards to Dealer Hand
+ Card dealerCard0 = new Card(Rank.ACE, Suit.CLUBS);
+ Card dealerCard1 = new Card(Rank.TEN, Suit.DIAMONDS);
+ Card dealerCard2 = new Card(Rank.JACK, Suit.HEARTS);
+ Card dealerCard3 = new Card(Rank.FIVE, Suit.SPADES);
+ blackjack.getDealer().getHand().receiveCards(dealerCard0, dealerCard1, dealerCard2, dealerCard3);
+
+ // Given
+ int expectedPersonHandSum = 5; // 5 = 2 + 1 + 1 + 1
+ int expectedDealerHandSum = 26; // 26 = 1 + 10 + 10 + 5
+ // When
+ int actualPersonHandSum = blackjack.sumOfRanksInHand(blackjack.getPlayer());
+ int actualDealerHandSum = blackjack.sumOfRanksInHand(blackjack.getDealer());
+ // Then
+ Assert.assertEquals(expectedPersonHandSum, actualPersonHandSum);
+ Assert.assertEquals(expectedDealerHandSum, actualDealerHandSum);
+ }
+
+ @Test
+ public void countRankRepetitionsInHandTest() {
+ Blackjack blackjack = new Blackjack(player);
+
+ // Add cards to player1 Hand
+ Card notShuffled0 = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card notShuffled1 = new Card(Rank.ACE, Suit.DIAMONDS);
+ Card notShuffled2 = new Card(Rank.ACE, Suit.HEARTS);
+ Card notShuffled3 = new Card(Rank.ACE, Suit.SPADES);
+ blackjack.getPlayer().getHand().receiveCards(notShuffled0, notShuffled1, notShuffled2, notShuffled3);
+
+ // Add cards to Dealer Hand
+ Card dealerCard0 = new Card(Rank.SIX, Suit.CLUBS);
+ Card dealerCard1 = new Card(Rank.SIX, Suit.DIAMONDS);
+ Card dealerCard2 = new Card(Rank.EIGHT, Suit.HEARTS);
+ //Card dealerCard3 = new Card(Rank.FIVE, Suit.SPADES);
+ blackjack.getDealer().getHand().receiveCards(dealerCard0, dealerCard1, dealerCard2);
+
+ // Given
+ int expectedPersonRankReps = 3; // ACE
+ int expectedDealerRankReps = 2; // SIX
+ // When
+ int actualPersonRankReps = blackjack.countRankRepetitionsInHand(blackjack.getPlayer(), notShuffled1);
+ int actualDealerRankReps = blackjack.countRankRepetitionsInHand(blackjack.getDealer(), dealerCard0);
+ // Then
+ Assert.assertEquals(expectedPersonRankReps, actualPersonRankReps);
+ Assert.assertEquals(expectedDealerRankReps, actualDealerRankReps);
+ }
+
+ @Test
+ public void findSmallerOfTwoIntsTest() {
+ // Given
+ Blackjack blackjack = new Blackjack(player);
+ int expectedLowerInt = 5;
+ int expectedHigherInt = 7;
+ // When
+ int actualLowerInt = blackjack.findSmallerOfTwoInts(expectedLowerInt, expectedHigherInt);
+ // Then
+ Assert.assertEquals(expectedLowerInt, actualLowerInt);
+ }
+
+ @Test
+ public void findGreaterOfTwoIntsTest() {
+ // Given
+ Blackjack blackjack = new Blackjack(player);
+ int expectedLowerInt = 5;
+ int expectedHigherInt = 7;
+ // When
+ int actualHigherInt = blackjack.findGreaterOfTwoInts(expectedLowerInt, expectedHigherInt);
+ // Then
+ Assert.assertEquals(expectedHigherInt, actualHigherInt);
+ }
+
+ @Test
+ public void personDecisionTest() {
+ Blackjack blackjack = new Blackjack(player);
+ //String playerDecisionString = blackjack.personDecision(blackjack.getPlayer());
+ }
+
+ @Test
+ public void handToStringTest() {
+ // Given
+ Blackjack blackjack = new Blackjack(player);
+ blackjack.getPlayer().getHand().receiveCards(new Card(Rank.DEUCE, Suit.CLUBS), new Card(Rank.THREE, Suit.DIAMONDS),
+ new Card(Rank.FOUR, Suit.HEARTS), new Card(Rank.FIVE, Suit.SPADES));
+ String expectedHandToString = "5♠ 4♥ 3♦ 2♣";
+ // When
+ String actualHandToString = blackjack.handToString(blackjack.getPlayer().getHand().getHandArrayList());
+ System.out.println(actualHandToString);
+ // Then
+ Assert.assertEquals(expectedHandToString, actualHandToString);
+ }
+
+ @Test
+ public void hitTest() {
+ // if playerSum < 21, player can hit
+ // if playerDecision = "hit", then dealer draws card and player hand receives card
+ Blackjack blackjack = new Blackjack(player);
+
+ // Add cards to player1 Hand
+ Card playerCard0 = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card playerCard1 = new Card(Rank.THREE, Suit.DIAMONDS);
+ blackjack.getPlayer().getHand().receiveCards(playerCard0, playerCard1);
+
+ // Add cards to Dealer Hand
+ Card dealerCard0 = new Card(Rank.SIX, Suit.CLUBS);
+ Card dealerCard1 = new Card(Rank.SEVEN, Suit.DIAMONDS);
+ blackjack.getDealer().getHand().receiveCards(dealerCard0, dealerCard1);
+
+ // Given
+ blackjack.hit(blackjack.getPlayer());
+ blackjack.hit(blackjack.getDealer());
+ int expectedPlayerHandSize = 3;
+ int expectedDealerHandSize = 3;
+ // When
+ int actualPlayerHandSize = blackjack.getPlayer().getHand().getHandArrayList().size();
+ int actualDealerHandSize = blackjack.getDealer().getHand().getHandArrayList().size();
+ // Then
+ Assert.assertEquals(expectedPlayerHandSize, actualPlayerHandSize);
+ Assert.assertEquals(expectedDealerHandSize, actualDealerHandSize);
+ }
+
+ // Will keep this for future reference
+// @Test
+// public void askForPlayerNameTest() {
+// // Given
+// String expectedName = "Luis";
+// // When
+// Blackjack blackjack = new Blackjack("Luis", 50);
+// String askedName = blackjack.askForPlayerName();
+// String actualName = blackjack.getPlayer().getName();
+// // Then
+// Assert.assertEquals(expectedName, actualName);
+// }
+
+ // GamblingInterface
+ @Test
+ public void placeBetTest() {
+ // Given
+ int betPlaced = 1;
+ int chipsToStart = 500;
+ int expectedChipsRemaining = chipsToStart - betPlaced; // 499
+ // When
+ Blackjack blackjack = new Blackjack(player);
+ blackjack.placeBet(blackjack.getPlayer(), betPlaced); // will remove 1 chip
+ int actualChipsRemaining = blackjack.getPlayer().getWallet().checkChipAmount();
+ // Then
+ Assert.assertEquals(expectedChipsRemaining,actualChipsRemaining);
+ }
+
+ @Test
+ public void checkNumberOfCards() {
+
+ }
+}
diff --git a/src/test/java/io/zipcoder/casino/CardTest.java b/src/test/java/io/zipcoder/casino/CardTest.java
new file mode 100644
index 00000000..f9c756d8
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/CardTest.java
@@ -0,0 +1,71 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.Before;
+
+public class CardTest {
+
+ private Card card;
+
+ @Test
+ public void CardConstructorRankPositiveTest() {
+
+ // Given
+ Rank expectedRank = Rank.DEUCE;
+ Suit expectedSuit = Suit.CLUBS;
+ Card card = new Card(Rank.DEUCE, Suit.CLUBS);
+
+ // When
+ Rank actualRank = card.getRank();
+ Suit actualSuit = card.getSuit();
+
+ // Then
+ Assert.assertEquals(expectedRank, actualRank);
+ Assert.assertEquals(expectedSuit, actualSuit);
+ }
+
+ @Test
+ public void getRankPositiveTest() {
+
+ // Given
+ Rank expectedRank = Rank.SEVEN;
+ Card card = new Card(Rank.SEVEN, Suit.SPADES);
+
+ // When
+ Rank actualRank = card.getRank();
+
+ // Then
+ Assert.assertEquals(expectedRank, actualRank);
+ }
+
+ @Test
+ public void getSuitPositiveTest() {
+
+ // Given
+ Suit expectedSuit = Suit.DIAMONDS;
+ Card card = new Card(Rank.EIGHT, Suit.DIAMONDS);
+
+ // When
+ Suit actualSuit = card.getSuit();
+
+ // Then
+ Assert.assertEquals(expectedSuit, actualSuit);
+
+ }
+
+ @Test
+ public void toStringPositiveTest() {
+
+ // Given
+ String expectedString = "J of hearts";
+ Card card = new Card(Rank.JACK, Suit.HEARTS);
+
+ // When
+ String actualString = card.toString();
+
+ // Then
+ Assert.assertEquals(expectedString, actualString);
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/io/zipcoder/casino/CasinoTest.java b/src/test/java/io/zipcoder/casino/CasinoTest.java
index e9286523..013b4009 100644
--- a/src/test/java/io/zipcoder/casino/CasinoTest.java
+++ b/src/test/java/io/zipcoder/casino/CasinoTest.java
@@ -1,5 +1,13 @@
package io.zipcoder.casino;
+import org.junit.Assert;
+import org.junit.Test;
+
+import org.junit.Before;
+
public class CasinoTest {
+
+
}
+
diff --git a/src/test/java/io/zipcoder/casino/CoinFlipperTest.java b/src/test/java/io/zipcoder/casino/CoinFlipperTest.java
new file mode 100644
index 00000000..c5087d22
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/CoinFlipperTest.java
@@ -0,0 +1,20 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+public class CoinFlipperTest {
+
+ private static Person player = new Person("Joe");
+ private static CoinFlipper coinFlipper = new CoinFlipper(player);
+
+ public static void main(String[] args) {
+ player.getWallet().addChipsToAmount(1000);
+ coinFlipper.start();
+ }
+
+ @Test
+ public void coinFlipper() {
+ // What to test what to test
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/CoinTest.java b/src/test/java/io/zipcoder/casino/CoinTest.java
new file mode 100644
index 00000000..929b77c9
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/CoinTest.java
@@ -0,0 +1,49 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CoinTest {
+
+ private static Coin coin;
+
+ @Before
+ public void setup() {
+ this.coin = new Coin();
+ }
+
+ /**
+ * One of each test type should pass
+ * Or maybe not because I'm a dingus and don't know how to make good tests but if you run them enough times you'll get the idea
+ */
+
+ @Test
+ public void coinLogicTest1() {
+ int expected = 1;
+ int actual = coin.coinLogic();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void coinLogicTest2() {
+ int expected = 2;
+ int actual = coin.coinLogic();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void coinFlipTestHeads() {
+ String expected = "heads";
+ String actual = coin.flip();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void coinFlipTestTails() {
+ String expected = "tails";
+ String actual = coin.flip();
+ Assert.assertEquals(expected, actual);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/CrapsTest.java b/src/test/java/io/zipcoder/casino/CrapsTest.java
new file mode 100644
index 00000000..a416b79a
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/CrapsTest.java
@@ -0,0 +1,396 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CrapsTest {
+ Person personTest = new Person("Steve");
+ Craps crapsTest = new Craps(personTest);
+
+ @Before public void addMoney() {
+ personTest.getWallet().addChipsToAmount(500);
+ }
+
+
+ @Test
+ public void checkPassLineBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.SIX);
+ crapsTest.setPassLineBet(5);
+ crapsTest.setPoint(8);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 505;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkPassLineBetLose(){
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.SIX);
+ crapsTest.setPassLineBet(5);
+ crapsTest.setPoint(8);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkDontPassLineBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.SIX);
+ crapsTest.setDontPassLineBet(5);
+ crapsTest.setPoint(8);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 505;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkDontPassLineBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.SIX);
+ crapsTest.setDontPassLineBet(5);
+ crapsTest.setPoint(8);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkComeBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.SIX);
+ crapsTest.setPoint(8);
+ crapsTest.setComeBet(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 505;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkComeBeLose() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.ONE);
+ crapsTest.setPoint(8);
+ crapsTest.setComeBet(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkDontComeBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.ONE);
+ crapsTest.setPoint(8);
+ crapsTest.setDontComeBet(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 505;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkDontComeBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0,DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1,DieFace.SIX);
+ crapsTest.setPoint(8);
+ crapsTest.setDontComeBet(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected,actual);
+ }
+
+ @Test
+ public void checkFieldBetDoubleWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.ONE);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.ONE);
+ crapsTest.setFieldBet(10);
+ crapsTest.createFieldValues();
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 520;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkFieldBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.ONE);
+ crapsTest.setFieldBet(10);
+ crapsTest.createFieldValues();
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 510;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkFieldBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setFieldBet(10);
+ crapsTest.createFieldValues();
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPassOddsBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.TWO);
+ crapsTest.setPassOddsBet(10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 520;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPassOddsBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FIVE);
+ crapsTest.setPassOddsBet(10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkDontPassOddsWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FIVE);
+ crapsTest.setDontPassOddsBet(10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 515;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkDontPassOddsLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.TWO);
+ crapsTest.setDontPassOddsBet(10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkComePointBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setComeBetPoints(5,10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 510;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkComePointBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FIVE);
+ crapsTest.setComeBetPoints(5,10);
+ crapsTest.setComeBetPoints(4,10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkDontComePointBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FIVE);
+ crapsTest.setDontComeBetPoints(5,10);
+ crapsTest.setDontComeBetPoints(4,10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 520;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkDontComePointBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.TWO);
+ crapsTest.setDontComeBetPoints(4,10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkComePointOddsBetWin1() { // Checks Come Point Odds bet on 5s
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setComeBetPointOdds(5,10);
+ crapsTest.setPoint(4);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 525;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkComePointOddsBetWin2() { // Checks Come Point Odds bet on 4
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.TWO);
+ crapsTest.setComeBetPointOdds(4,10);
+ crapsTest.setPoint(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 530;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkComePointOddsBetWin3() { // Checks Come Point Odds bet on 6
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FOUR);
+ crapsTest.setComeBetPointOdds(6,10);
+ crapsTest.setPoint(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 522;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkComePointOddsBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.THREE);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FOUR);
+ crapsTest.setComeBetPointOdds(6,10);
+ crapsTest.setComeBetPointOdds(5,10);
+ crapsTest.setPoint(5);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkDontComePointOddsBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.THREE);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setDontComeBetPointOdds(6,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkDontComePointOddsBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.FOUR);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setDontComeBetPointOdds(6,10);
+ crapsTest.setDontComeBetPointOdds(5,10);
+ crapsTest.setDontComeBetPointOdds(4,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 549;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPlaceWinBet1() {//Checks Place Win on 6
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.THREE);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setPlaceWinBets(6,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 521;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPlaceWinBet2() {//Checks place win on 5
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.THREE);
+ crapsTest.setPlaceWinBets(5,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 524;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPlaceWinBet3() {//Checks place win on 4
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.TWO);
+ crapsTest.setPlaceWinBets(4,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 528;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPlaceWinLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FIVE);
+ crapsTest.setPlaceWinBets(4,10);
+ crapsTest.setPlaceWinBets(5,10);
+ crapsTest.setPlaceWinBets(6,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPlaceLoseBetWin() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FIVE);
+ crapsTest.setPlaceLoseBets(4,10);
+ crapsTest.setPlaceLoseBets(5,10);
+ crapsTest.setPlaceLoseBets(6,10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 548;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkPlaceLoseBetLose() {
+ crapsTest.getDiceManager().setSpecificDie(0, DieFace.TWO);
+ crapsTest.getDiceManager().setSpecificDie(1, DieFace.FOUR);
+ crapsTest.setPlaceLoseBets(6, 10);
+ crapsTest.setPoint(6);
+ crapsTest.checkPhaseTwoRolls();
+ int expected = 500;
+ int actual = crapsTest.getPlayer().getWallet().checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+}
diff --git a/src/test/java/io/zipcoder/casino/DealerTest.java b/src/test/java/io/zipcoder/casino/DealerTest.java
new file mode 100644
index 00000000..46c55bc6
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DealerTest.java
@@ -0,0 +1,33 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class DealerTest {
+
+ @Test
+ public void constructorTest() {
+ Dealer dealer = new Dealer();
+ String expected = "Dealer";
+ String actual = dealer.getName();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void getWalletTest() {
+ Dealer dealer = new Dealer();
+ Integer expected = Integer.MAX_VALUE;
+ Integer actual = dealer.getDealerWallet().checkChipAmount();
+ Assert.assertEquals(actual, expected);
+ }
+
+ @Test
+ public void getHandTest() {
+ Dealer dealer = new Dealer();
+ ArrayList expected = new ArrayList();
+ ArrayList actual = dealer.getHand().getHandArrayList();
+ Assert.assertEquals(actual, expected);
+ }
+}
diff --git a/src/test/java/io/zipcoder/casino/DealerWalletTest.java b/src/test/java/io/zipcoder/casino/DealerWalletTest.java
new file mode 100644
index 00000000..ccf832c8
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DealerWalletTest.java
@@ -0,0 +1,16 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DealerWalletTest {
+
+ @Test
+ public void dealerWalletRemoveTest() {
+ DealerWallet testWallet = new DealerWallet();
+ testWallet.removeChipsFromAmount(500);
+ Integer expected = Integer.MAX_VALUE;
+ Integer actual = testWallet.checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+}
diff --git a/src/test/java/io/zipcoder/casino/DeckTest.java b/src/test/java/io/zipcoder/casino/DeckTest.java
new file mode 100644
index 00000000..8fb735f6
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DeckTest.java
@@ -0,0 +1,57 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class DeckTest {
+
+ private Deck deckTest;
+ private Card cardTest;
+
+ @Test
+ public void DeckTest() {
+ //Given
+ Deck deckTest = new Deck();
+
+ //When
+ ArrayList expected = deckTest.getDeckOfCards();
+ ArrayList actual = deckTest.getDeckOfCards();
+
+ //Then
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void ShuffleDeckTest(){
+ //Given
+ Deck deckTest = new Deck();
+ deckTest.shuffleDeck();
+
+ //When
+ String expected = "";
+ System.out.println(expected);
+
+ ArrayList actual = deckTest.getDeckOfCards();
+ System.out.println(actual);
+
+ //Then
+ Assert.assertNotEquals(expected, actual);
+ }
+
+ @Test
+ public void DrawCardTest(){
+ //Given
+ Deck deckTest = new Deck();
+
+ //When
+ Card expected = deckTest.drawCard();
+ ArrayList actual = deckTest.getDeckOfCards();
+
+
+ //Then
+ Assert.assertNotEquals(expected, actual);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/DiceManagerTest.java b/src/test/java/io/zipcoder/casino/DiceManagerTest.java
new file mode 100644
index 00000000..ddbf93eb
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DiceManagerTest.java
@@ -0,0 +1,63 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DiceManagerTest {
+
+ @Test
+ public void amountOfDiceCreatedTest() {
+ DiceManager allDice = new DiceManager(5);
+ int expected = 5;
+ allDice.rollAllDice();
+ int actual = allDice.getAllDieFaces().length;
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void rollAllDiceTest() {
+ // This test may occasionally fail if the dice rolled all wind up on the same face, but that should be very rare
+ DiceManager allDice = new DiceManager(5);
+ allDice.rollAllDice();
+ int firstDieTotal = allDice.getTotalValue();
+ allDice.rollAllDice();
+ int secondDieTotal = allDice.getTotalValue();
+ Assert.assertNotEquals(firstDieTotal, secondDieTotal);
+ }
+
+ @Test
+ public void setSpecificDieFaceTest() {
+ DiceManager allDice = new DiceManager(3);
+ allDice.rollAllDice();
+ allDice.setSpecificDie(2, DieFace.ONE);
+ DieFace expected = DieFace.ONE;
+ DieFace actual = allDice.getAllDieFaces()[2];
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void getDiceArrayTest() {
+ DiceManager allDice = new DiceManager(3);
+
+ allDice.setSpecificDie(0, DieFace.THREE);
+ allDice.setSpecificDie(1,DieFace.SIX);
+ allDice.setSpecificDie(2, DieFace.FIVE);
+
+ DieFace[] expected = new DieFace[]{DieFace.THREE, DieFace.SIX, DieFace.FIVE};
+ DieFace[] actual = allDice.getAllDieFaces();
+
+ Assert.assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void getTotalValueTest() {
+ DiceManager allDice = new DiceManager(2);
+ allDice.rollAllDice();
+ allDice.setSpecificDie(0, DieFace.TWO);
+ allDice.setSpecificDie(1,DieFace.TWO);
+ int expected = 4;
+ int actual = allDice.getTotalValue();
+ Assert.assertEquals(expected, actual);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/DieFaceTest.java b/src/test/java/io/zipcoder/casino/DieFaceTest.java
new file mode 100644
index 00000000..2cf05c19
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DieFaceTest.java
@@ -0,0 +1,36 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DieFaceTest {
+
+ @Test
+ public void equalsFaceValueTest1() {
+ DieFace one = DieFace.ONE;
+ Assert.assertTrue(one.equalsFaceValue(1));
+ }
+
+ @Test
+ public void equalsFaceValueTest2() {
+ DieFace two = DieFace.TWO;
+ Assert.assertTrue(two.equalsFaceValue(2));
+ }
+
+ @Test
+ public void toIntTest1() {
+ DieFace one = DieFace.ONE;
+ int expected = 1;
+ int actual = one.toInt();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void toIntTest2() {
+ DieFace two = DieFace.TWO;
+ int expected = 2;
+ int actual = two.toInt();
+ Assert.assertEquals(expected, actual);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/DieTest.java b/src/test/java/io/zipcoder/casino/DieTest.java
new file mode 100644
index 00000000..eb896b4e
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DieTest.java
@@ -0,0 +1,31 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class DieTest {
+
+ private static Die die;
+
+ @Before
+ public void setup() {
+ this.die = new Die();
+ die.rollDie();
+ }
+
+ @Test
+ public void getDieFaceTest() {
+ Integer actual = this.die.getDieFace().toInt();
+ Assert.assertTrue(1 <= actual && actual <= 6);
+ }
+
+ @Test
+ public void setDieFaceTest() {
+ this.die.setDieFace(DieFace.ONE);
+ int expected = 1;
+ int actual = this.die.getDieFace().toInt();
+ Assert.assertEquals(expected, actual);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/GoFishTest.java b/src/test/java/io/zipcoder/casino/GoFishTest.java
new file mode 100644
index 00000000..81050b8b
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/GoFishTest.java
@@ -0,0 +1,134 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class GoFishTest {
+
+ private Deck houseDeckTest = new Deck();
+ private Deck houseDeckTest2 = new Deck();
+
+ private Person player1Test = new Person("Joe");
+ private Person dealerTest = new Person("Dealer");
+ private Person playerBookTest = new Person("BookTest");
+
+ private Card cardTest1 = new Card(Rank.SEVEN,Suit.SPADES);
+ private Card cardTest2 = new Card(Rank.SEVEN,Suit.HEARTS);
+ private Card cardTest3 = new Card(Rank.SEVEN,Suit.DIAMONDS);
+ private Card cardTest4 = new Card(Rank.SEVEN,Suit.CLUBS);
+ private Card cardTest5 = new Card(Rank.ACE,Suit.SPADES);
+
+
+ @Before
+ public void startingUp() {
+ for (int i = 0; i < 7; i++) {
+ player1Test.getHand().getHandArrayList().add(houseDeckTest.drawCard());
+ }
+
+ for (int i = 0; i < 7; i++) {
+ dealerTest.getHand().getHandArrayList().add(houseDeckTest.drawCard());
+ }
+
+ houseDeckTest2.clearDeck();
+ houseDeckTest2.getDeckOfCards().add(cardTest1);
+ houseDeckTest2.getDeckOfCards().add(cardTest2);
+ houseDeckTest2.getDeckOfCards().add(cardTest3);
+ houseDeckTest2.getDeckOfCards().add(cardTest4);
+ houseDeckTest2.getDeckOfCards().add(cardTest5);
+
+ for (int i = 0; i < 5; i++) {
+ playerBookTest.getHand().getHandArrayList().add(houseDeckTest2.drawCard());
+ }
+ }
+
+ @Test
+ public void StartingDeckTest() {
+ Person player1 = new Person("Joe");
+ GoFish goFishTest = new GoFish(player1);
+ Deck deckTest = new Deck();
+ Person dealer = new Person();
+
+ Hand dealerHandTest = new Hand();
+
+ goFishTest.startingDrawDeck(deckTest);
+
+ int expected = 38;
+ int actual = deckTest.getDeckOfCards().size();
+
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void doYouHaveTheCardThatIWant() {
+ Person player1 = new Person("Joe");
+ GoFish goFishTest = new GoFish(player1);
+ Person dealer = new Person();
+
+ // card counts as int 1
+ Card cardSend = new Card(Rank.ACE, Suit.SPADES);
+
+ int expected = 1;
+ int actual = goFishTest.doYouHaveTheCardThatIWantFromComputer(1, dealerTest);
+
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void removeCardsFromComputerPlayerAndIntoHandTest () {
+ Person player1 = new Person("Joe");
+ GoFish goFishTest = new GoFish(player1);
+
+ Card cardSend = new Card(Rank.ACE, Suit.SPADES);
+
+ int actual = goFishTest.removeCardsFromComputerPlayerAndIntoHand(1, dealerTest, player1Test);
+ int expected = cardSend.getRank().toInt();
+
+
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void BookCheckerTest(){
+ GoFish goFishTest = new GoFish();
+
+ System.out.println(playerBookTest.getHand().getHandArrayList());
+
+ Card cardSend = new Card(Rank.SEVEN,Suit.CLUBS);
+
+ String expected = "[A♠, 7♣, 7♦, 7♥, 7♠]";
+ String actual = playerBookTest.getHand().getHandArrayList().toString();
+
+ System.out.println(playerBookTest.getHand().getHandArrayList());
+
+ Assert.assertEquals(expected, actual);
+ }
+
+
+ @Test
+ public void goFishTest(){
+ GoFish goFishTest = new GoFish();
+
+ Card cardExpected = new Card(Rank.KING,Suit.SPADES);
+
+ String expected = "K♠";
+ String actual = cardExpected.toString();
+
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void checkNumberOfHandsTest(){
+ Person player1 = new Person("Joe");
+ GoFish goFishTest = new GoFish(player1);
+
+ int expected = 0;
+ int actual = goFishTest.checkNumberOfCard();
+
+ Assert.assertEquals(expected, actual);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/HandTest.java b/src/test/java/io/zipcoder/casino/HandTest.java
new file mode 100644
index 00000000..131b6133
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/HandTest.java
@@ -0,0 +1,196 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+
+public class HandTest {
+
+ private Hand hand;
+ private ArrayList handArrayList;
+ // System.out.println("\u270B" + " my hand " + "\u270B");
+ // System.out.println("\u2660" + "\u2663" + "\u2665" + "\u2666");
+
+ @Test
+ public void handConstructorArrayList() {
+
+ // Given
+ // I receive an empty arraylist from cardDeck
+ int expectedHandSize = 0;
+ // When
+ Hand hand = new Hand();
+ int actualHandSize = hand.getHandArrayList().size();
+
+ // Then
+ Assert.assertEquals(expectedHandSize, actualHandSize);
+
+ }
+
+ @Test
+ public void getHandArrayList() {
+
+ //return currentarraylist
+
+ // Given
+ Hand hand = new Hand();
+ Card expectedCard = new Card(Rank.SEVEN, Suit.SPADES);
+ String expectedCardString = expectedCard.toString();
+ //System.out.println(hand.getHandArrayList());
+
+ // When
+ hand.getHandArrayList().add(expectedCard);
+ Card actualCard = hand.getHandArrayList().get(0);
+ String actualCardString = actualCard.toString();
+
+ // Then
+ Assert.assertEquals(expectedCardString, actualCardString);
+
+ }
+
+ @Test
+ public void receiveCardsFromDealerTest() { // This is like getHand
+
+ // Given
+ Hand hand = new Hand();
+ hand.receiveCards(new Card(Rank.DEUCE, Suit.CLUBS));
+ Card expectedCard0 = new Card(Rank.DEUCE, Suit.CLUBS);
+ String expectedString = expectedCard0.toString();
+
+
+ // When
+ Card actualCard0 = hand.getHandArrayList().get(0);
+ String actualString = actualCard0.toString();
+
+ // Then
+ Assert.assertEquals(expectedString, actualString);
+
+ }
+
+ @Test
+ public void drawCardFromHandTest() {
+
+ // Return last item in ArrayList and then delete it
+ // Given
+ Hand hand = new Hand();
+ Card expectedToStay = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card expectedToDelete = new Card(Rank.THREE, Suit.CLUBS);
+ hand.receiveCards(expectedToStay, expectedToDelete);
+
+ int expectedArraySizeAfterDeletion = 1;
+
+ // When
+ hand.drawCardfromHand();
+ int actualArraySizeAfterDeletion = hand.getHandArrayList().size();
+
+ // Then
+ Assert.assertEquals(expectedArraySizeAfterDeletion, actualArraySizeAfterDeletion);
+ }
+
+ // REMOVESPECIFIC CARD
+ @Test
+ public void getSpecificCardsArrayListTest() {
+
+ // Return specificCardsArrayList
+ /**
+ * I'll receive specific var args of cards to give
+ * I'll remove them from my handArrayList
+ * - loop through handArrayList, remove card/index, then i-- to go back one before next loop
+ * I'll add them to a new array called specificCardsArrayList and return that array
+ */
+
+ // Given
+ Hand hand = new Hand();
+ Card cardToStay1 = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card cardTostay2 = new Card(Rank.THREE, Suit.DIAMONDS);
+ Card cardToSend1 = new Card(Rank.FOUR, Suit.HEARTS);
+ Card cardToSend2 = new Card(Rank.FIVE, Suit.SPADES);
+ hand.receiveCards(cardToStay1, cardTostay2, cardToSend1, cardToSend2);
+
+ String expectedCardToSend1 = cardToSend1.toString();
+ String expectedCardToSend2 = cardToSend2.toString();
+
+ System.out.println(Arrays.toString(hand.getHandArrayList().toArray()));
+
+ // When
+ hand.getSpecificCardsArrayList(cardToSend1, cardToSend2);
+ System.out.println(Arrays.toString(hand.getHandArrayList().toArray()));
+ System.out.println(Arrays.toString(hand.getSpecificCardsArrayList().toArray()));
+
+
+ String actualCardToSend1 = hand.getSpecificCardsArrayList().get(0).toString();
+ String actualCardToSend2 = hand.getSpecificCardsArrayList().get(1).toString();
+
+ // Then
+ Assert.assertEquals(expectedCardToSend1, actualCardToSend1);
+ Assert.assertEquals(expectedCardToSend2, actualCardToSend2);
+ }
+
+ @Test
+ public void clearHandTest() {
+ // reset array size to zero
+
+ // Given
+ Hand hand = new Hand();
+
+ int expectedArraySize = 0;
+ Card expectedToDelete = new Card(Rank.THREE, Suit.CLUBS);
+ hand.receiveCards(expectedToDelete);
+
+ // When
+ hand.getHandArrayList().clear();
+ int actualArraySize = hand.getHandArrayList().size();
+
+ // Then
+ Assert.assertEquals(expectedArraySize, actualArraySize);
+
+ }
+
+ @Test
+ public void shuffleHandTest(){
+
+ // Given
+ Hand hand = new Hand();
+ Card notShuffled0 = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card notShuffled1 = new Card(Rank.THREE, Suit.DIAMONDS);
+ Card notShuffled2 = new Card(Rank.FOUR, Suit.HEARTS);
+ Card notShuffled3 = new Card(Rank.FIVE, Suit.SPADES);
+ hand.receiveCards(notShuffled0, notShuffled1, notShuffled2, notShuffled3);
+ //System.out.println(hand.getHandArrayList());
+
+ // When
+ hand.shuffleHand();
+ Card cardAtIndex0 = hand.getHandArrayList().get(0);
+ //System.out.println(hand.getHandArrayList());
+
+ // Then
+ Assert.assertNotEquals(notShuffled0, cardAtIndex0);
+
+ }
+
+
+ @Test
+ public void toStringTest() {
+
+ // Given
+ Hand hand = new Hand();
+ Card notShuffled0 = new Card(Rank.DEUCE, Suit.CLUBS);
+ Card notShuffled1 = new Card(Rank.THREE, Suit.DIAMONDS);
+ Card notShuffled2 = new Card(Rank.FOUR, Suit.HEARTS);
+ Card notShuffled3 = new Card(Rank.FIVE, Suit.SPADES);
+ hand.receiveCards(notShuffled0, notShuffled1, notShuffled2, notShuffled3);
+
+ // Print
+ System.out.println("My hand: " + "\u270B" + Arrays.toString(hand.getHandArrayList().toArray()) + "\u270B");
+ System.out.println("\u2660" + "\u2663" + "\u2665" + "\u2666");
+
+ // Then
+
+ }
+
+
+
+
+}
diff --git a/src/test/java/io/zipcoder/casino/MainMenuTest.java b/src/test/java/io/zipcoder/casino/MainMenuTest.java
new file mode 100644
index 00000000..da031038
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/MainMenuTest.java
@@ -0,0 +1,30 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MainMenuTest {
+
+ @Test
+ public void testChooseGame() {
+ String chosenGame = "war";
+ Person player = new Person ("Adam");
+ Game expected = new War(player);
+
+ Game actual = MainMenu.chooseGame(chosenGame, player);
+
+ Assert.assertEquals(actual, expected);
+ }
+
+ @Test
+ public void testChooseGame2() {
+ String chosenGame = "theibhwn";
+ Person player = new Person ("Adam");
+ Game expected = new War(player);
+
+ Game actual = MainMenu.chooseGame(chosenGame, player);
+
+ Assert.assertNotEquals(actual, expected);
+ }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/PersonTest.java b/src/test/java/io/zipcoder/casino/PersonTest.java
new file mode 100644
index 00000000..e5c82e12
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/PersonTest.java
@@ -0,0 +1,35 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class PersonTest {
+
+
+ @Test
+ public void constructorTest() {
+ Person testPesron = new Person("Joe");
+ String expected = "Joe";
+ String actual = testPesron.getName();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void getHandTest() {
+ Person person = new Person("Joe");
+ ArrayList expected = new ArrayList();
+ ArrayList actual = person.getHand().getHandArrayList();
+ Assert.assertEquals(actual, expected);
+ }
+
+ @Test
+ public void getWalletTest() {
+ Person person = new Person("Joe");
+ int expected = 0;
+ int actual = person.getWallet().checkChipAmount();
+ Assert.assertEquals(actual, expected);
+ }
+}
diff --git a/src/test/java/io/zipcoder/casino/RankTest.java b/src/test/java/io/zipcoder/casino/RankTest.java
new file mode 100644
index 00000000..42f2011e
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/RankTest.java
@@ -0,0 +1,41 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.Before;
+
+public class RankTest {
+
+ private Card card;
+
+ @Test
+ public void RanktoIntTest() {
+
+ // Given
+ int expectedRankValue = 3;
+ Card card = new Card(Rank.THREE, Suit.HEARTS);
+
+ // When
+ int actualRankValue = card.getRank().toInt();
+
+ // Then
+ Assert.assertEquals(expectedRankValue, actualRankValue);
+ }
+
+ @Test
+ public void RanktoStringTest() {
+
+ // Given
+ String expectedRankSymbol = "3";
+ Card card = new Card(Rank.THREE, Suit.HEARTS);
+
+ // When
+ String actualRankSymbol = card.getRank().toString();
+
+ // Then
+ Assert.assertEquals(expectedRankSymbol, actualRankSymbol);
+ }
+
+
+
+}
diff --git a/src/test/java/io/zipcoder/casino/ScoreboardTest.java b/src/test/java/io/zipcoder/casino/ScoreboardTest.java
new file mode 100644
index 00000000..b4e088ae
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/ScoreboardTest.java
@@ -0,0 +1,182 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+import java.util.LinkedHashMap;
+import java.util.Set;
+
+public class ScoreboardTest {
+ private Person person1 = new Person("Harry");
+ private Person person2 = new Person("Sally");
+ private Person person3 = new Person("Elise");
+ @Test
+ public void constructorOneTest(){
+ Scoreboard board = new Scoreboard();
+ Assert.assertNotNull(board);
+ }
+
+ @Test
+ public void secondConstructorTest(){
+ //given
+ Scoreboard board = new Scoreboard();
+ Person[] expected = {person1, person2, person3};
+ //when
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ board.addPlayer(person3);
+ //then
+ Person[] actual = board.getPlayers();
+
+ Assert.assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void thirdConstructorTest(){
+ //given
+ Scoreboard board = new Scoreboard();
+ Person[] expected = {person1, person2};
+ //when
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ //then
+ Person[] actual = board.getPlayers();
+
+ Assert.assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void setScoreboardTest(){
+
+ }
+
+ @Test
+ public void getScoreboardTest(){
+
+ }
+
+ @Test
+ public void getPlayersTest() {
+ //given
+ Scoreboard board = new Scoreboard();
+ Person[] expectedPlayers = {person1, person2};
+ //when
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ //then
+ Person[] actualPlayers = board.getPlayers();
+
+ Assert.assertArrayEquals(expectedPlayers, actualPlayers);
+
+ }
+
+ @Test
+ public void addPlayerTest() {
+ //given
+ Scoreboard board = new Scoreboard();
+ Person[] expected = {person1, person2, person3};
+ //when
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ board.addPlayer(person3);
+ //then
+ Person[] actual = board.getPlayers();
+
+ Assert.assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void removePlayerTest() {
+ //given
+ Scoreboard board = new Scoreboard();
+ Person[] players = {person1, person2, person3};
+ //when
+ board.addPlayer(person2);
+ board.addPlayer(person1);
+ board.addPlayer(person3);
+ Person[] expected = {person2, person3};
+ //then
+ board.removePlayer(person1);
+ Person[] actual = board.getPlayers();
+
+ Assert.assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void updateScoreTest() {
+ //given
+ Scoreboard board = new Scoreboard();
+ Integer expectedScore = 6;
+ //when
+ board.addPlayer(person1);
+ //then
+ board.updateScore(person1, 6);
+ Integer actualScore = board.getScore(person1);
+
+ Assert.assertEquals(expectedScore, actualScore);
+ }
+
+ @Test
+ public void clearScoreboardTest() {
+
+ Scoreboard board = new Scoreboard();
+ Person[] expected = {};
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+
+ board.clearScoreboardOfPlayersAndScores();
+ Person[] actual = board.getPlayers();
+ Assert.assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void resetScoreboardForSamePlayers(){
+ //Given
+ Scoreboard board = new Scoreboard();
+ Person[] expected = {person1, person2};
+ //when
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ board.updateScore(person1, 7);
+ board.updateScore(person2, 9);
+ //then
+ board.resetScoreboardForSamePlayers();
+ Person[] actual = board.getPlayers();
+ Assert.assertArrayEquals(expected, actual);
+
+ }
+
+ @Test
+ public void resetScoreboardForSamePlayer2() {
+ Scoreboard board = new Scoreboard();
+ Integer expected = 0;
+ board.addPlayer(person1);
+ board.updateScore(person1, 7);
+ board.resetScoreboardForSamePlayers();
+ Integer actual = board.getScore(person1);
+ Assert.assertEquals(expected, actual);
+ }
+
+
+ @Test
+ public void displayScoreboardSingleGameTest() {
+ Scoreboard board = new Scoreboard();
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ board.updateScore(person1, 7);
+ board.updateScore(person2, 9);
+ System.out.println(board.displayScoreboardSingleGame());
+ }
+
+/* @Test
+ public void displayRunningGameTallyTest() {
+ Scoreboard board = new Scoreboard();
+ board.addPlayer(person1);
+ board.addPlayer(person2);
+ board.updateScore(person1, 7);
+ board.updateScore(person2, 9);
+ System.out.println(board.displayRunningGameTally());
+ }*/
+
+
+}
diff --git a/src/test/java/io/zipcoder/casino/SuitTest.java b/src/test/java/io/zipcoder/casino/SuitTest.java
new file mode 100644
index 00000000..862acdd4
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/SuitTest.java
@@ -0,0 +1,38 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.Before;
+
+public class SuitTest {
+
+ private Card card;
+
+ @Test
+ public void SuitToStringTest() {
+
+ // Given
+ String expectedSuitWord = "clubs";
+ Card card = new Card(Rank.NINE, Suit.CLUBS);
+
+ // When
+ String actualSuitWord = card.getSuit().toString();
+
+ // Then
+ Assert.assertEquals(expectedSuitWord, actualSuitWord);
+ }
+
+ @Test
+ public void SuitToSymbolTest() {
+
+ // Given
+ String expectedSuitSymbol = "\u2663";
+ Card card = new Card(Rank.NINE, Suit.CLUBS);
+
+ // When
+ String actualSuitSymbol = card.getSuit().toSymbol();
+
+ // Then
+ Assert.assertEquals(expectedSuitSymbol, actualSuitSymbol);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/io/zipcoder/casino/WalletTest.java b/src/test/java/io/zipcoder/casino/WalletTest.java
new file mode 100644
index 00000000..4e31edaf
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/WalletTest.java
@@ -0,0 +1,26 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WalletTest {
+
+ @Test
+ public void addChipsTest() {
+ Wallet testWallet = new Wallet();
+ int expected = 500;
+ testWallet.addChipsToAmount(expected);
+ int actual = testWallet.checkChipAmount();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void removeChipsTest() {
+ Wallet testWallet = new Wallet();
+ testWallet.addChipsToAmount(500);
+ testWallet.removeChipsFromAmount(200);
+ int expected = 300;
+ int actual = testWallet.checkChipAmount();
+ Assert.assertEquals(actual, expected);
+ }
+}
diff --git a/src/test/java/io/zipcoder/casino/WarTest.java b/src/test/java/io/zipcoder/casino/WarTest.java
new file mode 100644
index 00000000..11ac333f
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/WarTest.java
@@ -0,0 +1,86 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WarTest {
+
+ // psvm for isolated War testing
+// public static void main(String[] args) {
+// Person player = new Person();
+// War war = new War(player);
+// war.start();
+// }
+
+ @Test
+ public void checkNumberOfCards() {
+ Person player = new Person();
+ War warGame = new War(player);
+ Hand hand = new Hand();
+ hand.getHandArrayList().add(new Card(Rank.DEUCE, Suit.CLUBS));
+ hand.getHandArrayList().add(new Card(Rank.NINE, Suit.HEARTS));
+ int expected = 2;
+ int actual = warGame.checkNumberOfCards(hand);
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void compareCardsTest() {
+ Person player = new Person();
+ War warGame = new War(player);
+ Card smallCard = new Card(Rank.THREE, Suit.DIAMONDS);
+ Card bigCard = new Card(Rank.SEVEN, Suit.DIAMONDS);
+ int expected = 2;
+ int actual = warGame.compareCards(smallCard, bigCard);
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void compareCardsTest2() {
+ Person player = new Person();
+ War warGame = new War(player);
+ Card smallCard = new Card(Rank.EIGHT, Suit.DIAMONDS);
+ Card bigCard = new Card(Rank.DEUCE, Suit.DIAMONDS);
+ int expected = 1;
+ int actual = warGame.compareCards(smallCard, bigCard);
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void dealCardsTest() {
+ Person player = new Person();
+ War warGame = new War(player);
+ warGame.start();
+ int expected = 26;
+ int actual = player.getHand().getHandArrayList().size();
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void decideHowManyYaddaYaddaTest_handHasFourCards() {
+ Person player = new Person();
+ War warGame = new War(player);
+ int expected = 4;
+ int actual = warGame.decideOnHowManyTimesToIterateBasedOn(4);
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void decideHowManyYaddaYaddaTest_handHasMoreThanFourCards() {
+ Person player = new Person();
+ War warGame = new War(player);
+ int expected = 4;
+ int actual = warGame.decideOnHowManyTimesToIterateBasedOn(7);
+ Assert.assertEquals(expected, actual);
+ }
+
+ @Test
+ public void decideHowManyYaddaYaddaTest_handHasLessThanFourCards() {
+ Person player = new Person();
+ War warGame = new War(player);
+ int expected = 2;
+ int actual = warGame.decideOnHowManyTimesToIterateBasedOn(2);
+ Assert.assertEquals(expected, actual);
+ }
+
+}