version 1.0

src/main/java/io/zipcoder/casino/BlackJack.java

@@ -0,0 +1,156 @@
+package io.zipcoder.casino;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+public class BlackJack extends CardGame {
+
+    protected Dealer dealer1 = new Dealer();
+    private BlackJackPlayer player1;
+    private Console console = new Console();
+
+    public BlackJack(Player player) {
+        this.player1 = new BlackJackPlayer(player);
+
+    }
+
+    public BlackJackPlayer getPlayer(){
+        return player1;
+    }
+
+    public void setPlayer(BlackJackPlayer player1) {
+        this.player1 = player1;
+    }
+
+
+
+    public void playRound() {
+        double wager = console.getDoubleInput(blackJackWelcome());
+        player1.setWagerAmount(wager);
+
+        dealer1.deal(2, player1);
+        console.print(playerTotalsOutput());
+
+        dealer1.deal(2, dealer1);
+
+        blackJackRound();
+
+        adjustFunds();
+
+        playerWinLoss();
+    }
+
+
+    public String blackJackWelcome(){
+        return "Welcome to BlackJack!  Please enter your bet: ";
+    }
+
+
+    public String playerTotalsOutput(){
+        return "Your cards are " + player1.getPlayerHand().toString().trim() + "\n"
+                +"Your current total is " + player1.getPlayerHand().getTotal();
+    }
+
+    public String dealerTotalOutput(){
+        return "The dealer's cards are " + dealer1.getHand().toString().trim() + "\n"
+                + "The dealer's total is " + dealer1.getHand().getTotal();
+    }
+
+    public String hitOrStand(){
+        return "Would you like to hit or stand?";
+    }
+
+
+
+    public void blackJackRound(){
+            if (dealerBlackJackorBust(dealer1.getHand())){
+            } else if (playerBlackJackorBust(dealer1.getHand()))  {
+            } else{
+                playerSubRound();
+                dealerSubRound();
+            }
+    }
+
+
+
+    public void playerSubRound() {
+        String userInput = console.getStringInput(hitOrStand());
+            while (userInput.equalsIgnoreCase("Hit")|| userInput.equalsIgnoreCase("hit")) {
+                if (playerBlackJackorBust(player1.getPlayerHand())) {
+                    break;
+                } else if (userInput.equalsIgnoreCase("Stand") || userInput.equalsIgnoreCase("stand")) {
+                    break;
+                } else if (userInput.equalsIgnoreCase("Hit") || userInput.equalsIgnoreCase("hit")) {
+                    dealer1.pluck(player1.getPlayerHand());
+                    console.print(playerTotalsOutput());
+                    if(player1.getPlayerHand().getTotal() < 21){
+                        userInput = console.getStringInput(hitOrStand());}
+                }
+            }
+        }
+
+    public boolean playerBlackJackorBust(Hand playerhand){
+        if (playerhand.getTotal() >= 21){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    public boolean dealerBlackJackorBust(Hand dealerhand){
+        if (dealerhand.getTotal() == 21 || dealerhand.getTotal() > 21){
+            return true;
+        }else{
+            return false;
+        }
+
+    }
+
+
+    public void dealerSubRound(){
+        while (dealer1.getHand().getTotal() <= 16) {
+                dealer1.pluck(dealer1.getHand());
+                break;
+            }
+
+    }
+
+    public boolean getResult(){
+        int dealerTotal = dealer1.getHand().getTotal();
+        int playerTotal = player1.getPlayerHand().getTotal();
+        if (dealerTotal > playerTotal && dealerTotal <= 21){
+            return false;
+        }else if(playerTotal > 21){
+            return false;
+        }else{
+            return true;
+        }
+    }
+
+    public void playerWinLoss(){
+        if (getResult()) {
+            console.print(dealerTotalOutput());
+            console.print("YOU WON!");
+            console.print("Your new account balance is " + String.format("%.2f", player1.getMoney()));
+        }else {
+            console.print(dealerTotalOutput());
+            console.print("YOU LOST!");
+            console.print("Your new account balance is " + String.format("%.2f", player1.getMoney()));
+        }
+
+    }
+
+
+    public void adjustFunds() {
+        if (getResult() == true) {
+            player1.setMoney(player1.getMoney() + (player1.getWagerAmount() * 1.5));
+
+        } else {
+            player1.setMoney(player1.getMoney() - player1.getWagerAmount());
+        }
+
+    }
+
+}

src/main/java/io/zipcoder/casino/BlackJackPlayer.java

@@ -0,0 +1,79 @@
+
+package io.zipcoder.casino;
+
+public class BlackJackPlayer implements Gambler {
+    private Player player;
+    private Hand playerHand = new Hand();
+    private double money;
+    private int age;
+    private String name;
+    private double wagerAmount;
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public void setPlayer(Player player) {
+        this.player = player;
+    }
+
+    public double getMoney() {
+        return money;
+    }
+
+    public void setMoney(double money) {
+        this.money = money;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setWagerAmount(double wagerAmount){
+        this.wagerAmount = wagerAmount;
+    }
+
+    public double getWagerAmount(){
+        return wagerAmount;
+    }
+
+
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public BlackJackPlayer(Player player) {
+
+        this.name = player.getName();
+        this.money = player.getMoney();
+        this.age = player.getAge();
+        this.player = player;
+    }
+
+    public void gamble(double wagerAmount) {
+        if (player.getMoney() < wagerAmount) {
+            System.out.println("You don't have enough money to cover that bet");
+        } else {
+            wagerAmount = wagerAmount * -1;
+            player.setMoney(player.getMoney() - wagerAmount);
+        }
+    }
+
+    public void setPlayerHand(Hand playerHand) {
+        this.playerHand = playerHand;
+    }
+
+    public Hand getPlayerHand() {
+        return playerHand;
+    }
+}
+

src/main/java/io/zipcoder/casino/Card.java

@@ -0,0 +1,29 @@
+package io.zipcoder.casino;
+
+public class Card implements Comparable<Card>{
+
+
+    private final Rank rank;
+    private final Suit suit;
+
+    Card(Rank rank, Suit suit) {
+        this.rank = rank;
+        this.suit = suit;
+    }
+
+    public int compareTo(Card o) {
+        if(o.getRank().getGoFishValue() > this.getRank().getGoFishValue()) {
+            return -1;
+        }else
+            return 1;
+        }
+
+
+    public Rank getRank() {
+        return rank;
+    }
+
+    public Suit getSuit() {
+        return suit;
+    }
+}

src/main/java/io/zipcoder/casino/CardGame.java

@@ -0,0 +1,16 @@
+package io.zipcoder.casino;
+
+public class CardGame implements Game {
+    private Deck deck = new Deck();
+    private Dealer dealer;
+
+    public void playRound(){}
+
+    public boolean gameOver(){ return false;}
+
+    public boolean playing() {
+        return false;
+    }
+
+
+}

src/main/java/io/zipcoder/casino/Casino.java

@@ -1,5 +1,97 @@
 package io.zipcoder.casino;
 
 
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Scanner;
+
 public class Casino {
-}
+    private Player player;
+    private int response;
+//    private InputStream in;
+//    private PrintStream outprint;
+    private Game game;
+    private Console console = new Console();
+
+    public static void main(String[] args) {
+        Casino casino = new Casino();
+        casino.createPlayer();
+        casino.playGame();
+    }
+
+    public Casino() {
+//        this.player = player;
+    }
+
+    public String findName(){
+        return console.getStringInput("Please enter your name.");
+    }
+
+    public int findAge(){
+        return console.getIntegerInput("Please enter your age.");
+    }
+
+    public double findMoney(){
+        return console.getDoubleInput("Please enter the amount of money in your account");
+    }
+
+    public void createPlayer(){
+        player = new Player(findName(), findAge(), findMoney());
+    }
+
+    public void playGame() {
+        selectGamePrompt();
+        response = selectedGame();
+        while (response == 1 || response == 2 || response == 3) {
+            startGame();
+            selectGame();
+//            response = selectedGame();
+        }
+        console.print("Thank you for visiting ZipCasino");
+    }
+
+    public void selectGame() {
+        console.print("Welcome " + player.getName() + " to ZipCasino");
+        selectGamePrompt();
+        selectedGame();
+    }
+
+    public int selectedGame(){
+        int output = console.getIntegerInput("Enter the number for what game you want to play.");
+        return output;
+    }
+
+    public void startGame(){
+        startCraps();
+        startBlackJack();
+        startGoFish();
+    }
+
+    public void startCraps(){
+        if (response == 1) {
+            game = new Craps(player);
+            game.playRound();
+        }
+    }
+
+    public void startBlackJack(){
+        if (response == 2) {
+            game = new BlackJack(player);
+            game.playRound();
+        }
+    }
+
+    public void startGoFish(){
+        if (response == 3) {
+            game = new GoFish(player);
+            game.playRound();
+        }
+    }
+
+    public void selectGamePrompt(){
+        console.print("1: Craps");
+        console.print("2: BlackJack");
+        console.print("3: Go Fish. WIP");
+        console.print("Press any other key to leave.");
+    }
+}

src/main/java/io/zipcoder/casino/Console.java

@@ -0,0 +1,41 @@
+package io.zipcoder.casino;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Scanner;
+
+public class Console {
+
+    private Scanner scanner = new Scanner(System.in);
+
+
+//    public Console(String input) {
+//        this.scanner = new Scanner(input);
+//    }
+
+public void print(String str){
+    System.out.println(str);
+}
+
+
+
+
+
+//    public  void print(String str, Object... args) {
+//        output.println(String.format(str, args));
+//    }
+//
+    public  String getStringInput(String prompt) {
+        print(prompt);
+        String input = scanner.nextLine();
+        return input;
+    }
+
+    public  Double getDoubleInput(String prompt) {
+        return Double.parseDouble(getStringInput(prompt));
+    }
+
+    public Integer getIntegerInput(String prompt) {
+        return getDoubleInput(prompt).intValue();
+    }
+}

src/main/java/io/zipcoder/casino/Craps.java

@@ -0,0 +1,220 @@
+package io.zipcoder.casino;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.Scanner;
+
+public class Craps extends DiceGame {
+
+    private  double balance = 0;
+    private  double wager = 0;
+    private  CrapsPlayer player;
+    private int roll = throwDice();
+    private int point = throwDice();
+    private Console console = new Console();
+
+    public void setBalance(double balance) {
+        this.balance = balance;
+    }
+
+    public double getWager() {
+        return wager;
+    }
+
+    public CrapsPlayer getPlayer() {
+        return player;
+    }
+
+    public void setPlayer(CrapsPlayer player) {
+        this.player = player;
+    }
+
+    public int getRoll() {
+        return roll;
+    }
+
+    public void setRoll(int roll) {
+        this.roll = roll;
+    }
+
+    public void setPointTester(int point) {
+        this.point = point;
+    }
+
+    public Craps(Player player) {
+        this.player = new CrapsPlayer(player);
+       // player.getMoney(accountBalance());
+    }
+
+    public void instantWin(){
+        console.print("AYYYYY! YOU ROLLED A " + point + "!! GOOD JOB");
+        this.addWinnings();
+        console.print("Your new balance is "  + balance);
+    }
+
+    public void instantLose(){
+        console.print("Daaaamn homie, You rolled a " + point +" & crapped out! It's not looking to good for ya!");
+        this.subtractWinnings();
+        console.print("Your new balance is "  + balance);
+    }
+
+    public int setPoint(){
+        int point = rollDice();
+       console.print("Your point is now " + point + "..... You got this!");
+        return point;
+    }
+
+    public int chasePoint(){
+        console.print("You rolled a " + roll );
+        return roll;
+    }
+
+
+
+
+
+    public int throwDice(){
+       Dice dice = new Dice(2);
+       return dice.tossAndSum();
+    }
+
+
+    public void accountBalance(){
+
+       balance = console.getDoubleInput("How much money are you bringing to the table today?");
+    }
+
+
+    public  void addWinnings(){
+        balance = balance + wager;
+
+    }
+
+    public  void betAmount(){
+
+        wager = console.getDoubleInput("How much would you like to wager?");
+
+
+
+
+    }
+
+    public void lookForMatchPoint(int currentRoll){
+        int roll = 0;
+
+        console.print("Your point is " + point);
+        while (roll != 7) {
+            roll = throwDice();
+           console.print("You rolled a " + roll);
+            if (point == roll) {
+                this.winningRoll();
+                break;
+            }
+         else if(roll == 7) {
+                this.losingRoll();
+            }
+        }
+    }
+
+    public  void subtractWinnings(){
+        balance = balance - wager;
+
+    }
+
+    public  int rollDice(){
+        int roll = throwDice();
+
+        return roll;
+    }
+
+    public  void winningRoll(){
+        console.print("OK K K! WE HAVE A WINNER! STACK YA PAPER");
+        this.addWinnings();
+        console.print("Your new balance is "  + balance);
+    }
+
+    public void losingRoll(){
+        console.print("SMH YOU LOST! YOU MIGHT WANT TO CHOOSE ANOTHER GAME PLAYA!");
+        this.subtractWinnings();
+        console.print("Your new balance is "  + balance);
+    }
+
+
+
+    public  void promptUser(){
+
+
+
+        String answer1;
+
+        System.out.println();
+
+        console.print("Welcome to Craps! \n\n" +
+                "The rules of the game are as follows: \n" +
+                "If your first roll is is 7 or 11 you instantly win! \n" +
+                "If your first roll is 2 or 3 or 12 you instantly lose! \n" +
+                "When the first roll is 4,5,6,8,9 or 10, that will become your \"point\"! \n" +
+                "You WIN by re-rolling the \"point\" before rolling a 7! \n" +
+                "If you roll a 7 before your \"point\" you LOSE!");
+
+
+        answer1 = console.getStringInput("Would you like to play?");
+
+        answer1.equalsIgnoreCase("Yes");
+
+
+
+
+        console.print("\nGOOD LUCK... Your gonna need it! \n");
+
+
+
+    }
+
+    public  void setWager(double wager) {
+     this.wager = wager;
+    }
+
+    public  double getBalance() {
+        return balance;
+    }
+
+    public  int getPoint() {
+        return point;
+    }
+
+    public void playRound(){
+
+        promptUser();
+        accountBalance();
+        betAmount();
+
+        Scanner scanner = new Scanner(System.in);
+        String continuePlayAnswer;
+
+        do {
+            //calls the throw dice method to create 2 dice and give the sum of the 2.
+
+            //checks to see if the player instantly wins or loses
+            point = throwDice();
+
+            if ( point== 7 || point == 11) {
+                this.instantWin();
+            } else if (point == 2 || point == 3 || point == 12) {
+                this.instantLose();
+            //sets point and checks to see if the player rolls the point
+            } else lookForMatchPoint(point);
+
+
+            if(balance == 0) {
+                System.out.println("Sadly, you've lost all your money I think it's time for you to go home for the evening BUDDY! :(");
+                break;
+            }
+            System.out.println("Would you like to roll again?");
+            continuePlayAnswer = scanner.nextLine();
+        }while (continuePlayAnswer.trim().equalsIgnoreCase("yes"));
+
+    }
+}
+

src/main/java/io/zipcoder/casino/CrapsPlayer.java

@@ -0,0 +1,19 @@
+
+package io.zipcoder.casino;
+
+public class CrapsPlayer implements Gambler {
+    private Player player;
+
+    public CrapsPlayer(Player player) {
+        this.player = player;
+    }
+
+    public void gamble(double wagerAmount) {
+        if (player.getMoney() < wagerAmount) {
+            System.out.println("You don't have enough money to cover that bet");
+        } else {
+            wagerAmount = wagerAmount * -1;
+            player.setMoney(wagerAmount);
+        }
+    }
+}

src/main/java/io/zipcoder/casino/Dealer.java

@@ -0,0 +1,56 @@
+package io.zipcoder.casino;
+
+public class Dealer {
+    private Hand dealerHand = new Hand();
+    Deck newDeck = new Deck();
+
+    public Hand getHand(){
+        return dealerHand;
+    }
+
+    public void setHand(Hand hand){
+        this.dealerHand = hand;
+    }
+
+    public void pluck(Hand playerHand) {
+        Card newCard = newDeck.pop();
+        playerHand.add(newCard);
+    }
+
+    public Deck getNewDeck() {
+        return newDeck;
+    }
+
+    public void deal(int numberOfCards, BlackJackPlayer player1){
+        newDeck.shuffleCards();
+        for (int i = 1; i <= numberOfCards; i++){
+            Card newCard = newDeck.pop();
+            Hand player1Hand = player1.getPlayerHand();
+            player1Hand.add(newCard);
+        }
+
+    }
+
+    public void deal(int numberOfCards, GoFishPlayer player2){
+        newDeck.shuffleCards();
+        for (int i = 1; i <= numberOfCards; i++){
+            Card newCard = newDeck.pop();
+            Hand player2Hand = player2.getPlayerHand();
+            player2Hand.add(newCard);
+        }
+
+    }
+
+    public void deal(int numberOfCards, Dealer dealer){
+        newDeck.shuffleCards();
+        for (int i = 1; i <= numberOfCards; i++){
+            Card newCard = newDeck.pop();
+            Hand dealerHand = dealer.getHand();
+            dealerHand.add(newCard);
+        }
+
+
+
+    }
+
+}

src/main/java/io/zipcoder/casino/Deck.java

@@ -0,0 +1,49 @@
+package io.zipcoder.casino;
+
+import java.util.Collections;
+import java.util.Stack;
+
+
+    public class Deck {
+
+
+        private Stack<Card> cards = new Stack<Card>();
+
+        public Deck() {
+            setCards();
+        }
+
+        public int getDeckSize(){
+            return cards.size();
+        }
+
+        public Stack<Card> getCards() {
+            return cards;
+        }
+
+        public void setCards() {
+            for (Suit suit : Suit.values()) {
+                for (Rank rank : Rank.values()) {
+                    cards.push(new Card(rank, suit));
+                }
+            }
+        }
+
+            public void shuffleCards () {
+                Collections.shuffle(cards);
+            }
+
+            public Card pop () {
+                return cards.pop();
+            }
+
+            public Card peek () {
+                return cards.peek();
+            }
+
+            public boolean isEmpty () {
+                return cards.empty();
+            }
+
+
+    }

src/main/java/io/zipcoder/casino/Dice.java

@@ -0,0 +1,18 @@
+package io.zipcoder.casino;
+
+public class Dice {
+    private int diceRolled = 0;
+
+    public Dice(int numOfDice){
+        diceRolled = numOfDice;
+    }
+
+    public int tossAndSum(){
+        int toss = 0;
+        for (int i = 0; i < diceRolled; i++) {
+            toss += (int) (Math.ceil(Math.random() * 6));
+        }
+        return toss;
+    }
+
+}

src/main/java/io/zipcoder/casino/DiceGame.java

@@ -0,0 +1,15 @@
+package io.zipcoder.casino;
+
+public class DiceGame implements Game {
+    private Dice dice;
+
+    public boolean playing() {
+        return false;
+    }
+
+    public void playRound() {}
+
+    public boolean gameOver() {
+        return false;
+    }
+}

src/main/java/io/zipcoder/casino/Gamble.java

@@ -0,0 +1,4 @@
+package io.zipcoder.casino;
+
+public interface Gamble {
+}

src/main/java/io/zipcoder/casino/Gambler.java

@@ -0,0 +1,6 @@
+package io.zipcoder.casino;
+
+public interface Gambler {
+    void gamble(double wagerAmount);
+
+}

src/main/java/io/zipcoder/casino/Game.java

@@ -0,0 +1,8 @@
+package io.zipcoder.casino;
+
+public interface Game {
+
+    boolean gameOver();
+
+    void playRound();
+}

src/main/java/io/zipcoder/casino/GoFish.java

@@ -0,0 +1,197 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class GoFish extends CardGame {
+
+    private int playerScore;
+    private int aiScore;
+    private GoFishPlayer player;
+    private GoFishPlayer ai;
+
+    public static void main(String[] args) {
+        Player William = new Player("William", 18, 0.0);
+        GoFish goFish = new GoFish(William);
+
+        goFish.playRound();
+    }
+
+    public int getPlayerScore() {
+        return playerScore;
+    }
+
+    public void setPlayerScore(int playerScore) {
+        this.playerScore = playerScore;
+    }
+
+    public int getAiScore() {
+        return aiScore;
+    }
+
+    public void setAiScore(int aiScore) {
+        this.aiScore = aiScore;
+    }
+
+    public GoFish(Player player) {
+        Player ai = new Player("ai", 0, 0.0);
+
+        this.player = new GoFishPlayer(player);
+        this.ai = new GoFishPlayer(ai);
+    }
+
+    public Dealer dealer = new Dealer();
+
+    public boolean running(){
+        return true;
+    }
+
+    public void playRound() {
+        System.out.println("Welcome to Baby Fish.");
+        dealer.deal(7, player);
+        dealer.deal(7, ai);
+        while (dealer.getNewDeck().getDeckSize() != 0 && player.getPlayerHand().size() != 0 && ai.getPlayerHand().size() != 0) {
+            usersTurn();
+            aiTurn();
+        }
+        findWinner();
+    }
+
+    public void usersTurn(){
+        checkUserHandSize();
+        System.out.println(player.getPlayerHand().toString());
+        System.out.println("What are you asking for?");
+        Card userGuess = userGuess(tempInput());
+        playerGoFish(userGuess);
+        playerGotFish(userGuess);
+        checkUserHandSize();
+    }
+
+    public void aiTurn(){
+        checkAiHandSize();
+        Card aiGuess = aiGuess();
+        System.out.println("The AI asks for a " + aiGuess);
+        aiGoFish(aiGuess);
+        aiGotFish(aiGuess);
+        checkAiHandSize();
+    }
+
+    public void playerMatches(){
+        if(player.getPlayerHand().numberOfDuplicates() > 0) {
+            int num = player.getPlayerHand().numberOfDuplicates();
+            player.getPlayerHand().removeDuplicates();
+            playerScore = playerScore + num;
+        }
+    }
+
+    public void aiMatches(){
+        if(ai.getPlayerHand().numberOfDuplicates() > 0) {
+            int num = ai.getPlayerHand().numberOfDuplicates();
+            ai.getPlayerHand().removeDuplicates();
+            aiScore = aiScore + num;
+        }
+        //checks if hand is 0 & if deck is < 7
+    }
+
+    public Card userGuess(Card guess){
+        ArrayList<Card> playerHand = player.getPlayerHand().getHand();
+        if(playerHand.contains(guess)){
+            return guess;
+        }
+        return null;
+    }
+
+    public Card aiGuess(){
+        ArrayList<Card> aiHandHand= ai.getPlayerHand().getHand();
+        Card aiGuess = aiHandHand.get(0);
+        return aiGuess;
+    }
+
+    public void playerGoFish(Card guess){
+        if(!ai.getPlayerHand().contains(guess)){
+            System.out.println("The AI doesnt have a " + guess);
+            player.getPlayerHand().add(dealer.getNewDeck().pop());
+            playerMatches();
+            System.out.println("The player went fishing.");
+        }
+    }
+
+    public void playerGotFish(Card guess){
+        if(ai.getPlayerHand().contains(guess)){
+            ArrayList<Card> aiHandHand= ai.getPlayerHand().getHand();
+            aiHandHand.remove(guess);
+            aiMatches();
+            System.out.println("The player has gained a point.");
+        }
+    }
+
+    public void aiGoFish(Card guess){
+        if(!player.getPlayerHand().contains(guess)){
+            if(dealer.getNewDeck().getDeckSize() >= 1){
+                ai.getPlayerHand().add(dealer.getNewDeck().pop());
+            }
+            aiMatches();
+            System.out.println("The AI has gone fishing.");
+        }
+    }
+
+    public void aiGotFish(Card guess){
+        if(player.getPlayerHand().contains(guess)){
+            ArrayList<Card> playerHandHand= player.getPlayerHand().getHand();
+            playerHandHand.remove(guess);
+            aiMatches();
+            System.out.println("The AI has gained a point.");
+        }
+    }
+
+    public void checkUserHandSize(){
+        if(player.getPlayerHand().size() == 0 && dealer.getNewDeck().getDeckSize() > 7){
+            System.out.println("Your hand was empty here's some cards.");
+            dealer.deal(7, player);
+        } else if(player.getPlayerHand().size() == 0){
+            System.out.println("Your hand was empty here's some cards.");
+            dealer.deal(dealer.getNewDeck().getDeckSize(), player);
+        }
+    }
+
+    public void checkAiHandSize(){
+        if(ai.getPlayerHand().size() == 0 && dealer.getNewDeck().getDeckSize() > 7){
+            dealer.deal(7, ai);
+        } else if(ai.getPlayerHand().size() == 0){
+            dealer.deal(7, ai);
+        }
+    }
+
+    public boolean getResult(){
+        if(playerScore < aiScore){
+            System.out.println("AI won this time.");
+            return false;
+        }else {
+            System.out.println("You won!!!");
+            return true;
+        }
+    }
+
+    public void findWinner(){
+        if(playerScore < aiScore){
+            System.out.println("AI won this time.");
+//            return ai;
+        }else {
+            System.out.println("You won!!!");
+//            return player;
+        }
+    }
+
+    public Card tempInput(){
+        //TAKES A STRING INPUT CONVERTS IT TO RANK
+        Scanner scanner = new Scanner(System.in);
+        String input = scanner.nextLine().toLowerCase();
+        for(Card card : ai.getPlayerHand().getHand()){
+            if(input.equals(card.getRank().getStringValue())){
+                return card;
+            }
+        }
+        return null;
+    }
+
+}

src/main/java/io/zipcoder/casino/GoFishPlayer.java

@@ -0,0 +1,18 @@
+package io.zipcoder.casino;
+
+public class GoFishPlayer {
+    private Player player;
+    private Hand playerHand = new Hand();
+
+    public GoFishPlayer(Player player) {
+        this.player = player;
+    }
+
+    public Hand getPlayerHand() {
+        return playerHand;
+    }
+
+    public void setPlayerHand(Hand playerHand) {
+        this.playerHand = playerHand;
+    }
+}

src/main/java/io/zipcoder/casino/Hand.java

@@ -0,0 +1,108 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class Hand {
+    private ArrayList<Card> playerHand = new ArrayList<Card>();
+
+    public Hand() {}
+
+    //public void add() {}
+
+    public void add(Card card){
+        playerHand.add(card);
+    }
+
+    public ArrayList<Card> getHand(){
+        return playerHand;
+    }
+
+    public int numberOfDuplicates(){
+
+
+        int countDuplicates = 0;
+        sortHand();
+        for (int i=1; i<playerHand.size(); i++) {
+            if(ifFirstCard(i))
+                {countDuplicates++;}
+            else if (twoInARow(i))
+                {countDuplicates++;}
+            else if (fourInARow(i))
+                {countDuplicates++;}
+        }
+            return countDuplicates;
+        }
+
+        public boolean ifFirstCard(int i){
+            if (i == 1 && playerHand.get(i - 1).getRank() == playerHand.get(i).getRank()) {
+
+                return true;
+            }
+            return false;
+        }
+
+        public boolean twoInARow(int i){
+        if (playerHand.get(i - 1).getRank() == playerHand.get(i).getRank()
+                    && playerHand.get(i - 2).getRank() != playerHand.get(i).getRank()) {
+        return true;}
+        return false;
+        }
+
+        public boolean fourInARow(int i){
+        if (i>3 && playerHand.get(i - 1).getRank() == playerHand.get(i).getRank()
+                && playerHand.get(i - 2).getRank() == playerHand.get(i).getRank()
+                && playerHand.get(i - 3).getRank() == playerHand.get(i).getRank()){
+            return true;
+        }
+    return false;}
+
+    public int size(){return playerHand.size();}
+
+    public boolean contains(Card card){ return playerHand.contains(card);}
+
+    public void sortHand(){
+        Collections.sort(playerHand);
+    }
+
+
+    //removes pairs of duplicates
+    public void removeDuplicates(){
+        sortHand();
+        for (int i=playerHand.size()-3; i>=0; i--) {
+            if (playerHand.get(i + 1).getRank() == playerHand.get(i).getRank()) {
+                playerHand.remove(i+1);
+                playerHand.remove(i);
+            }
+        }
+    }
+
+    //returns number of occurrences of input
+    public int getNumberOfRankOccurrences(Card card) {
+        int count =0;
+        for(int i = 0; i<playerHand.size(); i++){
+            if(playerHand.get(i).getRank() == card.getRank())
+            {count++;}
+        }
+        return count;
+    }
+
+    //Creates a string with rank and suit
+    public String toString() {
+        String  result = "";
+        for (Card card : playerHand){
+            result += card.getRank().toString() + card.getSuit().toString() + " ";
+        }
+        return result;
+    }
+
+    public int getTotal(){
+        int result = 0;
+        for(Card card : playerHand){
+            result += card.getRank().getBlackJackValue();
+        }
+        return result;
+    }
+}

src/main/java/io/zipcoder/casino/Opponent.java

@@ -0,0 +1,7 @@
+package io.zipcoder.casino;
+
+public interface Opponent {
+    void pluck();
+
+
+}

src/main/java/io/zipcoder/casino/Player.java

@@ -0,0 +1,31 @@
+package io.zipcoder.casino;
+
+public class Player {
+
+    private String name;
+    private int age;
+    private double money = 0;
+
+
+    public Player(String name, int age, double money) {
+        this.name = name;
+        this.age = age;
+        this.money = money;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public double getMoney() {
+        return money;
+    }
+
+    public void setMoney(double money) {
+        this.money += money;
+    }
+}

src/main/java/io/zipcoder/casino/Rank.java

@@ -0,0 +1,40 @@
+package io.zipcoder.casino;
+
+public enum Rank {
+    ACE(1, "ace"),
+    TWO(2, "two"),
+    THREE(3, "three"),
+    FOUR(4, "four"),
+    FIVE(5, "five"),
+    SIX(6, "six"),
+    SEVEN(7, "seven"),
+    EIGHT(8, "eight"),
+    NINE(9, "nine"),
+    TEN(10, "ten"),
+    JACK(10, "jack"),
+    QUEEN(10, "queen"),
+    KING(10, "king");
+
+    private int goFishValue;
+    private int blackJackValue;
+    private String stringValue;
+
+    Rank(int goFishValue, String stringValue) {
+        this.goFishValue = goFishValue;
+        this.blackJackValue = goFishValue;
+        this.stringValue = stringValue;
+    }
+
+
+    public int getGoFishValue() {
+        return goFishValue;
+    }
+
+    public int getBlackJackValue() {
+        return blackJackValue;
+    }
+
+    public String getStringValue() {
+        return stringValue;
+    }
+}

src/main/java/io/zipcoder/casino/Roulette.java

@@ -0,0 +1,10 @@
+package io.zipcoder.casino;
+
+public class Roulette {
+
+    private RoulettePlayer player;
+
+    public Roulette(Player player) {
+        this.player = new RoulettePlayer(player);
+    }
+}

src/main/java/io/zipcoder/casino/RoulettePlayer.java

@@ -0,0 +1,18 @@
+package io.zipcoder.casino;
+
+public class RoulettePlayer implements Gambler {
+    private Player player;
+
+    public RoulettePlayer(Player player) {
+        this.player = player;
+    }
+
+    public void gamble(double wagerAmount) {
+        if (player.getMoney() < wagerAmount) {
+            System.out.println("You don't have enough money to cover that bet");
+        } else {
+            wagerAmount = wagerAmount * -1;
+            player.setMoney(wagerAmount);
+        }
+    }
+}

src/main/java/io/zipcoder/casino/Suit.java

@@ -0,0 +1,8 @@
+package io.zipcoder.casino;
+
+public enum Suit {
+    CLUBS,
+    DIAMONDS,
+    HEARTS,
+    SPADES
+}

src/main/java/io/zipcoder/casino/SystemConsole.java

@@ -0,0 +1,17 @@
+//package io.zipcoder.casino;
+//
+//public class SystemConsole {
+//    private static final Console console = new Console(System.in, System.out);
+//
+//    private static void print(String str, Object... args) {
+//        console.print(str, args);
+//    }
+//
+//    public static String getStringInput(String str, Object... args) {
+//        return console.getStringInput(str, args);
+//    }
+//
+//    public static Double getDoubleInput(String str, Object... args) {
+//
+//    }
+//}

src/test/java/io/zipcoder/casino/BlackJackPlayerTest.java

@@ -0,0 +1,54 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BlackJackPlayerTest {
+
+    @Test
+    public void testGamble() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        BlackJackPlayer blackJackPlayer = new BlackJackPlayer(player);
+        double expectedOutput = 100 - 75;
+
+        // When
+        blackJackPlayer.gamble(75);
+        double actualOutput = 25;
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput, 0.01);
+    }
+
+    @Test
+    public void testGamble2() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        BlackJackPlayer blackJackPlayer = new BlackJackPlayer(player);
+        double expectedOutput = 100;
+
+        // When
+        blackJackPlayer.gamble(200);
+        double actualOutput = 100;
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput, 0.01);
+    }
+
+    @Test
+    public void testSetAndGetHand() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        BlackJackPlayer blackJackPlayer = new BlackJackPlayer(player);
+        Hand hand = new Hand();
+        blackJackPlayer.setPlayerHand(hand);
+        Hand expectedOutput = hand;
+
+        // When
+        Hand actualOutput = blackJackPlayer.getPlayerHand();
+
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+}

src/test/java/io/zipcoder/casino/BlackJackTest.java

@@ -0,0 +1,390 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class BlackJackTest {
+
+    Player playerTest = new Player("Joe", 23, 100);
+    BlackJack blackjack1 = new BlackJack(playerTest);
+    BlackJackPlayer player = new BlackJackPlayer(playerTest);
+    Dealer dealer1 = new Dealer();
+
+    @Test
+    public void setGetBlackJackPlayerTest(){
+        BlackJackPlayer expectedOutput = player;
+
+        blackjack1.setPlayer(player);
+        BlackJackPlayer actualOutput = blackjack1.getPlayer();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void blacjackWelcomeTest(){
+        String expectedOutput = "Welcome to BlackJack!  Please enter your bet: ";
+
+        String actualOutput = blackjack1.blackJackWelcome();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void hitOrStandTest(){
+        String expectedOutput = "Would you like to hit or stand?";
+
+        String actualOutput = blackjack1.hitOrStand();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void playerTotalsTest(){
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.QUEEN, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h12);
+        blackjack1.setPlayer(this.player);
+
+        String expectedOutput = "Your cards are QUEENCLUBS JACKDIAMONDS"+"\n"+ "Your current total is 20";
+
+        String actualOutput = blackjack1.playerTotalsOutput();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void dealerTotalsTest(){
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.QUEEN, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.dealer1.setHand(h12);
+        blackjack1.dealer1 = this.dealer1;
+
+        String expectedOutput = "The dealer's cards are QUEENCLUBS JACKDIAMONDS"+"\n"+ "The dealer's total is 20";
+
+        String actualOutput = blackjack1.dealerTotalOutput();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+
+
+    @Test
+    public void playerBlackJackorBustTest(){
+        Hand h = new Hand();
+        h.add(new Card(Rank.TWO, Suit.CLUBS));
+        h.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h);
+
+        boolean actualOutput = blackjack1.playerBlackJackorBust(h);
+
+        Assert.assertFalse(actualOutput);
+    }
+
+
+    @Test
+    public void playerBlackJackorBustTest2(){
+        Hand h1 = new Hand();
+        h1.add(new Card(Rank.TWO, Suit.CLUBS));
+        h1.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h1.add(new Card(Rank.QUEEN, Suit.SPADES));
+        this.player.setPlayerHand(h1);
+
+        boolean actualOutput = blackjack1.playerBlackJackorBust(h1);
+
+        Assert.assertTrue(actualOutput);
+    }
+
+    @Test
+    public void playerBlackJackorBustTest3(){
+        Hand h2 = new Hand();
+        h2.add(new Card(Rank.ACE, Suit.CLUBS));
+        h2.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h2.add(new Card(Rank.QUEEN, Suit.SPADES));
+        this.player.setPlayerHand(h2);
+
+        boolean actualOutput = blackjack1.playerBlackJackorBust(h2);
+
+        Assert.assertTrue(actualOutput);
+    }
+
+    @Test
+    public void dealerBlackJackorBust(){
+        Hand h3 = new Hand();
+        h3.add(new Card(Rank.ACE, Suit.CLUBS));
+        h3.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h3.add(new Card(Rank.QUEEN, Suit.SPADES));
+        this.dealer1.setHand(h3);
+
+        boolean actualOutput = blackjack1.dealerBlackJackorBust(h3);
+
+        Assert.assertTrue(actualOutput);
+
+    }
+
+    @Test
+    public void dealerBlackJackorBust1(){
+        Hand h4 = new Hand();
+        h4.add(new Card(Rank.TWO, Suit.CLUBS));
+        h4.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h4.add(new Card(Rank.QUEEN, Suit.SPADES));
+        this.dealer1.setHand(h4);
+
+        boolean actualOutput = blackjack1.dealerBlackJackorBust(h4);
+
+        Assert.assertTrue(actualOutput);
+
+    }
+
+    @Test
+    public void dealerBlackJackorBust2(){
+        Hand h5 = new Hand();
+        h5.add(new Card(Rank.TWO, Suit.CLUBS));
+        h5.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.dealer1.setHand(h5);
+
+        boolean expectedOutput = false;
+
+        boolean actualOutput = blackjack1.dealerBlackJackorBust(h5);
+
+        Assert.assertFalse(actualOutput);
+
+    }
+
+//    @Test
+//    public void playerSubRoundTestOver21(){
+//        Hand h6 = new Hand();
+//        h6.add(new Card(Rank.TWO, Suit.CLUBS));
+//        h6.add(new Card(Rank.JACK, Suit.DIAMONDS));
+//        h6.add(new Card(Rank.QUEEN, Suit.SPADES));
+//        this.player.setPlayerHand(h6);
+//        blackjack1.dealer1 = this.dealer1;
+//
+//        int expectedOutput = 22;
+//
+//        blackjack1.playerSubRound();
+//        int actualOutput = player.getPlayerHand().getTotal();
+//
+//        Assert.assertEquals(expectedOutput, actualOutput);
+//
+//    }
+//
+//    @Test
+//    public void playerSubRoundTestHit(){
+//        Hand h6 = new Hand();
+//        h6.add(new Card(Rank.TWO, Suit.CLUBS));
+//        h6.add(new Card(Rank.QUEEN, Suit.SPADES));
+//        this.player.setPlayerHand(h6);
+//        blackjack1.dealer1 = this.dealer1;
+//        //blackjack1. = this.player1;
+//
+//
+//        blackjack1.playerSubRound();
+//        int actualOutput = player.getPlayerHand().getTotal();
+//
+//        Assert.assertTrue(actualOutput > 12);
+//
+//    }
+//
+//    @Test
+//    public void playerSubRoundTestStay(){
+//        Hand h7 = new Hand();
+//        h7.add(new Card(Rank.TWO, Suit.CLUBS));
+//        h7.add(new Card(Rank.JACK, Suit.DIAMONDS));
+//        this.player.setPlayerHand(h7);
+//        blackjack1.dealer1 = this.dealer1;
+//
+//
+//        int expectedOutput = 12;
+//
+//        blackjack1.playerSubRound();
+//        int actualOutput = player.getPlayerHand().getTotal();
+//
+//        Assert.assertEquals(expectedOutput, actualOutput);
+//
+//    }
+
+    @Test
+    public void dealerSubRoundTest(){
+        Hand h8 = new Hand();
+        h8.add(new Card(Rank.TWO, Suit.CLUBS));
+        h8.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.dealer1.setHand(h8);
+        blackjack1.dealer1 = this.dealer1;
+
+
+        blackjack1.dealerSubRound();
+        int actualOutput = dealer1.getHand().getTotal();
+
+        Assert.assertTrue(actualOutput > 16);
+    }
+
+    @Test
+    public void dealerSubRoundTest2(){
+        Hand h9 = new Hand();
+        h9.add(new Card(Rank.TWO, Suit.CLUBS));
+        h9.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h9.add(new Card(Rank.QUEEN, Suit.SPADES));
+        this.dealer1.setHand(h9);
+        blackjack1.dealer1 = this.dealer1;
+
+        int expectedOutput = 22;
+
+
+        blackjack1.dealerSubRound();
+        int actualOutput = dealer1.getHand().getTotal();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void dealerSubRoundTest3(){
+        Hand h10 = new Hand();
+        h10.add(new Card(Rank.SIX, Suit.CLUBS));
+        h10.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.dealer1.setHand(h10);
+        blackjack1.dealer1 = this.dealer1;
+
+        blackjack1.dealerSubRound();
+        int actualOutput = dealer1.getHand().getTotal();
+
+        Assert.assertTrue(actualOutput > 16);
+    }
+
+    @Test
+    public void getResultTestDealerBlackJack(){
+        Hand h11 = new Hand();
+        h11.add(new Card(Rank.ACE, Suit.CLUBS));
+        h11.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h11.add(new Card(Rank.QUEEN, Suit.DIAMONDS));
+        this.dealer1.setHand(h11);
+        blackjack1.dealer1 = this.dealer1;
+
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.FIVE, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h12);
+
+
+        boolean actualOutput = blackjack1.getResult();
+
+        Assert.assertFalse(actualOutput);
+
+    }
+
+    @Test
+    public void getResultTestDealerWin(){
+        Hand h11 = new Hand();
+        h11.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        h11.add(new Card(Rank.QUEEN, Suit.DIAMONDS));
+        this.dealer1.setHand(h11);
+        blackjack1.dealer1 = this.dealer1;
+
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.FIVE, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h12);
+
+        boolean actualOutput = blackjack1.getResult();
+
+        Assert.assertFalse(actualOutput);
+
+    }
+
+    @Test
+    public void getResultTestPlayerWin(){
+        Hand h11 = new Hand();
+        h11.add(new Card(Rank.FIVE, Suit.DIAMONDS));
+        h11.add(new Card(Rank.QUEEN, Suit.DIAMONDS));
+        this.dealer1.setHand(h11);
+        blackjack1.dealer1 = this.dealer1;
+
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.QUEEN, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h12);
+        blackjack1.setPlayer(this.player);
+
+
+        System.out.println(blackjack1.getResult());
+        boolean actualOutput = blackjack1.getResult();
+
+        Assert.assertTrue(actualOutput);
+
+    }
+
+    @Test
+    public void playerWinLossWinTest(){
+        Hand h11 = new Hand();
+        h11.add(new Card(Rank.FIVE, Suit.DIAMONDS));
+        h11.add(new Card(Rank.QUEEN, Suit.DIAMONDS));
+        this.dealer1.setHand(h11);
+        blackjack1.dealer1 = this.dealer1;
+
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.QUEEN, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h12);
+        blackjack1.setPlayer(this.player);
+
+        blackjack1.getResult();
+        String expectedOutput = "The dealer's cards are FIVEDIAMONDS QUEENDIAMONDS"+"\n"+ "The dealer's total is 15"+"\n"+
+                "YOU WON!"+"\n";
+
+    }
+
+    @Test
+    public void adjustFundsWin(){
+        player.setWagerAmount(25.00);
+
+        Hand h11 = new Hand();
+        h11.add(new Card(Rank.FIVE, Suit.DIAMONDS));
+        h11.add(new Card(Rank.QUEEN, Suit.DIAMONDS));
+        this.dealer1.setHand(h11);
+        blackjack1.dealer1 = this.dealer1;
+
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.QUEEN, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.player.setPlayerHand(h12);
+        blackjack1.setPlayer(this.player);
+
+        double expectedOutput = 137.50;
+
+        blackjack1.adjustFunds();
+        double actualOutput = player.getMoney();
+
+        Assert.assertEquals(expectedOutput, actualOutput, .002);
+
+    }
+
+    @Test
+    public void adjustFundsLoss(){
+        player.setWagerAmount(25.00);
+
+        Hand h11 = new Hand();
+        h11.add(new Card(Rank.FIVE, Suit.DIAMONDS));
+        h11.add(new Card(Rank.QUEEN, Suit.DIAMONDS));
+        this.player.setPlayerHand(h11);
+        blackjack1.setPlayer(this.player);
+
+
+        Hand h12 = new Hand();
+        h12.add(new Card(Rank.QUEEN, Suit.CLUBS));
+        h12.add(new Card(Rank.JACK, Suit.DIAMONDS));
+        this.dealer1.setHand(h12);
+        blackjack1.dealer1 = this.dealer1;
+
+
+        double expectedOutput = 75.00;
+        blackjack1.adjustFunds();
+
+        double actualOutput = player.getMoney();
+
+        Assert.assertEquals(expectedOutput, actualOutput, .002);
+
+    }
+
+}

src/test/java/io/zipcoder/casino/CardTest.java

@@ -0,0 +1,48 @@
+
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CardTest {
+
+    Card card;
+
+    @Before
+    public void setup(){
+
+        card = new Card(card.getRank(), card.getSuit());
+
+        card = new Card(Rank.ACE, Suit.CLUBS);
+    }
+
+    @Test
+    public void getRankTest() {
+        Rank expected =card.getRank();
+        Rank actual = Rank.ACE;
+        Assert.assertEquals(expected, actual);
+
+    }
+
+//    @Test
+//    public void getRankTest() {
+//
+//        Enum expected = card.getRank();
+//        Enum actual = Rank.ACE;
+//
+//        Rank expected =card.getRank();
+//        Rank actual = Rank.ACE;
+//
+//        Assert.assertEquals(expected, actual);
+//    }
+
+    @Test
+    public void getSuitTest() {
+        Suit expected =card.getSuit();
+        Suit actual = Suit.CLUBS;
+        Assert.assertEquals(expected, actual);
+    }
+}

src/test/java/io/zipcoder/casino/CasinoTest.java

@@ -1,5 +1,12 @@
 package io.zipcoder.casino;
 
 
+import org.junit.Test;
+
 public class CasinoTest {
+    @Test
+    public void test(){
+        Casino casino = new Casino();
+        casino.selectGamePrompt();
+    }
 }

src/test/java/io/zipcoder/casino/ConsoleTest.java

@@ -0,0 +1,15 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+public class ConsoleTest {
+
+//    @Test
+//    public void test() {
+//        Console c = new Console(System.in, System.out);
+//        c.print("Select one of the options [%s %s %s]",
+//                "first option",
+//                "second option",
+//                "third option");
+//    }
+}

src/test/java/io/zipcoder/casino/CrapsPlayerTest.java

@@ -0,0 +1,37 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CrapsPlayerTest {
+
+    @Test
+    public void testGamble() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        CrapsPlayer crapsPlayer = new CrapsPlayer(player);
+        double expectedOutput = 100 - 50;
+
+        // When
+        crapsPlayer.gamble(50);
+        double actualOutput = 50;
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput, 0.01);
+    }
+
+    @Test
+    public void testGamble2() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        CrapsPlayer crapsPlayer = new CrapsPlayer(player);
+        double expectedOutput = 100;
+
+        // When
+        crapsPlayer.gamble(200);
+        double actualOutput = 100;
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput, 0.01);
+    }
+}

src/test/java/io/zipcoder/casino/CrapsTest.java

@@ -0,0 +1,130 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CrapsTest {
+
+    Craps craps;
+    Player player = new Player("Maggie", 27, 10000);
+    Console console = new Console();
+
+    @Before
+    public void setup(){
+       craps = new Craps(player);
+    }
+
+    @Test
+    public void instantWinTest() {
+        craps.setWager(20);
+        craps.instantWin();
+        double expected = 20;
+        double actual = craps.getBalance();
+        Assert.assertEquals(expected, actual, .1);
+    }
+
+    @Test
+    public void instantLoseTest() {
+        craps.setWager(100);
+        craps.instantLose();
+        double expected = -100;
+        double actual = craps.getBalance();
+        Assert.assertEquals(expected,actual, .1);
+    }
+
+    @Test
+    public void setPoint() {
+        craps.setPointTester(5);
+        craps.setPoint();
+        int expected = 5;
+        int actual = craps.getPoint();
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void chasePoint() {
+        craps.setRoll(5);
+
+        int expected = 5;
+        int actual = craps.chasePoint();
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void throwDice() {
+        craps.throwDice();
+        boolean correct = false;
+
+        int expected = craps.throwDice();
+        int actual = craps.throwDice();
+        if(actual >= 2 && actual <= 12){
+            correct = true;
+        }
+
+        Assert.assertTrue(correct);
+    }
+
+
+    @Test
+    public void accountBalanceTest() {
+
+        craps.setBalance(1000);
+        double expected = 1000;
+        double actual = craps.getBalance();
+
+        Assert.assertEquals(expected,actual, .01);
+    }
+
+    @Test
+    public void addWinnings() {
+        craps.setBalance(40);
+        craps.setWager(10);
+        craps.addWinnings();
+        double expected = craps.getBalance();
+        double actual =50;
+        Assert.assertEquals(expected, actual, .1);
+
+    }
+
+
+    @Test
+    public void lookForMatchPoint() {
+        craps.setPointTester(5);
+        craps.setPoint();
+
+        craps.setRoll(5);
+
+        boolean correct = false;
+
+        
+    }
+
+    @Test
+    public void subtractWinnings() {
+    }
+
+    @Test
+    public void rollDice() {
+
+
+    }
+
+    @Test
+    public void winningRoll() {
+    }
+
+    @Test
+    public void losingRoll() {
+    }
+
+
+
+
+    @Test
+    public void playRound() {
+    }
+}

src/test/java/io/zipcoder/casino/DealerTest.java

@@ -0,0 +1,56 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+import org.junit.Assert;
+
+public class DealerTest {
+    Dealer dealer1 = new Dealer();
+    Player player = new Player("Joe", 21, 100);
+    BlackJackPlayer player1 = new BlackJackPlayer(player);
+    GoFishPlayer player2 = new GoFishPlayer(player);
+
+
+    @Test
+    public void dealTest(){
+//        int expectedOutput = 0;
+//        int actualOutput = dealer1.getHand().size();
+
+        dealer1.deal(2, dealer1);
+
+        int expectedOutput = 2;
+        int actualOutput = dealer1.getHand().size();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void dealBlackJackTest(){
+        int expectedOutput = 2;
+
+        dealer1.deal(2, player1);
+        int actualOutput = player1.getPlayerHand().size();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void dealGoFishTest(){
+        int expectedOutput = 7;
+
+        dealer1.deal(7, player2);
+        int actualOutput = player2.getPlayerHand().size();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+
+    @Test
+    public void pluckTest(){
+        int expectedOutput = 1;
+
+        dealer1.pluck(player1.getPlayerHand());
+        int actualOutput = player1.getPlayerHand().size();
+
+        Assert.assertEquals(expectedOutput, actualOutput);
+
+    }
+}

src/test/java/io/zipcoder/casino/DeckTest.java

@@ -0,0 +1,75 @@
+
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class DeckTest {
+
+    private Deck deck;
+
+
+    @Before
+    public void setup(){
+        deck = new Deck();
+        deck.setCards();
+    }
+
+
+    @Test
+    public void shuffleCards() {
+        String before = deck.getCards().toString();
+        deck.shuffleCards();
+        String after = deck.getCards().toString();
+        Assert.assertNotEquals(before, after);
+    }
+
+    @Test
+    public void popTest() {
+       Card actual = deck.pop();
+       Card expected= new Card(Rank.KING, Suit.SPADES);
+       Assert.assertEquals(expected.getSuit(),actual.getSuit());
+       Assert.assertEquals(expected.getRank(), actual.getRank());
+    }
+
+    @Test
+    public void popSizeTest() {
+        int startSize = deck.getDeckSize();
+        deck.pop();
+        int actual = startSize - deck.getDeckSize();
+        int expected= 1;
+        Assert.assertEquals(expected,actual);
+
+    }
+
+
+    @Test
+    public void peek() {
+        Card actual = deck.peek();
+        Card expected= new Card(Rank.KING, Suit.SPADES);
+        Assert.assertEquals(expected.getSuit(),actual.getSuit());
+        Assert.assertEquals(expected.getRank(), actual.getRank());
+    }
+
+    @Test
+    public void peekSizeTest() {
+        int startSize = deck.getDeckSize();
+        deck.peek();
+        int actual = startSize - deck.getDeckSize();
+        int expected= 0;
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void isEmptyTest() {
+        boolean actual = deck.isEmpty();
+        Assert.assertFalse(actual);
+    }
+
+
+}
+

src/test/java/io/zipcoder/casino/GoFishPlayerTest.java

@@ -0,0 +1,25 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class GoFishPlayerTest {
+
+    private GoFishPlayer goFishPlayer;
+
+    @Test
+    public void testSetAndGetHand() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        GoFishPlayer goFishPlayer = new GoFishPlayer(player);
+        Hand hand = new Hand();
+        goFishPlayer.setPlayerHand(hand);
+        Hand expectedOutput = hand;
+
+        // When
+        Hand actualOutput = goFishPlayer.getPlayerHand();
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+}

src/test/java/io/zipcoder/casino/GoFishTest.java

@@ -0,0 +1,163 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+import sun.misc.ASCIICaseInsensitiveComparator;
+
+public class GoFishTest {
+    Player William = new Player("William", 18, 0.0);
+    GoFish goFish = new GoFish(William);
+
+    @Test
+    public void testUserTurn(){
+        //IDK HOW TO TEST
+    }
+
+    @Test
+    public void testAiTurn(){
+        //IDK HOW TO TEST
+    }
+
+    @Test
+    public void testUserMatches(){
+        //TEST SIZE
+        //MATCH ONE
+        //TEST SIZE FOR ONE LESS
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAiMatches(){
+        //TEST SIZE
+        //MATCH ONE
+        //TEST SIZE FOR ONE LESS
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testUserGuess(){
+        //SHOULD RETURN THE INPUT
+    }
+
+    @Test
+    public void testAiGuess(){
+        //CANT BE TESTED BC IT IS RANDOM
+    }
+
+    @Test
+    public void testPlayerGoFish(){
+        //GET SIZE OF HAND
+        //GO FISH
+        //GET SIZE OF HAND + GO FISH
+        //SEE IF IT IS ONE MORE
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testPlayerGotFish(){
+        //GET SIZE OF HAND
+        //GOT FISH
+        //GET SIZE OF HAND - GOT FISH
+        //SEE IF IT IS ONE LESS
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAiGoFish(){
+        //GET SIZE OF HAND
+        //GO FISH
+        //GET SIZE OF HAND + GO FISH
+        //SEE IF IT IS ONE MORE
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAiGotFish(){
+        //GET SIZE OF HAND
+        //GOT FISH
+        //GET SIZE OF HAND - GOT FISH
+        //SEE IF IT IS ONE LESS
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testCheckUserHandSize(){
+        //SET HAND SIZE TO ZERO
+        //RUN CHECKUSERHANDSIZE()
+        //GET HAND SIZE
+        //SEE IF THE HAND SIZE IS 7
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testCheckAiHandSize(){
+        //SET HAND SIZE TO ZERO
+        //RUN CHECKUSERHANDSIZE()
+        //GET HAND SIZE
+        //SEE IF THE HAND SIZE IS 7
+        int expected = 0;
+        int actual = 0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testAiWinner(){
+        //SET AI SCORE TO ONE HIGHER
+        goFish.setAiScore(1);
+
+
+        //COMPARE THE SCORES AND SEE IF IT RETURNS AI
+    }
+
+    @Test
+    public void testPlayerWinner(){
+        //SET PLAYER SCORE TO ONE HIGHER
+        goFish.setPlayerScore(1);
+
+
+        //COMPARE THE SCORES AND SEE IF IT RETURNS PLAYER
+    }
+
+    @Test
+    public void testResultsAiWinner(){
+        //SET AI SCORE TO ONE HIGHER
+        goFish.setAiScore(1);
+
+
+        //SHOULD RETURN FALSE
+        Assert.assertFalse(goFish.getResult());
+    }
+
+    @Test
+    public void testResultsPlayerWinner(){
+        //SET PLAYER SCORE TO ONE HIGHER
+        goFish.setPlayerScore(1);
+
+
+        //SHOULD RETURN TRUE
+        Assert.assertTrue(goFish.getResult());
+    }
+
+}

src/test/java/io/zipcoder/casino/HandTest.java

@@ -0,0 +1,177 @@
+
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public class HandTest {
+
+
+    Hand hand;
+    Card card1;
+    Card card2;
+    Card card3;
+    Card card4;
+    Card card5;
+    Card card11;
+    Card card12;
+    Card card13;
+    Card card14;
+
+
+    @Before
+    public void setup(){
+        hand = new Hand();
+        card1 = new Card(Rank.KING, Suit.SPADES);
+        card2 = new Card(Rank.TWO, Suit.HEARTS);
+        card3 = new Card(Rank.ACE, Suit.DIAMONDS);
+        card4 = new Card(Rank.ACE, Suit.SPADES);
+        card5 = new Card(Rank.ACE, Suit.HEARTS);
+        card11 = new Card(Rank.THREE, Suit.HEARTS);
+        card12 = new Card(Rank.THREE, Suit.SPADES);
+        card13 = new Card(Rank.THREE, Suit.CLUBS);
+        card14 = new Card(Rank.THREE, Suit.DIAMONDS);
+
+
+    }
+
+    @Test
+    public void addTest() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        int actual = hand.size();
+        int expected = 3;
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void getHandTest() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        ArrayList<Card> expected = new ArrayList<Card>(Arrays.asList(card1, card2,card3));
+        ArrayList<Card> actual = hand.getHand();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void numberOfDuplicatesTest() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        hand.add(card4);
+        hand.add(card5);
+        int expected = 1;
+        int actual = hand.numberOfDuplicates();
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void numberOfDuplicatesBigTest() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        hand.add(card4);
+        hand.add(card5);
+        hand.add(card11);
+        hand.add(card12);
+        hand.add(card13);
+        hand.add(card14);
+        int expected = 3;
+        int actual = hand.numberOfDuplicates();
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void containsTestTrue() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        boolean actual= hand.contains(card2);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void containsTestFalse() {
+        hand.add(card1);
+        hand.add(card3);
+        boolean actual= hand.contains(card2);
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void removeDuplicatesTest() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        hand.add(card4);
+        hand.removeDuplicates();
+        String expected = "TWOHEARTS KINGSPADES ";
+        String actual = hand.toString();
+        Assert.assertEquals(expected, actual);
+    }
+    @Test
+    public void removeDuplicatesBigTest() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        hand.add(card4);
+        hand.add(card5);
+        hand.add(card11);
+        hand.add(card12);
+        hand.add(card13);
+        hand.add(card14);
+        hand.removeDuplicates();
+        String expected = "ACEDIAMONDS TWOHEARTS KINGSPADES ";
+        String actual = hand.toString();
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void toStringTest() {
+        hand.add(card1);
+        hand.add(card2);
+        String actual = hand.toString();
+        String expected = "KINGSPADES TWOHEARTS ";
+
+    }
+
+    @Test
+    public void getNumberOfOccurrences() {
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        hand.add(card4);
+        int actual = hand.getNumberOfRankOccurrences(card3);
+        int expected = 2;
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
+
+    @Test
+    public void getTotalValue(){
+        hand.add(card1);
+        hand.add(card2);
+        hand.add(card3);
+        hand.add(card4);
+        hand.add(card5);
+        hand.add(card11);
+        hand.add(card12);
+        hand.add(card13);
+        hand.add(card14);
+        int actual = hand.getTotal();
+        int expected =27;
+        Assert.assertEquals(expected, actual);
+    }
+}
+

src/test/java/io/zipcoder/casino/PlayerTest.java

@@ -0,0 +1,34 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PlayerTest {
+
+    @Test
+    public void testGetName() {
+        // Given
+        Player player = new Player("Curtis", 37, 500);
+        String expectedOutput = "Curtis";
+
+        // When
+        String actualOutput = player.getName();
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput);
+
+    }
+
+    @Test
+    public void testGetAge() {
+        // Given
+        Player player = new Player("Curtis", 37, 500);
+        int expectedOutput = 37;
+
+        // When
+        int actualOutput = player.getAge();
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput);
+    }
+}

src/test/java/io/zipcoder/casino/RoulettePlayerTest.java

@@ -0,0 +1,37 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RoulettePlayerTest {
+
+    @Test
+    public void testGamble() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        RoulettePlayer roulettePlayer = new RoulettePlayer(player);
+        double expectedOutput = 100 - 25;
+
+        // When
+        roulettePlayer.gamble(25);
+        double actualOutput = 75;
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput, 0.01);
+    }
+
+    @Test
+    public void testGamble2() {
+        // Given
+        Player player = new Player("Curtis", 36, 100);
+        RoulettePlayer roulettePlayer = new RoulettePlayer(player);
+        double expectedOutput = 100;
+
+        // When
+        roulettePlayer.gamble(125);
+        double actualOutput = 100;
+
+        // Then
+        Assert.assertEquals(expectedOutput, actualOutput, 0.01);
+    }
+}