diff --git a/Untitled Diagram.xml b/Untitled Diagram.xml new file mode 100644 index 00000000..149d6619 --- /dev/null +++ b/Untitled Diagram.xml @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/casino.uml b/casino.uml new file mode 100644 index 00000000..13c501df --- /dev/null +++ b/casino.uml @@ -0,0 +1,85 @@ + + + JAVA + io.zipcoder.casino + + io.zipcoder.casino.Console + io.zipcoder.casino.CardPlayer + io.zipcoder.casino.Casino + io.zipcoder.casino.Hand + io.zipcoder.casino.Deck + io.zipcoder.casino.CardTest + io.zipcoder.casino.BlackJack + io.zipcoder.casino.Games + io.zipcoder.casino.GoFishPlayer + io.zipcoder.casino.CasinoTest + io.zipcoder.casino.DeckTest + io.zipcoder.casino.CardGames + io.zipcoder.casino.Gamble + io.zipcoder.casino.Card + io.zipcoder.casino.Player + io.zipcoder.casino.Craps + io.zipcoder.casino.BlackJackGambler + io.zipcoder.casino.GoFish + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Fields + Methods + + All + private + + diff --git a/pom.xml b/pom.xml index c6ec0cc8..3996aef2 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,18 @@ io.zipcoder casino 1.0-SNAPSHOT + + + + 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..e153a0a2 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..7bb43dbf 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..31795b31 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..87611248 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..5f0daaa7 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..37bdd188 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -0,0 +1,170 @@ +package io.zipcoder.casino; + + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Random; + +public class BlackJack extends CardGames implements Gamble { + private Dealer dealer; + private String playAgain = ""; + private Map playerWagers = new HashMap(); + + public void play(BlackJackGambler user) { + gameSetUp(user); + do { + if (getRemainingDeckCards() / getPlayers().size() < 52) + loadDecks(8); + System.out.println(user.getName() + " Chips: " + user.getChipCount() + "\n"); + for (BlackJackGambler player : getPlayers()) { + Integer bet = takeBet(player); + playerBet(player, bet); + } + + addPlayer(dealer); + dealCards(2); + removePlayer(dealer); + + System.out.println(dealer.showOneCard()); + for (BlackJackGambler player : getPlayers()) + System.out.println(player.showHand()); + + for (BlackJackGambler player : getPlayers()) + hitOrStay(player); + + System.out.println("Dealers Cards: " + dealer.showHand() + "\n"); + + hitOrStay(dealer); + checkForWinners(); + + if (user.getChipCount() == 0) { + System.out.println("Your are out of chips, returning to lobby"); + playAgain = "no"; + } else + playAgain = Console.getStringInput("Play again?"); + + resetHands(); + resetBets(); + removeZeroChipPlayers(); + } while ("yes".equalsIgnoreCase(playAgain)); + + } + + @Override + public void gameSetUp(BlackJackGambler user) { + dealer = new Dealer(); + addPlayer(user); + loadDecks(8); + int numberOfPlayers = new Random().nextInt(6) + 1; + addAIPlayers(numberOfPlayers); + resetBets(); + } + + @Override + public void addAIPlayers(int playersToAdd) { + for (int i = 1; i <= playersToAdd; i++) + getPlayers().add(new BlackJackGambler(new Player("Computer" + i, 0, false), 3000)); + } + + @Override + public Integer takeBet(BlackJackGambler player) { + Integer bet; + if (player.isPerson()) { + bet = Console.getIntegerInput("Place your bet"); + bet = player.placeBet(bet); + } else bet = CompPlay.makeBet(player); + + return bet; + } + + private void playerBet(BlackJackGambler player, Integer amount) { + playerWagers.put(player, amount); + } + + private void hitOrStay(BlackJackGambler player) { + String userChoice = ""; + + while (!userChoice.equalsIgnoreCase("Stay") && !isBust(player)) { + if (player.isPerson()) + userChoice = Console.getStringInput("Hit or Stay?"); + else userChoice = CompPlay.hitOrStay(player); + + if (userChoice.equalsIgnoreCase("Hit")) { + System.out.println(player.getName() + ": Hit"); + Card card = getDeckCard(); + player.addCardToHand(card); + System.out.println(card + " New Total: " + player.getHandTotal() + "\n"); + } else if (userChoice.equalsIgnoreCase("Stay")) + System.out.println(player.getName() + ": Stay\n"); + } + + if (isBust(player)) + System.out.println(player.getName() + " went over: " + player.getHand() + "\n"); + } + + private boolean isBust(BlackJackGambler player) { + if (player.getHandTotal() > 21) { + return true; + } + return false; + } + + private void checkForWinners() { + for (BlackJackGambler player : getPlayers()) { + int multiplier = 0; + if (!isBust(dealer) && !isBust(player)) + multiplier = payoutMultiplier(player); + else if (!isBust(player)) + multiplier = 2; + payoutWinnings(player, multiplier); + } + } + + private int payoutMultiplier(BlackJackGambler player) { + if (player.getHandTotal() > dealer.getHandTotal()) { + return 2; + } else if (player.getHandTotal() == dealer.getHandTotal()) + return 1; + return 0; + } + + private boolean checkForBlackJack(BlackJackGambler player) { + if (player.getHandTotal() == 21 && player.getHand().size() == 2) + return true; + return false; + } + + private void payoutWinnings(BlackJackGambler player, double multiplier) { + if (checkForBlackJack(player)) + multiplier += 0.5; + Integer winnings = (int) (playerWagers.get(player).doubleValue() * multiplier); + System.out.println(player.showHand()); + System.out.println(" Winnings: " + winnings + "\n"); + player.addChips(winnings); + } + + private void removeZeroChipPlayers() { + ArrayList playersToRemove = new ArrayList<>(); + for (BlackJackGambler player : getPlayers()) + if (player.getChipCount() == 0 && !player.isPerson()) { + System.out.println(player.getName() + " ran out of chips, now leaving."); + playersToRemove.add(player); + } + getPlayers().removeAll(playersToRemove); + } + + + private void resetHands() { + for (BlackJackGambler player : getPlayers()) + player.clearHand(); + dealer.resetHand(); + } + + @Override + public void resetBets() { + for (BlackJackGambler player : getPlayers()) + playerWagers.put(player, 0); + } + +} diff --git a/src/main/java/io/zipcoder/casino/BlackJackGambler.java b/src/main/java/io/zipcoder/casino/BlackJackGambler.java new file mode 100644 index 00000000..70a3d0f6 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/BlackJackGambler.java @@ -0,0 +1,69 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; + +public class BlackJackGambler extends CardPlayer { + + private Integer chipCount; + + public BlackJackGambler(Player player, Integer chipCount) { + super(player); + this.chipCount = chipCount; + } + + public Integer getChipCount() { + return chipCount; + } + + public void addChips(Integer amount) { + chipCount += amount; + } + + public Integer tradeInChips() { + Integer chips = chipCount; + chipCount = 0; + return chips; + } + + public Integer placeBet(Integer amount) { + if (wagerAvailable(amount)) + chipCount -= amount; + else { + amount = chipCount; + chipCount = 0; + } + + return amount; + } + + private boolean wagerAvailable(Integer bet) { + if (bet > chipCount) + return false; + else return true; + } + + public int getHandTotal() { + int total = 0; + String card; + int aces = 0; + for (Card c : getHand()) { + card = c.getRank().toString(); + if ("JACK".equals(card) || "QUEEN".equals(card) || "KING".equals(card)) + total += 10; + else if ("ACE".equals(card.toString())) { + total += 11; + aces++; + } else total += c.getValue(); + } + while (total > 21 && aces != 0) { + total -= 10; + aces--; + } + return total; + } + + public String showHand() { + return getName() + ": " + handToString() + " Total: " + getHandTotal(); + } + +} 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..38f83dc3 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Card.java @@ -0,0 +1,49 @@ +package io.zipcoder.casino; + + +public class Card { + + enum Rank { + + JOKER, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE; + + public int getValue() { + return ordinal() + 1; + } + } + + enum Suit { + CLUBS((char)'\u2663'), SPADES((char)'\u2660'), HEARTS((char)'\u2665'), DIAMONDS((char)'\u2666'); + + private char val; + Suit(char val){ + this.val=val; + } + + } + + + private Rank rank; + private Suit suit; + + public Card(Rank v, Suit s) { + this.rank = v; + this.suit = s; + } + + public int getValue() { + return rank.getValue(); + } + + public Rank getRank() { + return rank; + } + + public Suit getSuit() { + return suit; + } + + public String toString() { + return rank + " of " + suit.val; + } +} diff --git a/src/main/java/io/zipcoder/casino/CardGames.java b/src/main/java/io/zipcoder/casino/CardGames.java new file mode 100644 index 00000000..e0269b59 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CardGames.java @@ -0,0 +1,57 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; + +public abstract class CardGames implements Games { + private ArrayList players = new ArrayList(); + private Deck deck; + + public abstract void addAIPlayers(int playersToAdd); + public abstract void gameSetUp(T user); + + public void dealCards(int cardsToDeal) { + while (cardsToDeal > 0) { + + for (T player : players) { + Card card = deck.getCard(); + player.addCardToHand(card); + } + cardsToDeal--; + } + } + + public void addPlayer(T player) { + players.add(player); + } + + public void loadDecks(int numberOfDecks) { + deck = new Deck(numberOfDecks); + deck.shuffleDeck(); + } + + public int getRemainingDeckCards() { + return deck.getRemainingCards(); + } + + public T getPlayer(int index) { + try{ + return players.get(index);} + catch (IndexOutOfBoundsException e){ + System.out.println("Invalid Player Choice"); + } + return null; + } + + public ArrayList getPlayers() { + return players; + } + + public Card getDeckCard() { + return deck.getCard(); + } + + public void removePlayer(T player) { + players.remove(player); + } + +} diff --git a/src/main/java/io/zipcoder/casino/CardPlayer.java b/src/main/java/io/zipcoder/casino/CardPlayer.java new file mode 100644 index 00000000..191893ef --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CardPlayer.java @@ -0,0 +1,34 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; + +public abstract class CardPlayer extends Player { + private Hand hand; + + + public CardPlayer(Player player) { + super(player.getName(), player.getCash(), player.isPerson()); + hand = new Hand(); + } + + public ArrayList getHand() { + return hand.getHand(); + } + + public void clearHand() { + hand = new Hand(); + } + + public void addCardToHand(Card card) { + hand.addCard(card); + } + + public Card removeCard(Card.Rank rank) { + return hand.removeCard(rank); + } + + public String handToString(){ + return hand.toString(); + } +} + diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 74dfdd8c..92cb2f18 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -2,4 +2,106 @@ public class Casino { + + private enum Games {BLACKJACK, CRAPS, GOFISH, EXIT} + + private String playerName; + private Player player; + private CasinoCage casinoCage = new CasinoCage(); + + public void start() { + + playerName = Console.getStringInput("Please enter your name"); + player = new Player(playerName, 10000, true); + String userInput = ""; + do { + for (Games game : Games.values()) + System.out.print(" {" + game + "} "); + try { + userInput = Console.getStringInput("\nEnter the name of the game you would like to play: "); + Games gameSelection = Games.valueOf(userInput); + gameSelection(gameSelection); + } catch (IllegalArgumentException e) { + System.out.println("Invalid Choice"); + } + } while (!"Exit".equalsIgnoreCase(userInput)); + + + } + + private void gameSelection(Games userInput) { + + switch (userInput) { + case CRAPS: + playCraps(); + break; + case BLACKJACK: + playBlackJack(); + break; + case GOFISH: + playGoFish(); + break; + case EXIT: + System.exit(0); + break; + + } + } + + private void playCraps() { + Craps craps = new Craps(); + CrapsPlayer gambler; + + Integer chipReq = Console.getIntegerInput("How many chips would you like to purchase? ($" + player.getCash() + " avail.)"); + chipReq = player.withdrawalCash(chipReq); + if (chipReq > 0) { + Integer chips = casinoCage.payoutChips(chipReq); + gambler = new CrapsPlayer(player, chips); + craps.play(gambler); + chips=gambler.tradeInChips(); + Integer winnings=casinoCage.payoutCash(chips); + player.addCash(winnings); + } else System.out.println("Sorry invalid amount"); + + } + + private void playBlackJack() { + BlackJack blackJack = new BlackJack(); + BlackJackGambler gambler; + Integer chipReq = Console.getIntegerInput("How many chips would you like to purchase? ($" + player.getCash() + " avail.)"); + chipReq = player.withdrawalCash(chipReq); + if (chipReq > 0) { + Integer chips = casinoCage.payoutChips(chipReq); + gambler = new BlackJackGambler(player, chips); + blackJack.play(gambler); + chips=gambler.tradeInChips(); + Integer winnings=casinoCage.payoutCash(chips); + player.addCash(winnings); + } else System.out.println("Sorry invalid amount"); + + + } + + private void playGoFish() { + GoFish goFish = new GoFish(); + GoFishPlayer goFishPlayer = new GoFishPlayer(player); + goFish.play(goFishPlayer); + } + + private class CasinoCage { + Integer bankRoll = 100000000; + + + public Integer payoutChips(Integer chipReq) { + if (chipReq < bankRoll) { + bankRoll += chipReq; + } + return chipReq; + } + + public Integer payoutCash(Integer chipCount) { + bankRoll-=chipCount; + return chipCount; + } + } } diff --git a/src/main/java/io/zipcoder/casino/CompPlay.java b/src/main/java/io/zipcoder/casino/CompPlay.java new file mode 100644 index 00000000..7d720fe1 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CompPlay.java @@ -0,0 +1,99 @@ +package io.zipcoder.casino; + +import java.util.*; + +import io.zipcoder.casino.Card.*; + +public class CompPlay { + + + private static Random rand = new Random(); + private static Map> playerCards = new HashMap<>(); + + + public static Integer makeBet(BlackJackGambler player) { + return player.placeBet(250); + } + + public static String hitOrStay(BlackJackGambler player) { + if (player.getClass().getSimpleName().equals("Dealer")) + return dealerHitOrStay(player); + else return basicHitOrStay(player); + } + + private static String dealerHitOrStay(BlackJackGambler player) { + if (player.getHandTotal() >= 17) + return "Stay"; + else return "Hit"; + } + + private static String basicHitOrStay(BlackJackGambler player) { + if (player.getHandTotal() < 12) { + return "Hit"; + } + if (player.getHandTotal() >= 18) + return "Stay"; + else { + int rand = new Random().nextInt(10) + 1; + if (rand < 4) + return "Hit"; + else return "Stay"; + } + } + + public static String getPlayerCards() { + String cards = ""; + for (GoFishPlayer p : playerCards.keySet()) { + cards += playerCards.get(p) + "\n"; + } + return cards; + } + + public static void setUpPlayerCards(GoFishPlayer player) { + Set card = new HashSet(); + playerCards.put(player, card); + } + + public static void clearPlayerCards() { + playerCards.clear(); + } + + public static void addRankToPlayer(GoFishPlayer player, Rank cardRank) { + playerCards.get(player).add(cardRank); + } + + + public static void removeRankFromPlayer(GoFishPlayer player, Rank cardRank) { + playerCards.get(player).remove(cardRank); + } + + public static Rank chooseRank(GoFishPlayer player) { + Rank cardRank=null; + for (Card card : player.getHand()) { + for (GoFishPlayer otherPlayer : playerCards.keySet()) { + if (playerCards.get(otherPlayer).contains(card.getRank())&&!player.equals(otherPlayer)) { + cardRank = card.getRank(); + return cardRank; + } + } + } + cardRank = player.getHand().get(player.getHand().size() - 1).getRank(); + return cardRank; + } + + public static GoFishPlayer choosePlayer(GoFishPlayer player, Rank cardRank) { + for (GoFishPlayer p : playerCards.keySet()) { + if (playerCards.get(p).contains(cardRank)&&!player.equals(p)) { + return p; + } + } + GoFishPlayer[] arr = playerCards.keySet().stream().toArray(GoFishPlayer[]::new); + GoFishPlayer otherPlayer = null; + do { + otherPlayer = arr[rand.nextInt(arr.length)]; + } + while (otherPlayer.equals(player)||otherPlayer.getHand().size()==0); + return otherPlayer; + } + +} diff --git a/src/main/java/io/zipcoder/casino/Console.java b/src/main/java/io/zipcoder/casino/Console.java new file mode 100644 index 00000000..37a64afb --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Console.java @@ -0,0 +1,38 @@ +package io.zipcoder.casino; + +import java.util.Scanner; + +public class Console { + + public static String getStringInput(String prompt) { + Scanner in = new Scanner(System.in); + System.out.println(prompt); + String userInput = in.nextLine(); + return userInput.toUpperCase(); + } + + + public static Integer getIntegerInput(String prompt) { + do { + try { + String userInput = getStringInput(prompt); + Integer intUserInput = Integer.parseInt(userInput); + return intUserInput; + } catch (IllegalArgumentException iae) { + continue; + } + } while (true); + } + + public static Card.Rank getRankInput(String prompt) { + do { + try { + String userInput = getStringInput(prompt); + Card.Rank rank = Card.Rank.valueOf(userInput); + return rank; + } catch (IllegalArgumentException e) { + System.out.println("Invalid Card Choice"); + } + } while (true); + } +} 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..cf029e95 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -0,0 +1,212 @@ +package io.zipcoder.casino; + +public class Craps implements Gamble, Games { + + private String playAgain = "yes"; + + int pot; + + Die d1; + Die d2; + + int bet4or10 = 0; + int bet5or9 = 0; + int bet6or8 = 0; + + @Override + public void play(CrapsPlayer player) { + + do { + d1 = new Die(); + d2 = new Die(); + int pointValue; + int rollValue; + + + printCurrentChips(player); + pot = takeBet(player); + + rollDice(); + rollValue = d1.getValue() + d2.getValue(); + printDiceValue(d1, d2); + + if (rollValue == 7 || rollValue == 11) { + // Win + int winnings = pot * 2; + printWinOrLose("win", winnings); + payOut(player, pot, 2); + playAgain = Console.getStringInput("Play Again?"); + + } else if (rollValue == 2 || rollValue == 3 || rollValue == 12) { + // Lose + printWinOrLose("lose", 0); + playAgain = Console.getStringInput("Play Again?"); + continue; + } else { + pointValue = rollValue; + do { + + printCurrentChips(player); + // prompt for bets on next roll group (4 & 10, 5 & 9, or 6 & 8) + placeSideBet(player); + + rollDice(); + rollValue = d1.getValue() + d2.getValue(); + printDiceValue(d1, d2); + + int winnings = handlePointerRoll(pointValue, rollValue); + + payOut(player, winnings, 2); + + } + while (rollValue != pointValue && rollValue != 7); + + resetBets(); + playAgain = Console.getStringInput("Play Again?"); + } + + + + } while ("yes".equalsIgnoreCase(playAgain)); + } + + @Override + public Integer takeBet(CrapsPlayer player) { + Integer bet; + bet = Console.getIntegerInput("Place your bet"); + player.placeBet(bet); + + return bet; + } + + @Override + public void resetBets() { + pot = 0; + clearSideBets(); + } + + private void rollDice() { + d1.rollDie(); + d2.rollDie(); + } + + private int handlePointerRoll(int pointValue, int rollValue) { + + int retValue = 0; + + switch (rollValue) { + + case 4: + retValue = determineRollPayout(rollValue, pointValue, 10, bet4or10); + break; + case 5: + retValue = determineRollPayout(rollValue, pointValue, 9, bet5or9); + break; + case 6: + retValue = determineRollPayout(rollValue, pointValue, 8, bet6or8); + break; + case 7: + // Lose + printWinOrLose("lose", 0); + retValue = 0; + clearSideBets(); + break; + case 8: + retValue = determineRollPayout(rollValue, pointValue, 6, bet6or8); + break; + case 9: + retValue = determineRollPayout(rollValue, pointValue, 5, bet5or9); + break; + case 10: + retValue = determineRollPayout(rollValue, pointValue, 4, bet4or10); + break; + default: + break; + } + return retValue; + } + + private int determineRollPayout(int rollValue, int pointValue, int sideValue, int groupBets) { + int retValue; + if (pointValue == rollValue) { + int total = pot + bet4or10; + printWinOrLose("win", total); + retValue = total; + pot = 0; + clearSideBets(); + } else if (sideValue == rollValue && groupBets < 0) { + printWinOrLose("win", groupBets); + retValue = groupBets; + clearSideBets(); + } else { + printWinOrLose("lose", 0); + retValue = 0; + clearSideBets(); + } + return retValue; + } + + private void printDiceValue(Die d1, Die d2) { + int total = d1.getValue() + d2.getValue(); + System.out.println("You rolled a :" + d1.getValue() + " and a " + d2.getValue()); + System.out.println("You have a combined value of " + total); + } + + private void printCurrentChips(CrapsPlayer player) { + System.out.println("\nYou currently have " + player.getChipCount() + " chips.\n"); + } + + private void printWinOrLose(String input, int value) { + if("win".equals(input)) { + System.out.println(""); + System.out.println("Congratulations! You win!"); + System.out.println("You won: " + value + " chips!"); + System.out.println(""); + } + else if ("lose".equals(input)) { + System.out.println("Sorry, a Winrar\u00A9 is not you."); + System.out.println("Better luck next time."); + } + else { + System.out.println("What are you trying to pull here? Lrn2spelling my boy."); + } + } + + private int placeSideBet(CrapsPlayer player) { + boolean isValidInput = false; + int retValue = -1; + + while (isValidInput == false) { + String group = Console.getStringInput("Which group would you like to bet on?\n" + + "[4 & 10]\t[5 & 9]\t[6 & 8]\tNONE"); + if (group.equals("4 & 10") || group.equals("4&10") || group.equals("4") || group.equals("10")) { + bet4or10 = takeBet(player); + isValidInput = true; + } else if (group.equals("5 & 9") || group.equals("5&9") || group.equals("5") || group.equals("9")) { + bet5or9 = takeBet(player); + isValidInput = true; + } else if (group.equals("6 & 8") || group.equals("6&8") || group.equals("6") || group.equals("8")) { + bet6or8 = takeBet(player); + isValidInput = true; + } else if (group.equalsIgnoreCase("NONE")) { + retValue = 0; + isValidInput = true; + } else { + System.out.println("Invalid input. Try again"); + } + } + return retValue; + + } + + private void clearSideBets() { + bet4or10 = 0; + bet5or9 = 0; + bet6or8 = 0; + } + + public void payOut(CrapsPlayer player, int value, int multiplier) { + player.addChips(value * multiplier); + } + +} \ No newline at end of file diff --git a/src/main/java/io/zipcoder/casino/CrapsPlayer.java b/src/main/java/io/zipcoder/casino/CrapsPlayer.java new file mode 100644 index 00000000..e9d76f1d --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CrapsPlayer.java @@ -0,0 +1,42 @@ +package io.zipcoder.casino; + +public class CrapsPlayer extends Player { + + private Player player; + private Integer chipCount = 0; + + public CrapsPlayer(Player player, Integer chipCount) { + super(player.getName(), player.getCash(), player.isPerson()); + this.player = player; + this.chipCount = chipCount; + } + + public Integer getChipCount() { + return chipCount; + } + + public Integer tradeInChips() { + Integer chips = chipCount; + chipCount = 0; + return chips; + } + + public void addChips(Integer amount) { + chipCount += amount; + } + + public Integer placeBet(Integer amount) { + if (wagerAvailable(amount)) + chipCount -= amount; + else amount = 0; + + return amount; + } + + private boolean wagerAvailable(Integer bet) { + if (bet > chipCount) + return false; + else return true; + } + +} 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..056ee6ff --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Dealer.java @@ -0,0 +1,18 @@ +package io.zipcoder.casino; + +public class Dealer extends BlackJackGambler{ + + + public Dealer() { + super(new Player("Dealer",0, false),10); + } + + public String showOneCard() { + return "Dealer Top Card: " + getHand().get(0); + } + + public void resetHand() { + clearHand(); + } + +} 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..a54d12ba --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Deck.java @@ -0,0 +1,32 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; +import java.util.Collections; + +public class Deck { + private ArrayList deck; + private Card.Rank[] values = Card.Rank.values(); + private Card.Suit[] suites = Card.Suit.values(); + + public Deck(int numberOfDecks) { + deck = new ArrayList(); + while (numberOfDecks > 0) { + for (int i = 1; i < 14; i++) + for (int j = 0; j < 4; j++) + deck.add(new Card(values[i], suites[j])); + numberOfDecks--; + } + } + + public Card getCard() { + return deck.remove(0); + } + + public int getRemainingCards() { + return deck.size(); + } + + public void shuffleDeck() { + Collections.shuffle(deck); + } +} 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..74925044 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Die.java @@ -0,0 +1,18 @@ +package io.zipcoder.casino; + +public class Die { + + int value; + + public Die() { + } + + public void rollDie() { + this.value = (int) Math.ceil(Math.random() * 6); + } + + public int getValue() { + return value; + } + +} diff --git a/src/main/java/io/zipcoder/casino/Gamble.java b/src/main/java/io/zipcoder/casino/Gamble.java new file mode 100644 index 00000000..27d93932 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Gamble.java @@ -0,0 +1,9 @@ +package io.zipcoder.casino; + + +public interface Gamble { + public Integer takeBet(T player); + public void resetBets(); + + +} diff --git a/src/main/java/io/zipcoder/casino/Games.java b/src/main/java/io/zipcoder/casino/Games.java new file mode 100644 index 00000000..bf4fd6d2 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Games.java @@ -0,0 +1,5 @@ +package io.zipcoder.casino; + +public interface Games { + public void play(T user); +} 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..79641923 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -0,0 +1,130 @@ +package io.zipcoder.casino; + +import io.zipcoder.casino.Card.*; + +import java.util.ArrayList; + +public class GoFish extends CardGames { + + public void play(GoFishPlayer user) { + + gameSetUp(user); + + while (booksRemaining() > 0) { + System.out.println("Books remaining: " + booksRemaining()); + booksFound(); + System.out.println("Your Hand: " + user.handToString()); + Rank cardRank = null; + GoFishPlayer otherPlayer = null; + for (GoFishPlayer player : getPlayers()) { + if (player.getHand().size() == 0) + continue; + cardRank = playerCardChoice(player); + otherPlayer = chooseOtherPlayer(player, cardRank); + System.out.println(player.getName() + " asks " + otherPlayer.getName() + " for any " + cardRank); + if (goFish(player, otherPlayer, cardRank) && getRemainingDeckCards() > 0) { + Card card = getDeckCard(); + player.addCardToHand(card); + } + player.removeBooks(); + } + } + + findWinner(); + CompPlay.clearPlayerCards(); + Console.getStringInput("Game Over, Press any key to return to the lobby."); + } + + @Override + public void gameSetUp(GoFishPlayer user) { + addPlayer(user); + loadDecks(1); + + int numberOfPlayers = Console.getIntegerInput("How many other players would you like to play with? "); + addAIPlayers(numberOfPlayers); + dealCards(5); + for (GoFishPlayer player : getPlayers()) + CompPlay.setUpPlayerCards(player); + } + @Override + public void addAIPlayers(int playersToAdd) { + if(playersToAdd==0) + playersToAdd=1; + for (int i = 1; i <= playersToAdd; i++) + addPlayer(new GoFishPlayer(new Player("Computer" + i, 0, false))); + } + + private boolean goFish(GoFishPlayer player, GoFishPlayer otherPlayer, Rank cardRank) { + CompPlay.addRankToPlayer(player, cardRank); + if (otherPlayer.checkForCard(cardRank)) { + + ArrayList cardsTaken = otherPlayer.giveCards(cardRank); + CompPlay.removeRankFromPlayer(otherPlayer, cardRank); + for (Card card : cardsTaken) + player.addCardToHand(card); + System.out.println("Found " + cardsTaken.size() + " " + cardRank); + + + Console.getStringInput("press enter to continue"); + return false; + } else { + System.out.println("no matches found"); + Console.getStringInput("press enter to continue"); + return true; + } + } + + private GoFishPlayer chooseOtherPlayer(GoFishPlayer player, Rank cardRank) { + Integer playerIndex; + GoFishPlayer chosenPlayer; + if (player.isPerson()) { + printPlayers(); + do { + playerIndex = Console.getIntegerInput("\nWho has your card? "); + chosenPlayer = getPlayer(playerIndex); + } while (chosenPlayer == null); + } else chosenPlayer = CompPlay.choosePlayer(player, cardRank); + return chosenPlayer; + } + + + private Rank playerCardChoice(GoFishPlayer player) { + Rank cardRank; + if (player.isPerson()) { + do { + cardRank = Console.getRankInput("What card are you looking for?"); + } while (!player.checkForCard(cardRank)); + } else cardRank = CompPlay.chooseRank(player); + return cardRank; + } + + private void booksFound() { + for (GoFishPlayer player : getPlayers()) + System.out.println(player.getName() + " Completed Books: " + player.completedBooksToString()); + } + + private int booksRemaining() { + int booksMade = 0; + for (GoFishPlayer player : getPlayers()) + booksMade += player.getBookCount(); + return 13 - booksMade; + } + + private void printPlayers() { + for (int i = 1; i < getPlayers().size(); i++) + System.out.print(" " + i + ") " + getPlayer(i).getName()); + } + + private void findWinner() { + GoFishPlayer winner = null; + int topScore = 0; + for (GoFishPlayer player : getPlayers()) { + if (player.getPointTotal() > topScore) { + winner = player; + topScore = player.getPointTotal(); + } + System.out.println(player.getName() + ": " + player.getPointTotal() + " points"); + } + System.out.println("Winner: " + winner.getName() + " with " + topScore + " points!"); + } +} diff --git a/src/main/java/io/zipcoder/casino/GoFishPlayer.java b/src/main/java/io/zipcoder/casino/GoFishPlayer.java new file mode 100644 index 00000000..caeb304e --- /dev/null +++ b/src/main/java/io/zipcoder/casino/GoFishPlayer.java @@ -0,0 +1,86 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +import io.zipcoder.casino.Card.*; + + +public class GoFishPlayer extends CardPlayer { + + private ArrayList completedBooks = new ArrayList<>(); + private int books = 0; + private Map cardMap; + + public GoFishPlayer(Player player) { + super(player); + cardMap = new HashMap(); + } + + private void mapNewCard(Card card) { + Integer val = cardMap.getOrDefault(card.getRank(), 0); + cardMap.put(card.getRank(), val + 1); + } + + private void mapCardRemoved(Rank rank) { + Integer val = cardMap.get(rank); + cardMap.put(rank, val - 1); + } + + public boolean checkForCard(Rank rank) { + if (cardMap.getOrDefault(rank, 0) != 0) + return true; + return false; + } + + public ArrayList giveCards(Rank rank) { + + ArrayList cards = new ArrayList<>(); + while (checkForCard(rank)) { + cards.add(removeCard(rank)); + mapCardRemoved(rank); + } + return cards; + } + + public void removeBooks() { + for (Rank rank : cardMap.keySet()) + if (cardMap.get(rank) == 4) { + CompPlay.removeRankFromPlayer(this, rank); + addCompletedBooks(rank); + giveCards(rank); + books++; + System.out.println(getName() + " Completed Book: " + rank); + } + } + + public int getBookCount() { + return books; + } + + private void addCompletedBooks(Rank rank) { + completedBooks.add(rank); + } + + public String completedBooksToString() { + String complete = "|"; + for (Rank rank : completedBooks) + complete += " {" + rank + "} |"; + return complete; + } + + public int getPointTotal(){ + int points=0; + for (Rank rank : completedBooks) + points+=rank.getValue(); + return points; + } + + @Override + public void addCardToHand(Card card) { + mapNewCard(card); + super.addCardToHand(card); + } + +} 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..822ff961 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Hand.java @@ -0,0 +1,48 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; + +public class Hand { + private ArrayList hand; + + public Hand() { + hand = new ArrayList(); + } + + public void addCard(Card card) { + hand.add(card); + } + + public void addCard(ArrayList cards) { + hand.addAll(cards); + } + + public void clearHand() { + hand.clear(); + } + + public Card removeCard(Card.Rank rank) { + Card cardToRemove = null; + for (Card card : hand) + if (card.getRank().equals(rank)) { + cardToRemove = card; + break; + } + hand.remove(cardToRemove); + return cardToRemove; + } + + public String toString() { + String cardsInHand = "Hand is Empty."; + if (hand.size() > 0) { + cardsInHand = " {"+hand.get(0).toString()+"}"; + for (int i = 1; i < hand.size(); i++) + cardsInHand += " {" + hand.get(i).toString()+"}"; + } + return cardsInHand; + } + + public ArrayList getHand() { + return hand; + } +} diff --git a/src/main/java/io/zipcoder/casino/Player.java b/src/main/java/io/zipcoder/casino/Player.java new file mode 100644 index 00000000..fdb248a0 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Player.java @@ -0,0 +1,38 @@ +package io.zipcoder.casino; + +public class Player { + private String name; + private Hand hand; + private Integer cash; + private boolean isPerson; + + public Player(String name, Integer cash, boolean isPerson) { + this.name = name; + this.isPerson = isPerson; + this.cash = cash; + } + + public String getName() { + return name; + } + + public boolean isPerson() { + return isPerson; + } + + public Integer getCash(){ + return cash; + } + public void addCash(Integer amount){ + cash+=amount; + } + + public Integer withdrawalCash(Integer amount) { + if (amount > cash) + return 0; + else + cash-=amount; + return amount; + } + +} 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..9686d914 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/main.java @@ -0,0 +1,11 @@ +package io.zipcoder.casino; + +public class main { + + + + public static void main(String[] args) { + Casino casino=new Casino(); + casino.start(); + } +} diff --git a/src/test/java/io/zipcoder/casino/BlackJackGamblerTest.java b/src/test/java/io/zipcoder/casino/BlackJackGamblerTest.java new file mode 100644 index 00000000..8c44ea53 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/BlackJackGamblerTest.java @@ -0,0 +1,87 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class BlackJackGamblerTest { + + Player person; + BlackJackGambler player; + + @Before + public void setupTest() { + person = new Player("Sam", 1000, false); + player = new BlackJackGambler(person, 1000); + + Card fiveHeart = new Card(Card.Rank.FIVE, Card.Suit.HEARTS); + Card QueenHeart = new Card(Card.Rank.QUEEN, Card.Suit.HEARTS); + + player.addCardToHand(fiveHeart); + player.addCardToHand(QueenHeart); + + } + + + @Test + public void getChipCount() throws Exception { + Integer expected = 1000; + Integer actual = player.getChipCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void addChips() throws Exception { + Integer expected = player.getChipCount() + 1000; + player.addChips(1000); + Integer actual = player.getChipCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void placeBet() throws Exception { + Integer expectedBalance = player.getChipCount() - 500; + Integer expected = 500; + Integer actual = player.placeBet(500); + Integer actualBalance = player.getChipCount(); + + Assert.assertEquals(expected, actual); + Assert.assertEquals(expectedBalance, actualBalance); + } + + @Test + public void placeBet2() throws Exception { + + Integer expectedBalance = player.getChipCount() - player.getChipCount(); + Integer expected = 1000; + Integer actual = player.placeBet(1050); + Integer actualBalance = player.getChipCount(); + Assert.assertEquals(expected, actual); + Assert.assertEquals(expectedBalance, actualBalance); + } + + @Test + public void getHandTotal() throws Exception { + Integer expected = 15; + Integer actual = player.getHandTotal(); + } + + @Test + public void showHand() throws Exception { + String expected = "Sam: {FIVE of HEARTS} {QUEEN of HEARTS} Total: 15"; + String actual = player.showHand(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void tradeInChips() { + Integer expected = 1000; + Integer actual = player.tradeInChips(); + Assert.assertEquals(expected, actual); + } +} \ No newline at end of file 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..2ab5b48c --- /dev/null +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -0,0 +1,221 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.HashMap; + +public class BlackJackTest { + + BlackJackGambler p1; + BlackJackGambler p2; + BlackJackGambler p3; + BlackJack blackJack; + Dealer dealer; + ArrayList players; + + @Before + public void setup() { + blackJack = new BlackJack(); + players = new ArrayList(); + + p1 = new BlackJackGambler(new Player("Samwise", 10000, false),1000 ); + p2 = new BlackJackGambler(new Player("Frodo", 10000, false),1000 ); + p3 = new BlackJackGambler(new Player("Smeagol", 10, false),1000 ); + dealer= new Dealer(); + blackJack.addPlayer(p1); + blackJack.addPlayer(p2); + blackJack.addPlayer(p3); + + blackJack.gameSetUp(p2); + } + + @Test + public void isBustTest() throws Exception { + p1.addCardToHand(new Card(Card.Rank.ACE, Card.Suit.SPADES)); + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.ACE, Card.Suit.DIAMONDS)); + + System.out.println(p1.getHandTotal()); + boolean expected = false; +// boolean actual = blackJack.isBust(p1); + +// Assert.assertEquals(expected, actual); + } + + @Test + public void isBustTest2() throws Exception { +// p1.addCardToHand(new Card(Card.Rank.ACE, Card.Suit.SPADE)); + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.KING, Card.Suit.SPADES)); + + System.out.println(p1.getHandTotal()); + boolean expected = true; +// boolean actual = blackJack.isBust(p1); + +// Assert.assertEquals(expected, actual); + } + + @Test + public void resetHandsTest() throws Exception { + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + p2.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + p2.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + p3.addCardToHand(new Card(Card.Rank.KING, Card.Suit.SPADES)); + p3.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + + HashMap expected = new HashMap(); + HashMap actual = new HashMap(); + + for (Player p : players) { + expected.put(p, 0); + } + + +// blackJack.resetHands(); + + for (BlackJackGambler p : players) { + actual.put(p, p.getHand().size()); + } + + Assert.assertEquals(expected, actual); + } + + @Test + public void payoutWinningsTest1() throws Exception { + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + blackJack.gameSetUp(p1); +// blackJack.playerBet(p1, 250); + + Integer expected = p1.getChipCount()+500; +// blackJack.payoutWinnings(p1,2); + Integer actual = p1.getChipCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void payoutWinningsTest2() throws Exception { + p1.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.TEN, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.TEN, Card.Suit.DIAMONDS)); + blackJack.gameSetUp(p1); +// blackJack.playerBet(p1, 250); + + Integer expected = p1.getChipCount(); +// blackJack.payoutWinnings(p1,0); + Integer actual = p1.getChipCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void payoutWinningsTest3() throws Exception { + p1.addCardToHand(new Card(Card.Rank.ACE, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + blackJack.gameSetUp(p1); +// blackJack.playerBet(p1, 250); + + Integer expected = p1.getChipCount()+625; +// blackJack.payoutWinnings(p1,2); + Integer actual = p1.getChipCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void playerBetTest() throws Exception { + + int bet = 5; + +// blackJack.playerBet(p3, bet); + + int expected = p3.getChipCount() + bet; + +// blackJack.payoutWinnings(p3, 1); + + int actual = p3.getChipCount(); + + Assert.assertEquals(expected, actual); + + } + + @Test + public void takeBetTest() throws Exception { + Integer expected = 250; + Integer chipsBefore = p1.getChipCount()-250; + + Integer actual = blackJack.takeBet(p1); + Integer chipsAfter = p1.getChipCount(); + + Assert.assertEquals(expected, actual); + Assert.assertEquals(chipsBefore, chipsAfter); + } + + @Test + public void checkForBlackJackTest() throws Exception { + p1.addCardToHand(new Card(Card.Rank.ACE, Card.Suit.SPADES)); + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + + boolean expected=true; +// boolean actual =blackJack.checkForBlackJack(p1); + +// Assert.assertEquals(expected,actual); + } + + @Test + public void checkForBlackJackTest2() throws Exception { + p1.addCardToHand(new Card(Card.Rank.SEVEN, Card.Suit.SPADES)); + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + p1.addCardToHand(new Card(Card.Rank.FOUR, Card.Suit.DIAMONDS)); + + boolean expected=false; +// boolean actual =blackJack.checkForBlackJack(p1); +// +// Assert.assertEquals(expected,actual); + } + + @Test + public void addAIPlayers() throws Exception { + int expected=blackJack.getPlayers().size()+3; + blackJack.addAIPlayers(3); + int actual = blackJack.getPlayers().size(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void removeZeroChipPlayers() throws Exception { + BlackJackGambler p4 = new BlackJackGambler(new Player("Frodo", 10000, false),0 ); + BlackJackGambler p5 = new BlackJackGambler(new Player("Smeagol", 10, false),0 ); + + blackJack.addPlayer(p4); + blackJack.addPlayer(p5); + + int expected=blackJack.getPlayers().size()-2; +// blackJack.removeZeroChipPlayers(); + int actual=blackJack.getPlayers().size(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void payoutMultiplierTest(){ + p1.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + Integer expected=2; +// Integer actual=blackJack.payoutMultiplier(p1); +// Assert.assertEquals(expected,actual); + } + + @Test + public void payoutMultiplierTest2(){ + Integer expected=1; +// Integer actual=blackJack.payoutMultiplier(dealer); +// Assert.assertEquals(expected,actual); + } +} \ No newline at end of file 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..fc607859 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/CardTest.java @@ -0,0 +1,37 @@ +package io.zipcoder.casino; +import org.junit.Assert; +import org.junit.Test; + +import static io.zipcoder.casino.Card.Rank.*; +import static io.zipcoder.casino.Card.Suit.*; + +public class CardTest { + + Card card1= new Card(EIGHT, HEARTS); + Card card2= new Card(EIGHT, DIAMONDS); + Card card3= new Card(EIGHT, SPADES); + Card card4= new Card(EIGHT, CLUBS); + + @Test + public void getValueTest() throws Exception { + int expected =8; + int actual= card1.getValue(); + Assert.assertEquals(expected,actual); + } + + @Test + public void getSuitTest() throws Exception { + Card.Suit expected =HEARTS; + Card.Suit actual=card1.getSuit(); + Assert.assertEquals(expected, actual); + } + + @Test + public void suitValTest(){ + System.out.println(card1); + System.out.println(card2); + System.out.println(card3); + System.out.println(card4); + } + +} \ 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 deleted file mode 100644 index e9286523..00000000 --- a/src/test/java/io/zipcoder/casino/CasinoTest.java +++ /dev/null @@ -1,5 +0,0 @@ -package io.zipcoder.casino; - - -public class CasinoTest { -} diff --git a/src/test/java/io/zipcoder/casino/CompPlayTest.java b/src/test/java/io/zipcoder/casino/CompPlayTest.java new file mode 100644 index 00000000..f1d339e5 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/CompPlayTest.java @@ -0,0 +1,154 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Collections; + +public class CompPlayTest { + + GoFishPlayer p1; + GoFishPlayer p2; + GoFishPlayer p3; + BlackJackGambler p4; + Dealer dealer; + + @Before + public void Setup() { + + + p1 = new GoFishPlayer(new Player("joe", 100, false)); + p2 = new GoFishPlayer(new Player("james", 100, false)); + p3 = new GoFishPlayer(new Player("dave", 100, false)); + p4 = new BlackJackGambler(new Player("dave", 100, false),1000); + + dealer = new Dealer(); + + ArrayList players = new ArrayList<>(); + Collections.addAll(players, p1, p2, p3); + CompPlay.setUpPlayerCards(p1); + CompPlay.setUpPlayerCards(p2); + CompPlay.setUpPlayerCards(p3); + } + + @Test + public void basicHitOrStayTest() throws Exception { + p4.addCardToHand(new Card(Card.Rank.THREE, Card.Suit.HEARTS)); + p4.addCardToHand(new Card(Card.Rank.FIVE, Card.Suit.DIAMONDS)); + + String expected="Hit"; + String actual=CompPlay.hitOrStay(p4); + + Assert.assertEquals(expected,actual); + } + + @Test + public void basicHitOrStayTest2() throws Exception { + p4.addCardToHand(new Card(Card.Rank.TEN, Card.Suit.HEARTS)); + p4.addCardToHand(new Card(Card.Rank.NINE, Card.Suit.DIAMONDS)); + + String expected="Stay"; + String actual=CompPlay.hitOrStay(p4); + + Assert.assertEquals(expected,actual); + } + + @Test + public void dealerHitOrStayTest() throws Exception { + dealer.addCardToHand(new Card(Card.Rank.THREE, Card.Suit.HEARTS)); + dealer.addCardToHand(new Card(Card.Rank.SIX, Card.Suit.DIAMONDS)); + + String expected="Hit"; + String actual=CompPlay.hitOrStay(dealer); + + Assert.assertEquals(expected,actual); + } + + @Test + public void dealerHitOrStayTest2() throws Exception { + dealer.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.HEARTS)); + dealer.addCardToHand(new Card(Card.Rank.EIGHT, Card.Suit.DIAMONDS)); + + String expected="Stay"; + String actual=CompPlay.hitOrStay(dealer); + + Assert.assertEquals(expected,actual); + } + + @Test + public void makeBetTest() throws Exception { + Integer expected=250; + Integer actual =CompPlay.makeBet(p4); + Assert.assertEquals(expected,actual); + } + + + @Test + public void addRankToPlayer() throws Exception { + + String before = CompPlay.getPlayerCards(); + + CompPlay.addRankToPlayer(p1, Card.Rank.THREE); + CompPlay.addRankToPlayer(p1, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p2, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p3, Card.Rank.SIX); + CompPlay.addRankToPlayer(p3, Card.Rank.SEVEN); + + String after = CompPlay.getPlayerCards(); + + Assert.assertNotEquals(before, after); + } + + @Test + public void removeRankFromPlayer() throws Exception { + + + CompPlay.addRankToPlayer(p1, Card.Rank.THREE); + CompPlay.addRankToPlayer(p1, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p1, Card.Rank.TEN); + + String expected = "[THREE, FIVE]\n[]\n[]\n"; + + CompPlay.removeRankFromPlayer(p1, Card.Rank.TEN); + + String actual = CompPlay.getPlayerCards(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void chooseRank() throws Exception { + p1.addCardToHand(new Card(Card.Rank.FIVE, Card.Suit.HEARTS)); + p1.addCardToHand(new Card(Card.Rank.THREE, Card.Suit.HEARTS)); + CompPlay.addRankToPlayer(p1, Card.Rank.THREE); + CompPlay.addRankToPlayer(p1, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p2, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p3, Card.Rank.SIX); + CompPlay.addRankToPlayer(p3, Card.Rank.SEVEN); + + + Card.Rank expected = Card.Rank.FIVE; + + Card.Rank actual = CompPlay.chooseRank(p1); + + Assert.assertEquals(expected, actual); + } + + @Test + public void choosePlayer() throws Exception { + CompPlay.addRankToPlayer(p1, Card.Rank.THREE); + CompPlay.addRankToPlayer(p1, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p2, Card.Rank.FIVE); + CompPlay.addRankToPlayer(p3, Card.Rank.SIX); + CompPlay.addRankToPlayer(p3, Card.Rank.SEVEN); + + String expected = p2.getName(); + + String actual = CompPlay.choosePlayer(p1, Card.Rank.FIVE).getName(); + + Assert.assertEquals(expected, actual); + } + +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/CrapsPlayerTest.java b/src/test/java/io/zipcoder/casino/CrapsPlayerTest.java new file mode 100644 index 00000000..f501ed75 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/CrapsPlayerTest.java @@ -0,0 +1,51 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class CrapsPlayerTest { + + CrapsPlayer player; + + @Before + public void setup() { + player = new CrapsPlayer(new Player("Tester", 100, true), 10); + } + + @Test + public void getChipCount() throws Exception { + int expected = 10; + int actual = player.getChipCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void tradeInChips() throws Exception { + int expected = 10; + int actual = player.tradeInChips(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void addChips() throws Exception { + + int plusValue = 10; + + int chipsBeforeAdd = player.getChipCount(); + player.addChips(plusValue); + int chipsAfterAdd = chipsBeforeAdd + plusValue; + + int expected = chipsAfterAdd - chipsBeforeAdd; + int actual = player.getChipCount(); + } + + @Test + public void placeBet() throws Exception { + } + +} \ No newline at end of file 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..9afee0c6 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/CrapsTest.java @@ -0,0 +1,32 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class CrapsTest { + + CrapsPlayer player; + Craps craps; + + @Before + public void setup() { + player = new CrapsPlayer(new Player("SumYunGai" , 9001, true), 100); + craps = new Craps(); + } + + @Test + public void payOut() throws Exception { + int chipsBefore = player.getChipCount(); + craps.payOut(player, 100, 2); + int chipsAfter = player.getChipCount(); + + int expectedChange = 200; + int actualChange = chipsAfter - chipsBefore; + + Assert.assertEquals(expectedChange, actualChange); + } + +} \ No newline at end of file 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..ab2204ec --- /dev/null +++ b/src/test/java/io/zipcoder/casino/DealerTest.java @@ -0,0 +1,42 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DealerTest { + Dealer dealer; + Deck deck; + + @Before + public void setup() { + deck = new Deck(1); + dealer = new Dealer(); + } + + @Test + public void showOneCardTest() throws Exception { + Card first = new Card(Card.Rank.JACK, Card.Suit.SPADES); + dealer.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + dealer.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + String expected = "Dealer: " + first.toString(); + String actual = dealer.showOneCard(); + Assert.assertNotEquals(expected, actual); + + } + + @Test + public void resetHandTest() throws Exception { + + dealer.addCardToHand(new Card(Card.Rank.JACK, Card.Suit.DIAMONDS)); + dealer.addCardToHand(new Card(Card.Rank.QUEEN, Card.Suit.DIAMONDS)); + int before = dealer.getHand().size(); + dealer.resetHand(); + int after = dealer.getHand().size(); + + Assert.assertNotEquals(before, after); + } + +} \ No newline at end of file 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..c682600b --- /dev/null +++ b/src/test/java/io/zipcoder/casino/DeckTest.java @@ -0,0 +1,55 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +public class DeckTest { + Deck deck = new Deck(1); + + @Test + public void multiDeckTest() throws Exception { + deck=new Deck(2); + String expected=""; + while (deck.getRemainingCards() != 0) { + expected+=deck.getCard()+"\n"; + } + expected.concat(expected); + + String actual=""; + deck = new Deck(2); + while (deck.getRemainingCards() != 0) { + actual+=deck.getCard().toString()+"\n"; + } + + Assert.assertEquals(expected, actual); + } + + @Test + public void getCard() throws Exception { + Card expected = new Card(Card.Rank.TWO, Card.Suit.CLUBS); + Card actual = deck.getCard(); + + Assert.assertEquals(expected.toString(), actual.toString()); + } + + @Test + public void shuffleDeck() throws Exception { + + String newDeck=""; + deck = new Deck(1); + while (deck.getRemainingCards() != 0) { + newDeck+=deck.getCard()+"\n"; + } + + + String shuffledDeck=""; + deck = new Deck(1); + deck.shuffleDeck(); + while (deck.getRemainingCards() != 0) { + shuffledDeck+=deck.getCard().toString()+"\n"; + } + + Assert.assertNotEquals(newDeck, shuffledDeck); + } + +} \ No newline at end of file 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..8ebcce65 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/DieTest.java @@ -0,0 +1,35 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DieTest { + + Die d6; + + @Before + public void setup() { + d6 = new Die(); + } + + @Test + public void getValue() throws Exception { + int expected = 0; + int actual = d6.getValue(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void rollDie() throws Exception { + + d6.rollDie(); + double expected = 3d; + double actual = d6.getValue(); + + Assert.assertEquals(expected, actual, 3); + } +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/GoFishPlayerTest.java b/src/test/java/io/zipcoder/casino/GoFishPlayerTest.java new file mode 100644 index 00000000..c93a42dc --- /dev/null +++ b/src/test/java/io/zipcoder/casino/GoFishPlayerTest.java @@ -0,0 +1,117 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.ArrayList; + +public class GoFishPlayerTest { + + + + GoFishPlayer joe = new GoFishPlayer(new Player("Joe", 1000, false)); + GoFishPlayer player = new GoFishPlayer(joe); + + + Card threeHeart = new Card(Card.Rank.THREE, Card.Suit.HEARTS); + Card threeClub = new Card(Card.Rank.THREE, Card.Suit.CLUBS); + Card threeSpade = new Card(Card.Rank.THREE, Card.Suit.SPADES); + Card fiveHeart = new Card(Card.Rank.FIVE, Card.Suit.HEARTS); + Card QueenHeart = new Card(Card.Rank.QUEEN, Card.Suit.HEARTS); + + { + player.addCardToHand(threeHeart); + player.addCardToHand(threeClub); + player.addCardToHand(threeSpade); + player.addCardToHand(fiveHeart); + player.addCardToHand(QueenHeart); + CompPlay.setUpPlayerCards(player); + } + + @Test + public void giveCardsTest() throws Exception { + String expected = " " + threeHeart + " " + threeClub + " " + threeSpade; + String actual = ""; + + String remainingExpected = "" + fiveHeart + QueenHeart; + String remainingActual = ""; + + ArrayList cards = player.giveCards(Card.Rank.THREE); + + for (Card card : cards) + actual += " " + card; + + for (Card card : player.getHand()) + remainingActual += card.toString(); + + Assert.assertEquals(expected, actual); + Assert.assertEquals(remainingExpected, remainingActual); + + } + + + @Test + public void checkForCardTest1() throws Exception { + boolean expected =false; + + boolean actual=player.checkForCard(Card.Rank.KING); + Assert.assertEquals(expected,actual); + } + + @Test + public void checkForCardTest2() throws Exception { + boolean expected =true; + boolean actual=player.checkForCard(Card.Rank.QUEEN); + Assert.assertEquals(expected,actual); + } + + @Test + public void removeBooksTest() throws Exception { + Card threeDiamond = new Card(Card.Rank.THREE, Card.Suit.DIAMONDS); + player.addCardToHand(threeDiamond); + System.out.println(player.handToString()); + int expected=1; + player.removeBooks(); + int actual =player.getBookCount(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void getBookCountTest() throws Exception{ + Card threeDiamond = new Card(Card.Rank.THREE, Card.Suit.DIAMONDS); + player.addCardToHand(threeDiamond); + player.removeBooks(); + int expected=1; + int actual=player.getBookCount(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void completedBooksToStringTest() throws Exception { + Card threeDiamond = new Card(Card.Rank.THREE, Card.Suit.DIAMONDS); + String expected="| {THREE} |"; + player.addCardToHand(threeDiamond); + player.removeBooks(); + String actual =player.completedBooksToString(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void handToStringTest() throws Exception{ + System.out.println(player.handToString()); + } + + @Test + public void getPointTotalTest() throws Exception { + int expected=3; + Card threeDiamond = new Card(Card.Rank.THREE, Card.Suit.DIAMONDS); + player.addCardToHand(threeDiamond); + player.removeBooks(); + int actual=player.getPointTotal(); + + Assert.assertEquals(expected,actual); + } +} \ No newline at end of file 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..acf63c7a --- /dev/null +++ b/src/test/java/io/zipcoder/casino/GoFishTest.java @@ -0,0 +1,29 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class GoFishTest { + GoFish goFish=new GoFish(); + GoFishPlayer joe=new GoFishPlayer(new Player("joe",10, false)); + + @Test + public void play() throws Exception { + goFish.play(joe); + } + + @Test + public void addAIPlayers() throws Exception { + String expected="Computer 1 Computer 2 "; + String actual=""; + goFish.addAIPlayers(2); + for (GoFishPlayer player:goFish.getPlayers()) + actual+=player.getName()+" "; + + Assert.assertEquals(expected, actual); + } + + +} \ No newline at end of file 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..98d2f676 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/HandTest.java @@ -0,0 +1,94 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; + +public class HandTest { + Hand hand; + Card card; + Card card2; + + Card cardOther; + Card cardOther2; + Card cardOther3; + + @Before + public void setup() { + hand = new Hand(); + card = new Card(Card.Rank.FIVE, Card.Suit.HEARTS); + card2 = new Card(Card.Rank.THREE, Card.Suit.CLUBS); + + cardOther = new Card(Card.Rank.NINE, Card.Suit.SPADES); + cardOther2 = new Card(Card.Rank.TWO, Card.Suit.DIAMONDS); + cardOther3 = new Card(Card.Rank.QUEEN, Card.Suit.HEARTS); + } + + @Test + public void addCardTest() throws Exception { + String expected = "FIVE of HEART\nTHREE of CLUB"; + hand.addCard(card); + hand.addCard(card2); + String actual = hand.toString(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void addCard1Test() throws Exception { + ArrayList cards = new ArrayList(); + + String expected = "FIVE of HEART\nTHREE of CLUB\nNINE of SPADE\nTWO of DIAMOND\nQUEEN of HEART"; + + hand.addCard(card); + hand.addCard(card2); + + cards.add(cardOther); + cards.add(cardOther2); + cards.add(cardOther3); + + hand.addCard(cards); + + String actual = hand.toString(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void clearHandTest() throws Exception { + String expected = "Hand is Empty."; + + hand.addCard(card); + hand.addCard(card2); + + hand.clearHand(); + String actual = hand.toString(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void removeCardTest() throws Exception { + ArrayList cards = new ArrayList(); + + String expected = "FIVE of HEART\nTHREE of CLUB\nNINE of SPADE\nTWO of DIAMOND\nQUEEN of HEART"; + + hand.addCard(card); + hand.addCard(card2); + + hand.addCard(cardOther); + cards.add(cardOther2); + cards.add(cardOther3); + + hand.addCard(cards); + + String actual = hand.toString(); + + Assert.assertEquals(expected, actual); + + } + + +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/PlayerTest.java b/src/test/java/io/zipcoder/casino/PlayerTest.java new file mode 100644 index 00000000..b41b61c9 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/PlayerTest.java @@ -0,0 +1,55 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PlayerTest { + Player player=new Player("Jake", 1000,false ); + + @Test + public void getNameTest() throws Exception { + String expected="Jake"; + String actual=player.getName(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void isPersonTest() throws Exception { + boolean expected=false; + boolean actual=player.isPerson(); + + Assert.assertEquals(expected, actual); + } + + @Test + public void getCashTest() throws Exception { + Integer expected=1000; + Integer actual = player.getCash(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void addCashTest() throws Exception { + Integer expected=player.getCash()+1000; + player.addCash(1000); + Integer actual=player.getCash(); + + Assert.assertEquals(expected,actual); + } + + @Test + public void withdrawalCashTest() throws Exception { + Integer expected=player.getCash()-500; + Integer withdrawn=player.withdrawalCash(500); + Integer actual=player.getCash(); + + Assert.assertEquals(expected,actual); + Assert.assertEquals(500,withdrawn.intValue()); + + } + +} \ No newline at end of file