Merge

.gitignore

@@ -9,6 +9,8 @@ local.properties
 .settings/
 .loadpath
 .recommenders
+.DS_Store
+
 
 # External tool builders
 .externalToolBuilders/

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

@@ -19,9 +19,7 @@ public abstract class CardGame {
     private Deck deck = new Deck();
 
 
-    CardGame(int minBet, int maxBet, int ante){
-        this.minBet = minBet;
-        this.maxBet = maxBet;
+    CardGame(int ante){
         this.ante = ante;
     }
 
@@ -81,6 +79,10 @@ public abstract class CardGame {
         return handSize;
     }
 
+    public void setHandSize(int handSize) {
+        this.handSize = handSize;
+    }
+
     public CardPlayer getPlayersTurn() {
         return playersTurn;
     }

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

@@ -17,6 +17,10 @@ public class CardPlayer {
         return hand;
     }
 
+    public void setHand(ArrayList<Card> hand) {
+        this.hand = hand;
+    }
+
     public Player getPlayer() {
         return player;
     }

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

@@ -8,7 +8,11 @@ public class Console {
     private ArrayList<String> gameLib = new ArrayList<>();
     private Game game = null;
     private Player player;
-    private boolean running = true;
+    public boolean running = true;
+
+    private ArrayList<Player> players = new ArrayList<>();
+
+
 
     Console(){
         gameLib.add("yahtzee");
@@ -16,6 +20,7 @@ public class Console {
         gameLib.add("stud");
         gameLib.add("slot");
         gameLib.add("quit");
+
     }
 
     public void createAccount()
@@ -26,9 +31,14 @@ public class Console {
         System.out.println("How much money are you bringing to the table?");
         int balance = getIntFromUser();
 
-        player = new Player(name, balance);
+        Player player = new Player(name, balance);
+        players.add(player);
     }
 
+    /**
+     * Currently required to make Stud a 2 player game, could later refactor to declare 'player' in createAccount method and pass to PlayerArray
+     */
+
     public void chooseGame()
     {
 
@@ -41,17 +51,19 @@ public class Console {
 
             switch (command) {
 
+
                 case 2:
                     int[] warMinMax = getMinMax();
-                    Game war = new War(warMinMax[0], warMinMax[1], 10);
+                    Game war = new War(10);
                     ((War) war).addPlayers(player);
                     ((War) war).addNpc();
                     war.startGame();
                     break;
 
+
                 case 3:
                     int[] studMinMax = getMinMax();
-                    Game stud = new Stud(studMinMax[0], studMinMax[1], 10);
+                    Game stud = new Stud(10);
                     ((Stud) stud).addPlayers(player);
                     ((Stud) stud).addNpc();
                     stud.startGame();
@@ -95,6 +107,7 @@ public class Console {
         return -1;
     }
 
+
     public int[] getMinMax(){
         Printer.getBet("minimum bet");
         int min = 0;
@@ -141,22 +154,29 @@ public class Console {
         return command;
     }
 
-    public String continueAskGame(){
+    public int getStudPlayers() {
+        int numOfStudPlayers = 0;
 
-        String command = "";
-
-        System.out.println("Please choose a game to play!");
-        command = getCommand();
+        while (numOfStudPlayers <= 1) {
 
-        if(gameLib.indexOf(command) == -1)
-        {
-            while(gameLib.indexOf(command) == -1)
-            {
-                Printer.noMatchingGameName(gameLib);
-                command = getCommand();
+            System.out.println("How many players are there?");
+            try {
+                numOfStudPlayers = scanner.nextInt();
+            } catch (InputMismatchException e) {
+                System.out.println("Please enter a number");
             }
         }
-        return command;
+
+        return numOfStudPlayers;
+    }
+
+    public void addStudPlayers(Game game){
+        int numPlayers = getStudPlayers();
+
+        for(int i = 1; i < numPlayers; i ++) {
+            createAccount();
+            ((Stud) game).addPlayers(players.get(i));
+        }
     }
 
     public void getGameIndex(){

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

@@ -1,6 +1,7 @@
 package io.zipcoder.casino;
 
 public interface Gamble {
+
      void bet(int betAmount);
      void payout();
 }

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

@@ -27,4 +27,12 @@ public class Printer {
     public static void unacceptableMinBet(){
         System.out.println("Your bet must be above $0");
     }
+
+    public static void studHandsDealt(){
+        System.out.println("Each player Dealt 3 cards");
+    }
+
+    public static void showCard(Player player, Card card){
+        System.out.println(player.getName() + " shows a " + card.getName());
+    }
 }

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

@@ -2,8 +2,6 @@
 
 package io.zipcoder.casino;
 
-import com.sun.tools.example.debug.expr.ASCII_UCodeESC_CharStream;
-
 import java.util.*;
 
 public class ScoreSheet {

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

@@ -1,54 +1,277 @@
 
 package io.zipcoder.casino;
+import java.util.Scanner;
 
 public class Stud extends CardGame implements Gamble, Game {
-    public Stud(int minBet, int maxBet, int ante) {
-        super(minBet, maxBet, ante);
+    Scanner scanner = new Scanner(System.in);
+    Console console;
+    // private int roundCount = 0;
+
+    public Stud(int ante) {
+        super(ante);
+    }
+    
+    public void playCard(Player player, Card card) {
+        card.setVisibility(true);               //CARD isVISIBLE
+        Printer.showCard(player, card);         //PRINT card name to CONSOLE
     }
 
-    public void deal() {
+
+    public void fold(){
 
     }
 
-    public void determineWinner(){
+    /**
+     * Determine what player wins by looping through player array and then
+     * passing each hand to the 'handValue' method
+     */
+    public CardPlayer determineWinner(){
+    int max = 0;
+    CardPlayer winner = null;
 
+    for(int i = 0; i < getPlayers().size(); i ++){
+        CardPlayer player = getPlayers().get(i);
+        int playerHandValue = handValue(player); // 'handValue' method sets 'max' value of this hand
+        if(playerHandValue > max){
+            max = playerHandValue;
+            winner = player;
+        }
+    }
+    System.out.println("The winner is " + winner.getPlayer().getName());
+    System.out.println(winner.getPlayer().getName() + "\'s hand was: " + winner.getHand().get(0).getName() + " - " + winner.getHand().get(1).getName() + " - " + winner.getHand().get(2).getName() );
+    return winner;
     }
 
-    public void fold(){
+    /**
+     * Method will return a int value, larger value means strong hand to determine the winning player
+     * @param player
+     * @return
+     */
+    public int handValue(CardPlayer player){
+        int handValue = 0;
+        int card1 = player.getHand().get(0).getCardValue();
+        int card2 = player.getHand().get(1).getCardValue();
+        int card3 = player.getHand().get(2).getCardValue();
 
+        //Three of a Kind
+        if (card1 == card2 && card1 == card3){
+            handValue = card1 * 1000000;
+        //Two pair
+        }
+        else if (card1 == card2){
+            handValue = (card1 * 10000) + card3;
+        }
+        else if (card1 == card3){
+            handValue = (card1 * 10000) + card2;
+        }
+        else if (card2 == card3){
+            handValue = (card2 * 10000) + card1;
+        //High Card
+        } else {
+            // Card1 is Highest
+            if (card1 > card2 && card1 > card3 && card2 > card3) {
+                handValue = (card1 * 100) + (card2 * 10) + card3;
+            }
+            else if (card1 > card2 && card1 > card3 && card3 > card2) {
+                handValue = (card1 * 100) + (card3 * 10) + card2;
+            }
+            // Card2 is Highest
+            else if (card2 > card1 && card2 > card3 && card1 > card3) {
+                handValue = (card2 * 100) + (card1 * 10) + card3;
+            }
+            else if (card2 > card1 && card2 > card3 && card3 > card1) {
+                handValue = (card2 * 100) + (card3 * 10) + card1;
+            }
+            // Card3 is Highest
+            else if (card3 > card1 && card3 > card2 && card1 > card3) {
+                handValue = (card3 * 100) + (card1 * 10) + card3;
+            }
+            else if (card3 > card1 && card3 > card2 && card3 > card1) {
+                handValue = (card3 * 100) + (card3 * 10) + card1;
+            }
+            else {
+                handValue = 0;
+            }
+        }
+        return handValue;
     }
 
-    /**
-     * Below 3 Implemented from Gamble
-     * @param betAmount
+
+
+
+
+
+
+    /*
+
+        create a bet method which asks the first player how much to bet
+        loops through other plays to see how they would like to react to this.
+
+        fold, call, raise, check
+
      */
+
+
+
+
+
+
     public void bet(int betAmount) {
+        super.changeTablePot(betAmount);
+        //player.changeBalance(betAmount * -1);
+    }
+
+
+
+
 
+
+
+
+
+
+
+
+
+
+
+
+    public void payout(){
+        if(super.getWinner() != null){
+            super.getWinner().changeBalance(super.getTablePot());
+        }
+        System.out.println(getWinner().getName() + " won: " + super.getTablePot());
     }
 
-    public void payout() {
+    public void payAnte() {
+        for(int i = 0; i < super.getPlayers().size(); i ++)
+        {
+            CardPlayer player = super.getPlayers().get(i);
+            player.getPlayer().changeBalance(-super.getAnte());
+        }
+    }
 
+    public void Quit() {
+        System.out.println("Play again? Y : or any key to quit.");
+        String answer = scanner.next();
+        if (answer.equals("Y")){
+            startGame();
+        } else {
+            console = new Console();
+        }
     }
 
 
-    public void Ante(int anteAmount) {
+    public void startGame() {
+        // Deck deck = new Deck();     //CREATE deck for game
+        setHandSize(3);             //SET Hand Size for game(3)
+        payAnte();                  //PAY ante (all players)
+        deal();                     //DEALS cards/ hands to each player
+        startRound();               //METHOD called
 
     }
 
+    /**
+     * Game played in this method by calling the 'gameRound' methods
+     */
+    public void startRound() {
+        System.out.println("Welcome to Three Card Stud!");
+        //for (int i = 0; i < getHandSize() - 1; i++){    //Each player turns a card in hand to face up
+        gameRound1();
+        gameRound2();
+        //}
+        lastGameRound();
+        determineWinner();
+        // Payout();
+    }
+
 
     /**
-     * Below 3 Implemented from Game
+     * Plays through rounds that includes flipping cards face up and then betting or folding
      */
+    public void gameRound1(){
 
-    public void quit() {
+        playersPlayCard();
 
+        for (int x = 0; x < getPlayers().size(); x++) {                          //Betting round or fold
+            CardPlayer player = super.getPlayers().get(x);
+            int bet;
+            //ask player to bet and pass amount to Bet(betAmount
+            System.out.println("Enter a bet, if 0 is entered you fold");
+//TRY- CATCH OR WHILE/IF statement
+            bet = Integer.parseInt(scanner.next());
+            if (bet == 0){
+                System.out.println(player.getPlayer().getName() + " folds.");
+                //if fold, player is removed from game
+                //if only 1 player game ends
+            } else {
+                bet(bet);
+                System.out.println(player.getPlayer().getName() + " bets: " + bet);
+            }
+        }
     }
 
-    public void startGame() {
+    public void playersPlayCard(){
+        for (int j = 0; j < getPlayers().size(); j++) {
+            CardPlayer player = super.getPlayers().get(j);                       //GET a player
+            playCard(player.getPlayer(), player.getHand().get(0));      //SHOW-PRINT players first CARD
+            //roundCount++;
+        }
+    }
 
+    public void quit() {}
+
+    /**
+     * Plays through rounds that includes flipping cards face up and then betting or folding
+     */
+    public void gameRound2(){
+        for (int j = 0; j < getPlayers().size(); j++) {
+            CardPlayer player = super.getPlayers().get(j);                       //GET a player
+            playCard(player.getPlayer(), player.getHand().get(1));      //SHOW-PRINT players first CARD
+            //roundCount++;
+        }
+        for (int x = 0; x < getPlayers().size(); x++) {                          //Betting round or fold
+            CardPlayer player = super.getPlayers().get(x);
+            int bet;
+            //ask player to bet and pass amount to Bet(betAmount
+            System.out.println("Enter a bet, if 0 is entered you fold");
+//TRY- CATCH OR WHILE/IF statement
+            bet = Integer.parseInt(scanner.next());
+            if (bet == 0){
+                System.out.println(player.getPlayer().getName() + " folds.");
+                //if fold, player is removed from game
+                //if only 1 player game ends
+            } else {
+                bet(bet);
+                System.out.println(player.getPlayer().getName() + " bets: " + bet);
+            }
+        }
+    }
+
+    /**
+     * PreCondition: Betting rounds already played
+     * Plays through round that include flipping last card face up
+     * PostCondtion: tablePot is now at max value
+     * DetermineWinner() expected to be called after this method
+     */
+    public void lastGameRound(){
+        for (int j = 0; j < getPlayers().size(); j++) {
+            CardPlayer player = super.getPlayers().get(j);              //GET a player
+            playCard(player.getPlayer(), player.getHand().get(2));      //SHOW-PRINT players first CARD
+        }
     }
 
-    public void startRound() {
 
+    /**
+     * Deal each player(and dealer) 3 face down cards in turn
+     */
+    public void deal() {
+        for(int i = 0; i < getHandSize(); i ++){                        //OUTER loop - run 3 times as there are 3 cards per hand
+            for (int j = 0; j < getPlayers().size(); j++) {             //INNER loop through each player
+                Card card = super.getDeck().pullCard();                     //PULL card from deck (removed from deck)
+                CardPlayer player = super.getPlayers().get(j);              //GET a player
+                player.getHand().add(card);                                 //ADD card to player hand
+            }
+        }
     }
 }

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

@@ -14,8 +14,8 @@ public class War extends CardGame implements Gamble, Game {
     private Scanner scanner = new Scanner(System.in);
     private boolean war = false;
 
-    War(int minBet, int maxBet, int ante) {
-        super(minBet, maxBet, ante);
+    War(int ante) {
+        super(ante);
     }
 
 
@@ -97,7 +97,6 @@ public class War extends CardGame implements Gamble, Game {
                 war = true;
             }
         }
-
         if(war)
         {
             warMembers.add(winner);
@@ -152,9 +151,9 @@ public class War extends CardGame implements Gamble, Game {
 
     public void startRound() {
         while(super.getLoser() == null) {
-            System.out.println("Type play to play the top card from your pile.");
-            String input = scanner.next();
-            input = input.toLowerCase().trim();
+
+            String input = getCommand();
+
             if (input.equals("play")) {
                 //each player
                 for (CardPlayer player : super.getPlayers()) {
@@ -179,6 +178,13 @@ public class War extends CardGame implements Gamble, Game {
 
     }
 
+    public String getCommand(){
+        System.out.println("Type play to play the top card from your pile.");
+        String input = scanner.next();
+        input = input.toLowerCase().trim();
+        return input;
+    }
+
     public void deal() {
         //while there are cards in the deck
         while(super.getDeck().size() != 0){
@@ -195,6 +201,9 @@ public class War extends CardGame implements Gamble, Game {
                 super.getDeck().remove(card);
             }
         }
-        System.out.println(super.getPlayersTurn().getPlayer().getName() + " has: " + super.getPlayersTurn().getHand().size() + " cards.");
+
+        System.out.println(super.getPlayersTurn().getPlayer().getName() +
+                "has: " + super.getPlayersTurn().getHand().size() + " cards.");
+
     }
 }

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

@@ -21,13 +21,7 @@ public class Yahtzee extends DiceGame implements Game, Gamble {
         this.betAmount = bid;
     }
 
-
-    @Override
-    public void quit() {
-
-    }
-
-    public void startGame() {
+    public void createGame() {
         Dice dice1 = new Dice();
         Dice dice2 = new Dice();
         Dice dice3 = new Dice();
@@ -39,6 +33,10 @@ public class Yahtzee extends DiceGame implements Game, Gamble {
         dicePlayer.getCup()[2] = dice3;
         dicePlayer.getCup()[3] = dice4;
         dicePlayer.getCup()[4] = dice5;
+    }
+
+    public void startGame() {
+        createGame();
 
         System.out.println("How much would you like to bet on this game?");
         int betAmount = scanner.nextInt();
@@ -50,6 +48,7 @@ public class Yahtzee extends DiceGame implements Game, Gamble {
         payout();
         dicePlayer.printBalanceAtEnd();
         System.out.println();
+
     }
 
     public void startRound() {
@@ -222,4 +221,12 @@ public class Yahtzee extends DiceGame implements Game, Gamble {
         System.out.println("You won $" + payOut);
     }
 
+    @Override
+    public void quit() {
+
+    }
+
+    public DicePlayer getDicePlayer() {
+        return dicePlayer;
+    }
 }

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

@@ -279,4 +279,383 @@ public class ScoreSheetTest {
 
     }
 
+    @Test
+    public void testSetRowCHANCE() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+        int expected = dice1.getValue() + dice2.getValue() + dice3.getValue() + dice4.getValue() + dice5.getValue();
+
+        //When
+
+        scoreSheet.setRow(ScoreSheet.ROW.CHANCE, cup);
+        int actual = scoreSheet.getScore(ScoreSheet.ROW.CHANCE);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSetRowACES() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.ACES, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.ACES) != null));
+
+    }
+
+    @Test
+    public void testSetRowTWOS() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.TWOS, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.TWOS) != null));
+
+    }
+
+    @Test
+    public void testSetRowTHREES() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.THREES, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.THREES) != null));
+
+    }
+
+    @Test
+    public void testSetRowFOURS() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.FOURS, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.FOURS) != null));
+
+    }
+
+    @Test
+    public void testSetRowFIVES() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.FIVES, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.FIVES) != null));
+
+    }
+
+    @Test
+    public void testSetRowSIXES() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.SIXES, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.SIXES) != null));
+
+    }
+
+    @Test
+    public void testSetRowThreeOfAKind() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.THREEOFAKIND, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.THREEOFAKIND) != null));
+
+    }
+
+    @Test
+    public void testSetRowFourOfAKind() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.FOUROFAKIND, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.FOUROFAKIND) != null));
+
+    }
+
+    @Test
+    public void testSetRowFullHouse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.FULLHOUSE, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.FULLHOUSE) != null));
+
+    }
+
+    @Test
+    public void testSetRowSmallStraight() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.SMALLSTRAIGHT, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.SMALLSTRAIGHT) != null));
+
+    }
+
+    @Test
+    public void testSetRowLargeStraight() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.LARGESTRAIGHT, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.LARGESTRAIGHT) != null));
+
+    }
+
+    @Test
+    public void testSetRowYahtzee() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+        Dice[] cup = new Dice[5];
+        cup[0] = dice1;
+        cup[1] = dice2;
+        cup[2] = dice3;
+        cup[3] = dice4;
+        cup[4] = dice5;
+        for (Dice d : cup) {
+            d.roll();
+        }
+
+        //When
+        scoreSheet.setRow(ScoreSheet.ROW.YAHTZEE, cup);
+
+
+        //Then
+        Assert.assertTrue((scoreSheet.getScore(ScoreSheet.ROW.YAHTZEE) != null));
+
+    }
+
+    @Test
+    public void testGetSize() {
+        //Given
+        int expected = 13;
+
+        //When
+        int actual = ScoreSheet.getSize();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
 }

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

@@ -0,0 +1,12 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+public class WarTest {
+
+    @Test
+    public void warTest01(){
+
+    }
+
+}

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

@@ -0,0 +1,51 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class YahtzeeTest {
+
+    Player player = new Player("Dan", 1000);
+    Yahtzee yahtzee = new Yahtzee(player);
+
+    @Test
+    public void testBet() {
+        //When
+        yahtzee.bet(400);
+        int expected = 600;
+        int actual = player.getCurrentBalance();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void testSetBidGetBid() {
+        //When
+        yahtzee.setBid(400);
+        int expected = 400;
+        int actual = yahtzee.getBid();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void testCreateGame() {
+        //When
+        yahtzee.createGame();
+        int expected = 5;
+        int actual = yahtzee.getDicePlayer().getCup().length;
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+
+}