merge

pom.xml

@@ -13,8 +13,8 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
-                    <source>7</source>
-                    <target>7</target>
+                    <source>8</source>
+                    <target>8</target>
                 </configuration>
             </plugin>
         </plugins>

src/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptSettings">
+    <option name="languageLevel" value="ES6" />
+  </component>
+</project>

src/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/src.iml" filepath="$PROJECT_DIR$/.idea/src.iml" />
+    </modules>
+  </component>
+</project>

src/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

src/.idea/workspace.xml

@@ -0,0 +1,236 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="74cab72c-e027-4e61-ac26-2617cf8ce683" name="Default Changelist" comment="">
+      <change afterPath="$PROJECT_DIR$/.idea/misc.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/modules.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/vcs.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/test/java/io/zipcoder/casino/SlotTest.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Casino.java" beforeDir="false" afterPath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Casino.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Game.java" beforeDir="false" afterPath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Game.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Printer.java" beforeDir="false" afterPath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Printer.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/main/java/io/zipcoder/casino/SlotMachine.java" beforeDir="false" afterPath="$PROJECT_DIR$/main/java/io/zipcoder/casino/SlotMachine.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Yahtzee.java" beforeDir="false" afterPath="$PROJECT_DIR$/main/java/io/zipcoder/casino/Yahtzee.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/test/java/io/zipcoder/casino/CardTest.java" beforeDir="false" afterPath="$PROJECT_DIR$/test/java/io/zipcoder/casino/CardTest.java" afterDir="false" />
+    </list>
+    <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FUSProjectUsageTrigger">
+    <session id="729355978">
+      <usages-collector id="statistics.lifecycle.project">
+        <counts>
+          <entry key="project.closed" value="1" />
+          <entry key="project.open.time.1" value="1" />
+          <entry key="project.opened" value="1" />
+        </counts>
+      </usages-collector>
+      <usages-collector id="statistics.file.extensions.open">
+        <counts>
+          <entry key="java" value="1" />
+        </counts>
+      </usages-collector>
+      <usages-collector id="statistics.file.types.open">
+        <counts>
+          <entry key="JAVA" value="1" />
+        </counts>
+      </usages-collector>
+    </session>
+  </component>
+  <component name="FileEditorManager">
+    <leaf>
+      <file pinned="false" current-in-tab="true">
+        <entry file="file://$PROJECT_DIR$/test/java/io/zipcoder/casino/CardTest.java">
+          <provider selected="true" editor-type-id="text-editor">
+            <state relative-caret-position="60">
+              <caret line="4" column="30" lean-forward="true" selection-start-line="4" selection-start-column="30" selection-end-line="4" selection-end-column="30" />
+              <folding>
+                <element signature="imports" expanded="true" />
+              </folding>
+            </state>
+          </provider>
+        </entry>
+      </file>
+    </leaf>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="JsBuildToolGruntFileManager" detection-done="true" sorting="DEFINITION_ORDER" />
+  <component name="JsBuildToolPackageJson" detection-done="true" sorting="DEFINITION_ORDER" />
+  <component name="JsGulpfileManager">
+    <detection-done>true</detection-done>
+    <sorting>DEFINITION_ORDER</sorting>
+  </component>
+  <component name="ProjectFrameBounds" extendedState="6" fullScreen="true">
+    <option name="y" value="23" />
+    <option name="width" value="1440" />
+    <option name="height" value="817" />
+  </component>
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
+  <component name="ProjectView">
+    <navigator proportions="" version="1">
+      <foldersAlwaysOnTop value="true" />
+    </navigator>
+    <panes>
+      <pane id="ProjectPane">
+        <subPane>
+          <expand>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+              <item name="main" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+              <item name="main" type="462c0819:PsiDirectoryNode" />
+              <item name="java" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+              <item name="main" type="462c0819:PsiDirectoryNode" />
+              <item name="java" type="462c0819:PsiDirectoryNode" />
+              <item name="casino" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+              <item name="test" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+              <item name="test" type="462c0819:PsiDirectoryNode" />
+              <item name="java" type="462c0819:PsiDirectoryNode" />
+            </path>
+            <path>
+              <item name="src" type="b2602c69:ProjectViewProjectNode" />
+              <item name="src" type="462c0819:PsiDirectoryNode" />
+              <item name="test" type="462c0819:PsiDirectoryNode" />
+              <item name="java" type="462c0819:PsiDirectoryNode" />
+              <item name="casino" type="462c0819:PsiDirectoryNode" />
+            </path>
+          </expand>
+          <select />
+        </subPane>
+      </pane>
+      <pane id="PackagesPane" />
+      <pane id="Scope" />
+    </panes>
+  </component>
+  <component name="PropertiesComponent">
+    <property name="WebServerToolWindowFactoryState" value="false" />
+    <property name="aspect.path.notification.shown" value="true" />
+    <property name="com.android.tools.idea.instantapp.provision.ProvisionBeforeRunTaskProvider.myTimeStamp" value="1541771782363" />
+    <property name="last_opened_file_path" value="$PROJECT_DIR$" />
+    <property name="nodejs_interpreter_path.stuck_in_default_project" value="undefined stuck path" />
+    <property name="nodejs_npm_path_reset_for_default_project" value="true" />
+    <property name="settings.editor.selected.configurable" value="preferences.general" />
+  </component>
+  <component name="RunDashboard">
+    <option name="ruleStates">
+      <list>
+        <RuleState>
+          <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
+        </RuleState>
+        <RuleState>
+          <option name="name" value="StatusDashboardGroupingRule" />
+        </RuleState>
+      </list>
+    </option>
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="74cab72c-e027-4e61-ac26-2617cf8ce683" name="Default Changelist" comment="" />
+      <created>1541771578720</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1541771578720</updated>
+      <workItem from="1541771580200" duration="204000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TimeTrackingManager">
+    <option name="totallyTimeSpent" value="204000" />
+  </component>
+  <component name="ToolWindowManager">
+    <frame x="0" y="0" width="1440" height="900" extended-state="6" />
+    <editor active="true" />
+    <layout>
+      <window_info id="Image Layers" />
+      <window_info id="Designer" />
+      <window_info id="UI Designer" />
+      <window_info id="Capture Tool" />
+      <window_info id="Favorites" side_tool="true" />
+      <window_info active="true" content_ui="combo" id="Project" order="0" visible="true" weight="0.24964234" />
+      <window_info id="Structure" order="1" side_tool="true" weight="0.25" />
+      <window_info anchor="bottom" id="Database Changes" show_stripe_button="false" />
+      <window_info anchor="bottom" id="Version Control" show_stripe_button="false" />
+      <window_info anchor="bottom" id="Terminal" />
+      <window_info anchor="bottom" id="Event Log" side_tool="true" />
+      <window_info anchor="bottom" id="Message" order="0" />
+      <window_info anchor="bottom" id="Find" order="1" />
+      <window_info anchor="bottom" id="Run" order="2" />
+      <window_info anchor="bottom" id="Debug" order="3" weight="0.4" />
+      <window_info anchor="bottom" id="Cvs" order="4" weight="0.25" />
+      <window_info anchor="bottom" id="Inspection" order="5" weight="0.4" />
+      <window_info anchor="bottom" id="TODO" order="6" />
+      <window_info anchor="right" id="Palette" />
+      <window_info anchor="right" id="Theme Preview" />
+      <window_info anchor="right" id="Capture Analysis" />
+      <window_info anchor="right" id="Palette&#9;" />
+      <window_info anchor="right" id="Database" />
+      <window_info anchor="right" id="Maven Projects" />
+      <window_info anchor="right" id="Commander" internal_type="SLIDING" order="0" type="SLIDING" weight="0.4" />
+      <window_info anchor="right" id="Ant Build" order="1" weight="0.25" />
+      <window_info anchor="right" content_ui="combo" id="Hierarchy" order="2" weight="0.25" />
+    </layout>
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="1" />
+  </component>
+  <component name="VcsContentAnnotationSettings">
+    <option name="myLimit" value="2678400000" />
+  </component>
+  <component name="editorHistoryManager">
+    <entry file="file://$PROJECT_DIR$/test/java/io/zipcoder/casino/CardTest.java">
+      <provider selected="true" editor-type-id="text-editor">
+        <state relative-caret-position="60">
+          <caret line="4" column="30" lean-forward="true" selection-start-line="4" selection-start-column="30" selection-end-line="4" selection-end-column="30" />
+          <folding>
+            <element signature="imports" expanded="true" />
+          </folding>
+        </state>
+      </provider>
+    </entry>
+  </component>
+  <component name="masterDetails">
+    <states>
+      <state key="ProjectJDKs.UI">
+        <settings>
+          <last-edited>1.8</last-edited>
+          <splitter-proportions>
+            <option name="proportions">
+              <list>
+                <option value="0.2" />
+              </list>
+            </option>
+          </splitter-proportions>
+        </settings>
+      </state>
+    </states>
+  </component>
+</project>

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

@@ -44,9 +44,9 @@ public class Card {
         this.suit = suit;
     }
 
-    public CardValue getCardValue()
+    public int getCardValue()
     {
-        return cardValue;
+        return cardValue.getCardValue();
     }
 
     public void setCardValue(CardValue cardValue)

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

@@ -2,43 +2,38 @@ package io.zipcoder.casino;
 
 import java.lang.reflect.Array;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 
 public abstract class CardGame {
+
     private int tablePot;
     private int minBet;
     private int maxBet;
     private int handSize;
     private int ante;
-    private Player playersTurn;
-    private ArrayList<CardPlayer> players;
-    private ArrayList<Card> deck = new ArrayList<>();
+    private CardPlayer playersTurn;
+    private Player winner = null;
+    private Player loser = null;
+    private ArrayList<CardPlayer> players = new ArrayList<CardPlayer>();
+    private Deck deck = new Deck();
 
 
-    CardGame(int minBet, int maxBet, int ante){
-        this.minBet = minBet;
-        this.maxBet = maxBet;
+    CardGame(int ante){
         this.ante = ante;
     }
 
     //use hand size to determine dealing
-    public abstract void Deal();
+    // public abstract void deal();
+    // public abstract void deal(ArrayList<CardPlayer> players); // NEEDED FOR STUD
 
-    public void Shuffle(){
+    public void shuffle(){
 
         //shuffle the card stack
 
     }
 
-    public void faceDown(Card card){
-        card.setVisibility(false);
-    }
-
-    public void faceUp(Card card){
-        card.setVisibility(true);
-    }
-
-    public ArrayList<Card> getDeck() {
+    public Deck getDeck() {
         return deck;
     }
 
@@ -46,11 +41,84 @@ public abstract class CardGame {
         return players;
     }
 
-    public void setDeck(ArrayList<Card> deck) {
-        this.deck = deck;
+    public void addPlayers(Player... players){
+        for(Player player : players){
+            CardPlayer cardPlayer = new CardPlayer(player);
+            this.players.add(cardPlayer);
+        }
     }
 
+
     public int getAnte(){
         return ante;
     }
+
+    public int getTablePot() {
+        return tablePot;
+    }
+
+    public void changeTablePot(int amountPlusMinus) {
+        tablePot += amountPlusMinus;
+    }
+
+    public Player getWinner() {
+        return winner;
+    }
+
+    public int getHandSize() {
+        return handSize;
+    }
+
+    public void setHandSize(int handSize) {
+        this.handSize = handSize;
+    }
+
+    public CardPlayer getPlayersTurn() {
+        return playersTurn;
+    }
+
+    public void setPlayersTurn(CardPlayer playersTurn) {
+        this.playersTurn = playersTurn;
+    }
+
+    public void addNpc(){
+        addPlayers(new NPC("Opponant", getAnte()));
+    }
+
+    public void chooseStatingPlayer(){
+        //loop through the players
+        for(int i = 0; i < getPlayers().size(); i ++){
+            //if one is not an NPC
+            if(!(getPlayers().get(i).getPlayer() instanceof NPC)){
+                //set this player to have the current turn
+                setPlayersTurn(getPlayers().get(i));
+                break;
+            }
+        }
+    }
+
+    public void chooseNextTurn(){
+        if(playersTurn != null)
+        {
+            //if it is the end of the turn circle
+            if((players.indexOf(playersTurn) + 1) == players.size()){
+                //start again at the starting player
+                playersTurn = players.get(0);
+                //System.out.println("it is now " + playersTurn.getPlayer().getName() + "'s turn");
+
+            //if it is not the end of the turn circle
+            } else {
+                playersTurn = players.get(players.indexOf(playersTurn) + 1);
+                //System.out.println("it is now " + playersTurn.getPlayer().getName() + "'s turn");
+            }
+        }
+    }
+
+    public Player getLoser() {
+        return loser;
+    }
+
+    public void setLoser(Player loser) {
+        this.loser = loser;
+    }
 }

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

@@ -6,12 +6,52 @@ public class CardPlayer {
     private Player player;
     private ArrayList<Card> hand = new ArrayList<>();
     private ArrayList<Card> discard = new ArrayList<>();
+    private Card playedCard = null;
+
+
+    public CardPlayer(Player player){
+        this.player = player;
+    }
 
     public ArrayList<Card> getHand(){
         return hand;
     }
 
+    public void setHand(ArrayList<Card> hand) {
+        this.hand = hand;
+    }
+
     public Player getPlayer() {
         return player;
     }
+
+    public Card playCard(){
+
+        if(hand.size() > 0){
+            Card card = hand.get(hand.size()-1);
+            hand.remove(hand.size()-1);
+
+            return card;
+        }
+
+        return null;
+    }
+
+    public Card getPlayedCard() {
+        return playedCard;
+    }
+
+    public void setPlayedCard(Card playedCard) {
+        this.playedCard = playedCard;
+    }
+
+    public void addDiscard(ArrayList<Card> cards) {
+        this.discard.addAll(cards);
+    }
+    public ArrayList<Card> getDiscard() {
+        return discard;
+    }
+    public void setDiscard(ArrayList<Card> discard) {
+        this.discard = discard;
+    }
 }

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

@@ -1,6 +1,144 @@
 package io.zipcoder.casino;
 
 
+import java.util.ArrayList;
+import java.util.InputMismatchException;
+
 public class Casino {
+    public boolean running = true;
+    private ArrayList<String> gameLib = new ArrayList<>();
+    private ArrayList<Player> players = new ArrayList<>();
+    private Console console = new Console();
+    private Game game = null;
+    private Player player;
+
+    public Casino(){
+        gameLib.add("yahtzee");
+        gameLib.add("war");
+        gameLib.add("stud");
+        gameLib.add("slot");
+        gameLib.add("quit");
+    }
+
+    public static void main(String[] args){
+        Casino casino = new Casino();
+        //get a player
+        casino.setPlayer(casino.getConsole().createAccount());
+        //player picks game
+        casino.chooseGame();
+    }
+
+    public String getGameListing(){
+        int i=1;
+        String list = "";
+        for (String s: gameLib) {
+            list += "Enter "+i+ " for : " + s + "\n";
+            i++;
+        }
+        return list;
+    }
+
+    public void chooseGame()
+    {
+        while(running) {
+
+            Printer.printMessage("Please choose a game to play!");
+            Printer.printMessage(getGameListing());
+
+            int command = console.getIntFromUser("Please choose a game to play by entering the number next to the game.");
+
+            switch (command) {
+
+                case 2:
+                    Game war = new War(10);
+                    ((War) war).addPlayers(player);
+                    ((War) war).addNpc();
+                    game = war;
+                    war.startGame();
+                    break;
+
+                case 3:
+                    Game stud = new Stud(10);
+                    ((Stud) stud).addPlayers(player);
+                    ((Stud) stud).addNpc();
+                    game = stud;
+                    stud.startGame();
+                    break;
+
+                case 4:
+                    int slotBet1= console.getIntFromUser("Enter the amount you want to bet on Slot");
+                    if ((slotBet1 < 0) || (slotBet1 >100) )
+                    {
+                        Printer.printMessage("Invalid bet amount entered, min bet for slot is $1 and max $100 ");
+                        break;
+                    }
+                    Game slot= new SlotMachine(slotBet1);
+                    game = slot;
+                    slot.startGame();
+                    ((SlotMachine) slot).slotResult();
+                    ((SlotMachine) slot).payout();
+                    break;
+
+                case 1:
+                    Game yahtzee = new Yahtzee(player);
+                    game = yahtzee;
+                    ((Yahtzee) yahtzee).startGame();
+                    int betAmount = console.getIntFromUser("How much would you like to bet on this game?");
+                    ((Yahtzee) yahtzee).setBid(betAmount);
+                    ((Yahtzee) yahtzee).bet(betAmount);
+                    yahtzee.startRound();
+                    Printer.printMessage("You scored " + ((Yahtzee) yahtzee).getDicePlayer().getScoreSheet().getTotalScore() + " points.");
+                    ((Yahtzee) yahtzee).payout();
+                    Printer.printMessage(((Yahtzee) yahtzee).getDicePlayer().balanceAtEnd() + "\n");
+                    break;
+
+                case 5:
+                    running = false;
+                    Printer.printMessage("Thanks for the money chump!");
+                    break;
+
+                default:
+                    Printer.noMatchingGameName(gameLib);
+                    break;
+            }
+        }
+    }
+
+    public Console getConsole() {
+        return console;
+    }
+
+    public int getStudPlayers() {
+        int numOfStudPlayers = 0;
+
+        while (numOfStudPlayers <= 1) {
+
+            numOfStudPlayers = console.getIntFromUser("How many players are there?");
+        }
+        return numOfStudPlayers;
+    }
+
+    public void addStudPlayers(Game game){
+        int numPlayers = getStudPlayers();
+
+        for(int i = 1; i < numPlayers; i ++) {
+            console.createAccount();
+            ((Stud) game).addPlayers(players.get(i));
+        }
+    }
+
+    public void setPlayer(Player player) {
+        this.player = player;
+    }
+
+    public ArrayList<String> getGameLib() {
+        return gameLib;
+    }
 
+    public Game getGame() {
+        return game;
+    }
+    public boolean isRunning() {
+        return running;
+    }
 }

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

@@ -1,27 +1,54 @@
 package io.zipcoder.casino;
+import java.util.ArrayList;
+import java.util.InputMismatchException;
+import java.util.Scanner;
 
 public class Console {
-    private Game[] games;
-    private Player player;
 
-    Console(){}
+    private Scanner scanner = new Scanner(System.in);
+
+    Console(){
 
-    public void createAccount()
-    {
-        /*
-            ask the player for their name.
-            ask the player for their starting balance
-            create the player.
-         */
     }
 
-    public void chooseGame(String gameName)
+    public Player createAccount()
     {
-        /*
-            ask the user for min max bet at the table
-            ask the user which game they would like to play
-            create a new game with min and max set based
-            on user input
-         */
+        String name = getLineFromUser("Hello, what is your name?");
+        int balance = getIntFromUser("How much money are you bringing to the table?");
+        return new Player(name, balance);
+    }
+
+    public int getIntFromUser(String message){
+        Printer.printMessage(message);
+        try{
+            int num = scanner.nextInt();
+            return num;
+        }catch(InputMismatchException err){
+            Printer.printMessage("Please enter a number.");
+            scanner.next();
+        }
+        return -1;
+    }
+
+    public String getCMDFromUser(String msg){
+        Printer.printMessage(msg);
+        String input = scanner.next();
+        input.toLowerCase().trim();
+        return input;
+    }
+
+    public String getLineFromUser(String msg){
+        Printer.printMessage(msg);
+        String input = scanner.nextLine();
+        input.toLowerCase().trim();
+        return input;
+    }
+
+    public void setScanner(Scanner scanner) {
+        this.scanner = scanner;
+    }
+
+    public Scanner getScanner() {
+        return scanner;
     }
 }

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

@@ -3,8 +3,7 @@ package io.zipcoder.casino;
 import java.util.ArrayList;
 import java.util.Collections;
 
-public class Deck {
-    ArrayList<Card> deck;
+public class Deck extends ArrayList<Card>{
 
     /**
      * Deck constructor will create an array of all 52 @Card 's
@@ -15,17 +14,16 @@ public class Deck {
     }
 
     public void createDeck(){
-        this.deck = new ArrayList<>();
 
         for (int i = 0; i < 13; i++){
             Card.CardValue value = Card.CardValue.values()[i];
 
             for (int j = 0; j < 4; j++){
                 Card card = new Card(value, Card.Suit.values()[j]);
-                this.deck.add(card);
+                this.add(card);
             }
         }
-        Collections.shuffle(deck);
+        Collections.shuffle(this);
     }
 
     /**
@@ -35,7 +33,7 @@ public class Deck {
      * @return
      */
     public Card getCard(int index){
-        return this.deck.get(index);
+        return this.get(index);
     }
 
     /**
@@ -43,16 +41,7 @@ public class Deck {
      * @return
      */
     public Card pullCard(){
-        Card tempCard = this.deck.remove(0);
+        Card tempCard = this.remove(0);
         return tempCard;
     }
-
-    /**
-     * Used to retrieve the array with instantiated deck shuffled
-     * Will RETURN DECK
-     * @return
-     */
-    public ArrayList<Card> getDeck() {
-        return this.deck;
-    }
 }

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

@@ -2,7 +2,6 @@ package io.zipcoder.casino;
 
 public class Dice {
 
-
     private int value;
 
     public void roll(){

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

@@ -5,4 +5,6 @@ public abstract class DiceGame {
     private int numberOfRolls;
     private Player[] players;
     private Player playersTurn;
+
+
 }

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

@@ -19,9 +19,23 @@ public class DicePlayer {
         return cup;
     }
 
-    public void printCup() {
+    public String cupToString() {
+
+        String cupString = "";
+
         for(Dice d : cup) {
-            System.out.print(d.getValue() + " ");
+            cupString += (d.getValue() + " ");
         }
+        return cupString;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public String balanceAtEnd() {
+        return "Your total balance is now: $" + getPlayer().getCurrentBalance();
     }
 }
+
+

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

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

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

@@ -1,7 +1,6 @@
 package io.zipcoder.casino;
 
 public interface Game {
-     void Quit();
-     void StartGame();
-     void StartRound();
+     void startGame();
+     void startRound();
 }

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

@@ -0,0 +1,8 @@
+package io.zipcoder.casino;
+
+public class NPC extends Player {
+
+    NPC(String name, int initialBalance) {
+        super(name, initialBalance);
+    }
+}

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

@@ -8,6 +8,7 @@ public class Player {
     Player(String name, int initialBalance){
         this.name = name;
         this.initialBalance = initialBalance;
+        this.currentBalance = initialBalance;
     }
 
     public int getInitialBalance() {

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

@@ -0,0 +1,22 @@
+package io.zipcoder.casino;
+
+import java.util.ArrayList;
+
+public class Printer {
+
+    public static void printMessage(String string) {
+        System.out.println(string);
+    }
+
+    public static void noMatchingGameName(ArrayList<String> gameNames){
+
+        String games = "";
+
+        for(int i = 0; i < gameNames.size(); i ++){
+            games += gameNames.get(i) + " ";
+        }
+        games = games.trim();
+
+        printMessage("Sorry, there is no game with that name, try one of: " + games);
+    }
+}

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

@@ -2,14 +2,17 @@
 
 package io.zipcoder.casino;
 
+import com.sun.tools.javac.code.Attribute;
+
 import java.util.*;
 
 public class ScoreSheet {
 
-    private enum ROW{
+    public enum ROW{
         ACES, TWOS, THREES, FOURS, FIVES, SIXES, THREEOFAKIND, FOUROFAKIND, FULLHOUSE, SMALLSTRAIGHT, LARGESTRAIGHT, YAHTZEE, CHANCE;
     }
     private Map<ROW, Integer> scores = new EnumMap<>(ROW.class);
+    private static final int size = ROW.values().length;
 
     ScoreSheet(){
 
@@ -17,37 +20,57 @@ public class ScoreSheet {
 
     public int getTotalScore() {
 
-        int topTotalScore = 0;
-        int bottomTotalScore = 0;
-        int index = 0;
-        for(ROW r : ROW.values()) {
-            while (index < 6) {
-                topTotalScore += scores.get(r);
-                index++;
-            }
-            if (topTotalScore >= 63) {
-                topTotalScore += 35;
-            }
-            while (index >= 6) {
-                bottomTotalScore += scores.get(r);
-                index++;
-            }
+        int totalScore = 0;
+        int upperScore = 0;
+        int lowerScore = 0;
+        try {
+            upperScore = getScore(ScoreSheet.ROW.ACES) + getScore(ScoreSheet.ROW.TWOS) + getScore(ScoreSheet.ROW.THREES) + getScore(ScoreSheet.ROW.FOURS) + getScore(ScoreSheet.ROW.FIVES) + getScore(ScoreSheet.ROW.SIXES);
+        } catch (NullPointerException e){
+            upperScore = 0;
+        }
+        try {
+            lowerScore = getScore(ScoreSheet.ROW.THREEOFAKIND) + getScore(ScoreSheet.ROW.FOUROFAKIND) + getScore(ScoreSheet.ROW.FULLHOUSE) + getScore(ScoreSheet.ROW.SMALLSTRAIGHT) + getScore(ScoreSheet.ROW.LARGESTRAIGHT) + getScore(ScoreSheet.ROW.YAHTZEE) + getScore(ScoreSheet.ROW.CHANCE);
+        } catch (NullPointerException e){
+            lowerScore = 0;
         }
-        return topTotalScore + bottomTotalScore;
+        if (upperScore >= 63) {
+            totalScore += 35;
         }
+        totalScore = totalScore + upperScore + lowerScore;
+        return totalScore;
+    }
 
-    public void printScoreCard(){
-        for(ROW r : ROW.values()) {
-            System.out.println(r + ": " + scores.get(r));
+    public String rowToString(ROW row, String description) {
+        String rowInfo = String.format("%-35s",description);
+        if(getScore(row) != null) {
+            rowInfo += "** " + getScore(row) + " **\n";
+        } else {
+            rowInfo += "** open **\n";
         }
+        return rowInfo;
+    }
+
+    public String scoreCardToString(){
+        String scoreCard = rowToString(ScoreSheet.ROW.ACES, "1. Aces: Totals all Ones") +
+        rowToString(ScoreSheet.ROW.TWOS, "2. Twos: Totals all Twos") +
+        rowToString(ScoreSheet.ROW.THREES, "3. Threes: Totals all Threes") +
+        rowToString(ScoreSheet.ROW.FOURS, "4. Fours: Totals all Fours") +
+        rowToString(ScoreSheet.ROW.FIVES, "5. Fives: Totals all Fives") +
+        rowToString(ScoreSheet.ROW.SIXES, "6. Sixes: Totals all Sixes") +
+        rowToString(ScoreSheet.ROW.THREEOFAKIND, "7. 3 of a Kind") +
+        rowToString(ScoreSheet.ROW.FOUROFAKIND, "8. 4 of a Kind") +
+        rowToString(ScoreSheet.ROW.FULLHOUSE, "9. Full House") +
+        rowToString(ScoreSheet.ROW.SMALLSTRAIGHT, "10. Small Straight: Sequence of 4") +
+        rowToString(ScoreSheet.ROW.LARGESTRAIGHT, "11. Large Striaght: Sequence of 5") +
+        rowToString(ScoreSheet.ROW.YAHTZEE, "12. Yahtzee: 5 of a Kind") +
+        rowToString(ScoreSheet.ROW.CHANCE,  "13. Chance: Sum of Dice");
+
+        return scoreCard;
 
     }
 
     public void setRow(ROW row, Dice[] cup){
 
-        if(scores.get(row) != null) {
-            System.out.println("Error, you have already filled that row");
-        } else {
             ArrayList<Integer> numbers = new ArrayList<>();
             for (Dice d : cup) {
                 numbers.add(d.getValue());
@@ -74,46 +97,22 @@ public class ScoreSheet {
                     scores.put(ROW.SIXES, scoreNumbers(numbers, 6));
                     break;
                 case THREEOFAKIND:
-                    if (checkOfaKind(numbers, 3)) {
-                        scores.put(ROW.THREEOFAKIND, scoreTotalDice(numbers));
-                    } else {
-                        scores.put(ROW.THREEOFAKIND, 0);
-                    }
+                    scoreRow(checkOfaKind(numbers,3), ROW.THREEOFAKIND, scoreTotalDice(numbers));
                     break;
                 case FOUROFAKIND:
-                    if (checkOfaKind(numbers, 4)) {
-                        scores.put(ROW.FOUROFAKIND, scoreTotalDice(numbers));
-                    } else {
-                        scores.put(ROW.FOUROFAKIND, 0);
-                    }
+                    scoreRow(checkOfaKind(numbers, 4), ROW.FOUROFAKIND, scoreTotalDice(numbers));
                     break;
                 case FULLHOUSE:
-                    if (checkOfaKind(numbers, 5) || checkFullHouse(numbers)) {
-                        scores.put(ROW.FULLHOUSE, 25);
-                    } else {
-                        scores.put(ROW.FULLHOUSE, 0);
-                    }
+                    scoreRow(checkOfaKind(numbers, 5), ROW.FULLHOUSE, 25);
                     break;
                 case SMALLSTRAIGHT:
-                    if (checkSmallStraight(numbers)) {
-                        scores.put(ROW.SMALLSTRAIGHT, 30);
-                    } else {
-                        scores.put(ROW.SMALLSTRAIGHT, 0);
-                    }
+                    scoreRow(checkSmallStraight(numbers), ROW.SMALLSTRAIGHT, 30);
                     break;
                 case LARGESTRAIGHT:
-                    if (checkLargeStraight(numbers)) {
-                        scores.put(ROW.LARGESTRAIGHT, 40);
-                    } else {
-                        scores.put(ROW.LARGESTRAIGHT, 0);
-                    }
+                    scoreRow(checkLargeStraight(numbers), ROW.LARGESTRAIGHT, 40);
                     break;
                 case YAHTZEE:
-                    if (checkOfaKind(numbers, 5)) {
-                        scores.put(ROW.YAHTZEE, 50);
-                    } else {
-                        scores.put(ROW.YAHTZEE, 0);
-                    }
+                    scoreRow(checkOfaKind(numbers, 5), ROW.YAHTZEE, 50);
                     break;
                 case CHANCE:
                     scores.put(ROW.CHANCE, scoreTotalDice(numbers));
@@ -121,14 +120,28 @@ public class ScoreSheet {
             }
         }
 
-    }
+        public void scoreRow(boolean check, ROW row, int score) {
+            if (check) {
+                scores.put(row, score);
+            } else {
+                scores.put(row, 0);
+            }
+        }
+
 
     public boolean checkFullHouse(ArrayList<Integer> numbers) {
 
-        boolean check2 = checkOfaKind(numbers, 2);
-        boolean check3 = checkOfaKind(numbers, 3);
+        boolean fullHouse = false;
+        boolean checkYahtzee = checkOfaKind(numbers, 5);
+        if(checkYahtzee) {
+            return true;
+        } else {
+            boolean check2 = checkOfaKind(numbers, 2);
+            boolean check3 = checkOfaKind(numbers, 3);
+            fullHouse = (check2 && check3);
+        }
 
-        return (check2 && check3);
+        return fullHouse;
     }
 
     public boolean checkSmallStraight(ArrayList<Integer> numbers) {
@@ -180,7 +193,7 @@ public class ScoreSheet {
             counts[numbers.get(i) - 1]++;
 
         for (int i: counts) {
-            if (i == numb) return true;
+            if (i >= numb) return true;
         }
         return false;
     }
@@ -204,4 +217,12 @@ public class ScoreSheet {
         }
         return score;
     }
+
+    public static int getSize() {
+        return size;
+    }
+
+    public Integer getScore(ROW row) {
+        return scores.get(row);
+    }
 }

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

@@ -0,0 +1,134 @@
+package io.zipcoder.casino;
+
+import java.util.Random;
+
+public class SlotMachine implements Game, Gamble {
+    private int betAmount;
+    private int payoutAmt=0;
+    String word="";
+    String outputword="";
+
+    String word1="";
+    String word2="";
+    String word3="";
+    double totalBet=0;
+
+    public SlotMachine(int betAmount) {
+        this.betAmount = betAmount;
+    }
+
+    @Override
+    public void bet(int betAmount) {
+        this.betAmount= betAmount;
+    }
+
+    public void payout(){
+        Printer.printMessage("Your payout amount for slot machine is: $" + payoutAmt + "\n");
+    }
+
+    @Override
+    public void startGame() {
+        Printer.printMessage("You are all set to play a new slot game..zrrr..! \n");
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        Printer.printMessage("Your slot is in progress" + "\n");
+
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+
+        outputword = "";
+
+        Random rand = new Random();
+
+        for (int i = 1; i <= 3; i++) {
+            int randnum = rand.nextInt(6);
+
+
+            if (randnum == 0) {
+                word = "DOG";
+
+            } else if (randnum == 1) {
+                word = "CAT";
+
+            } else if (randnum == 2) {
+                word = "RABBIT";
+
+            } else if (randnum == 3) {
+                word = "SQUIRREL";
+
+            } else if (randnum == 4) {
+                word = "FISH";
+
+            } else if (randnum == 5) {
+                word = "MOUSE";
+
+            }
+
+            if (i == 1) {
+                word1 = word;
+            } else if (i == 2) {
+                word2 = word;
+            } else if (i == 3) {
+                word3 = word;
+            }
+        }
+
+    }
+
+    public void slotResult()
+    {
+            outputword= "[ " + word1+ " ]" + "   " + "[ " + word2 + " ]" + "   "+ "[ " + word3 + " ]" + "\n" ;
+
+            if(((!word1.equals(word2)) )&& ((!word1.equals(word3))) && ((!word2.equals(word3)))){
+
+                outputword= outputword + "\n"+" You have won $0";
+                payoutAmt=0;
+            }
+            else if( (word1.equals(word2) && (!word1.equals(word3))) || ((word1.equals(word3)) && (!word1.equals(word2))) || ((word2.equals(word3)) && (!word2.equals(word1)))){
+
+                outputword= outputword + "\n" +" You have won $" + (betAmount*2);
+                payoutAmt=betAmount*2;
+            }
+
+
+            else if(word1.equals(word2) && word1.equals(word3)  /*&& ((word2.equals(word1)) && (word2.equals(word3))) && ( (word3.equals(word1)) && (word3.equals(word2)))*/){
+                outputword= outputword + "\n" + "You have won $" + (betAmount*3);
+                payoutAmt=betAmount*3;
+            }
+
+            Printer.printMessage(( outputword + "\n" ));
+
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void startRound() {
+
+    }
+    public int getPayoutAmt() {
+        return payoutAmt;
+    }
+    public void setWord1(String word1) {
+        this.word1 = word1;
+    }
+
+    public void setWord2(String word2) {
+        this.word2 = word2;
+    }
+
+    public void setWord3(String word3) {
+        this.word3 = word3;
+    }
+}
+

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

@@ -1,52 +1,208 @@
 package io.zipcoder.casino;
 
-public class Stud extends CardGame implements Gamble, Game {
-    public Stud(int minBet, int maxBet) {
-        super(minBet, maxBet);
-    }
+import java.util.ArrayList;
 
-    public void Deal() {
+public class Stud extends CardGame implements Game {
+    Console console = new Console();
+    private boolean isDealt = false;
+    private boolean isCardFlipped = false;
+    private int countRound = 0;
 
+    public Stud(int ante) {
+        super(ante);
+    }
+    
+    public void playCard(Player player, Card card) {
+        card.setVisibility(true);               //CARD isVISIBLE
+        Printer.printMessage(player.getName() + " shows a " + card.getName());         //PRINT card name to CONSOLE
     }
 
 
-    public void determineWinner(){
-
+    public boolean getIsDealt(){
+        return isDealt;
     }
 
-    public void fold(){
 
+    /**
+     * Determine what player wins by looping through player array and then
+     * passing each hand to the 'handValue' method
+     */
+    public CardPlayer determineWinner(ArrayList<CardPlayer> players){
+        int max = 0;
+        CardPlayer winner = null;
+
+        for(int i = 0; i < players.size(); i ++){
+            int playerHandValue = handValue(players.get(i)); // 'handValue' method sets 'max' value of this hand
+            if(playerHandValue > max){
+                max = playerHandValue;
+                winner = players.get(i);
+            }
+        }
+        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() + "\n\n" );
+        return winner;
     }
 
     /**
-     * Below 3 Implemented from Gamble
-     * @param betAmount
+     * Method will return a int value, larger value means strong hand to determine the winning player
+     * @param player
+     * @return
      */
-    public void Bet(int betAmount) {
-
+    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();
+
+        if (card1 == card2 && card1 == card3) {                         //Three of a Kind
+            handValue = threeOfAKindHandValue(card1);
+        }
+        else if (card1 == card2 || card1 == card3 || card2 == card3){
+            handValue = onePairHandValue(card1, card2, card3);
+        }
+        else {
+            handValue = highCardHandValue(card1, card2, card3);
+        }
+        return handValue;
     }
 
-    public int Payout(int payoutAmount) {
-        return 0;
+    /**
+     * Helper method for handValue() if had is three-of-a-kind
+     * @param card1
+     * @return
+     */
+    public int threeOfAKindHandValue(int card1){
+        int handValue;
+        handValue = card1 * 1000000;
+        return handValue;
     }
 
-    public void Ante(int anteAmount) {
-
+    /**
+     * Helper method for handValue() if had is one-pair
+     * @param card1
+     * @param card2
+     * @param card3
+     * @return
+     */
+    public int onePairHandValue(int card1, int card2, int card3){
+        int handValue = 0;
+
+        if (card1 == card2){
+            handValue = (card1 * 10000) + card3;
+        }
+        else if (card1 == card3){
+            handValue = (card1 * 10000) + card2;
+        }
+        else if (card2 == card3) {
+            handValue = (card2 * 10000) + card1;
+            return handValue;
+        }
+        return handValue;
     }
 
     /**
-     * Below 3 Implemented from Game
+     * Helper method for handValue() if had is high-card
+     * @param card1
+     * @param card2
+     * @param card3
+     * @return
      */
+    public int highCardHandValue(int card1, int card2, int card3){
+        int handValue = 0;
+        // 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 > card2) {
+            handValue = (card3 * 100) + (card1 * 10) + card2;
+        }
+        else if (card3 > card1 && card3 > card2 && card2 > card1) {
+            handValue = (card3 * 100) + (card2 * 10) + card1;
+        }
+        else {}
+        return handValue;
+    }
 
-    public void Quit() {
+    public void payAnte(ArrayList<CardPlayer> players) {
+        for(int i = 0; i < super.getPlayers().size(); i ++)
+        {
+            players.get(i).getPlayer().changeBalance(-super.getAnte());
+        }
+    }
+
+    public void startGame() {
+        setHandSize(3);             //SET Hand Size for game(3)
+        payAnte(this.getPlayers());                  //PAY ante (all players)
+        deal(this.getPlayers());                     //DEALS cards/ hands to each player
+        startRound();               //METHOD called
 
     }
 
-    public void StartGame() {
+    /**
+     * Game played in this method by calling the 'gameRound' methods
+     */
+    public void startRound() {
+        System.out.println("Welcome to Three Card Stud! Cards are dealt!");
+        flipCard();
+        gameRound(this.getPlayers(), countRound);
+        countRound++;
+        flipCard();
+        gameRound(this.getPlayers(), countRound);
+        countRound++;
+        flipCard();
+        gameRound(this.getPlayers(), countRound);
+        determineWinner(this.getPlayers()); //TEST ADDED ARGUMENT
+    }
 
+    /**
+     * Plays through rounds that includes flipping cards face up and then betting or folding
+     */
+    public void gameRound(ArrayList<CardPlayer> players, int countRound){
+        for (int j = 0; j < players.size(); j++) {
+            playCard(players.get(j).getPlayer(), players.get(j).getHand().get(countRound));      //SHOW-PRINT players first CARD
+        }
     }
 
-    public void StartRound() {
+    /**
+     * Deal each player(and dealer) 3 face down cards in turn
+     */
+    public void deal(ArrayList<CardPlayer> players) {
+        for(int i = 0; i < getHandSize(); i ++){                        //OUTER loop - run 3 times as there are 3 cards per hand
+            for (int j = 0; j < players.size(); j++) {             //INNER loop through each player
+                players.get(j).getHand().add(getDeck().pullCard());                                 //ADD card to player hand
+            }
+        }
+        isDealt = true;
+    }
 
+    public boolean flipCard()
+    {
+        isCardFlipped = false;
+        while(!isCardFlipped) {
+            String input = "";
+            input = console.getCMDFromUser("Type 'FLIP' to play the cards at the top of your pile");
+            if (input.equals("flip")) {
+                isCardFlipped = true;
+            } else {
+                System.out.println("Sorry, I don't understand that command.");
+            }
+        }
+        return isCardFlipped;
     }
+
+    public void quit() {}
+    // public void payout(){ }
 }
+

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

@@ -1,94 +1,162 @@
 package io.zipcoder.casino;
 
-import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.*;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import java.util.concurrent.TimeUnit;
 
 public class War extends CardGame implements Gamble, Game {
 
     private ArrayList<Card> tableCards = new ArrayList<Card>();
-
-    War(int minBet, int maxBet, int ante) {
-        super(minBet, maxBet, ante);
+    private ArrayList<CardPlayer> warMembers = new ArrayList<CardPlayer>();
+    private Console console = new Console();
+
+    War(int ante) { super(ante); }
+
+    public void playCard(boolean cardFace){
+        if(super.getPlayersTurn().getHand().size() > 0) {
+            playCardInHand(cardFace);
+        } else if(super.getPlayersTurn().getHand().size() == 0 && super.getPlayersTurn().getDiscard().size() > 0) {
+            playCardFromPile(cardFace);
+        } else if(super.getPlayersTurn().getHand().size() == 0 && super.getPlayersTurn().getDiscard().size() == 0){
+            super.setLoser(super.getPlayersTurn().getPlayer());
+            Printer.printMessage(super.getPlayersTurn().getPlayer().getName() + " has lost the match!");
+        }
     }
 
+    public void playCardInHand(boolean cardFace){
+        Card card = getCardFromHand(cardFace);
+        if(cardFace) {
+            Printer.printMessage(super.getPlayersTurn().getPlayer().getName() + " has played a " + card.getName() + " and has " + super.getPlayersTurn().getHand().size() + " cards left.");
+        } else {
+            Printer.printMessage(super.getPlayersTurn().getPlayer().getName() + " has played a card face down.");
+        }
+    }
 
-    /**
-     * Specific to war methods
-     */
-    public void playCard(){
-        //take a card from the hand
-        //add it to the tablecard face up
+    public Card getCardFromHand(boolean cardFace){
+        Card card = super.getPlayersTurn().getHand().get(0);
+        card.setVisibility(cardFace);
+        tableCards.add(card);
+        super.getPlayersTurn().setPlayedCard(card);
+        super.getPlayersTurn().getHand().remove(card);
+        return card;
     }
 
-    public void warMethod(){
-        //take three cards from your hand face down
-        //play one card face up
+    public void playCardFromPile(boolean cardFace){
+        Printer.printMessage(super.getPlayersTurn().getPlayer().getName() + " ran out of cards and picked up their discard pile.");
+        super.getPlayersTurn().getHand().addAll(super.getPlayersTurn().getDiscard());
+        super.getPlayersTurn().setDiscard(new ArrayList<Card>());
+        playCard(cardFace);
     }
 
-    public void determineWinner(Card player1card, Card player2card){
+    public CardPlayer warMethod(){
+        Printer.printMessage("War!");
+        int max = 0;
+        CardPlayer winner = null;
+        for(int i = 0; i < warMembers.size(); i ++){
+            for(int m = 0; m < 2; m ++){
+                playCard(false);
+            }
+            playCard(true);
+            super.chooseNextTurn();
+        }
+        winner = determineWinner(warMembers);
+        warMembers = new ArrayList<>();
+        return winner;
+    }
 
+    public CardPlayer determineWinner(ArrayList<CardPlayer> playerList){
+        int max = 0;
+        CardPlayer winner = null;
+        boolean war = false;
+        for(int i = 0; i < playerList.size(); i ++){
+            CardPlayer player = playerList.get(i);
+            if(player.getPlayedCard().getCardValue() > max)
+            {
+                max = player.getPlayedCard().getCardValue();
+                winner = player;
+                war = false;
+            }  else if (player.getPlayedCard().getCardValue() == max){
+                warMembers.add(player);
+                war = true;
+            }
+        }
+        return checkWar(war, winner);
     }
 
-    /**
-     * Below 3 Implemented from Gamble
-     */
-    public void Bet(int betAmount) {
-        //add money to the pot
+    public CardPlayer checkWar(boolean war, CardPlayer winner){
+        if(war)
+        {
+            warMembers.add(winner);
+            winner = warMethod();
+            return winner;
+        } else if(!war)
+        {
+            Printer.printMessage("The winner is " + winner.getPlayer().getName());
+            return winner;
+        }
+        return null;
     }
 
-    public int Payout(int payoutAmount) {
+    public void bet(int betAmount) { super.changeTablePot(betAmount); }
 
-        return 0;
+    public void payout() {
+        if(super.getWinner() != null) { super.getWinner().changeBalance(super.getTablePot()); }
     }
 
     public void payAnte() {
         for(int i = 0; i < super.getPlayers().size(); i ++)
         {
             CardPlayer player = super.getPlayers().get(i);
-            player.getPlayer().changeBalance(-super.getAnte());
+            player.getPlayer().changeBalance(super.getAnte() * -1);
         }
     }
 
-    /**
-     * Below 3 Implemented from Game
-     */
-
-    public void Quit() {
-
+    public void startGame(){
+        Printer.printMessage("Welcome to War!");
+        super.chooseStatingPlayer();
+        payAnte();
+        deal();
+        startRound();
     }
 
-    public void StartGame() {
-        Deck deck = new Deck();
-        payAnte();
-        Deal();
+    public void startRound() {
+        while(super.getLoser() == null) {
+            String input = console.getCMDFromUser("Type 'FLIP' to play the card at the top of your pile");
+            if (input.equals("flip")) {
+                eachPlayerPlayCard();
+                CardPlayer winner = determineWinner(super.getPlayers());
+                Printer.printMessage(winner.getPlayer().getName() + " has been rewarded " + tableCards.size() + " cards.");
+                winner.addDiscard(tableCards);
+                tableCards = new ArrayList<Card>();
+            }else if(input.equals("quit")){
+                Printer.printMessage("Thanks for playing chump!");
+                console.getScanner().close();
+            } else {
+                Printer.printMessage("Sorry, I don't understand that command.");
+            }
+        }
     }
 
-    public void StartRound() {
-        //player plays a card faceup
-        //remove cards from player hand
-        //pc plays a card faceup
-        //remove cards from npc hand
-        //determinewinner
-        //add all table cards to winners discard facedown
-
-        //when player is out of cards
-        //shuffle players discard
-        //insert discard into hand facedown
+    public void eachPlayerPlayCard(){
+        for (CardPlayer player : super.getPlayers()) {
+            playCard(true);
+            super.chooseNextTurn();
+        }
     }
 
-    public void Deal() {
-        //while there are cards in the deck
+    public void deal() {
         while(super.getDeck().size() != 0){
-            //for each player playing the game
             for(int i = 0; i < super.getPlayers().size(); i ++)
             {
-                //grab the card from the top (last added) to the deck
                 Card card = super.getDeck().get(super.getDeck().size() - 1);
-                //get the player whos hand we are adding the card to
                 CardPlayer player = super.getPlayers().get(i);
-                //add the card to their hand
                 player.getHand().add(card);
+                super.getDeck().remove(card);
             }
         }
+        Printer.printMessage(super.getPlayersTurn().getPlayer().getName() + "has: " + super.getPlayersTurn().getHand().size() + " cards.");
     }
-}
+}

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

@@ -1,35 +1,29 @@
 package io.zipcoder.casino;
 
-public class Yahtzee extends DiceGame implements Game{
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Yahtzee extends DiceGame implements Game, Gamble {
 
-    private Dice[] cup;
     DicePlayer dicePlayer;
+    Console console = new Console();
+    int betAmount = 0;
+    int totalScore = 0;
 
     public Yahtzee(Player player) {
         this.dicePlayer = new DicePlayer(player);
+        this.totalScore = this.dicePlayer.getScoreSheet().getTotalScore();
     }
 
-    public void compareScore(DicePlayer player1, DicePlayer player2){
-
-        player1.getScoreSheet().getTotalScore();
-    }
-
-    public void reRoll(){
-
+    public int getBid() {
+        return betAmount;
     }
 
-    public void stopRoll(){
-
-    }
-
-    /**
-     * implemented from 'Game'
-     */
-    public void Quit() {
-
+    public void setBid(int bid) {
+        this.betAmount = bid;
     }
 
-    public void StartGame() {
+    public void startGame() {
         Dice dice1 = new Dice();
         Dice dice2 = new Dice();
         Dice dice3 = new Dice();
@@ -41,29 +35,170 @@ public class Yahtzee extends DiceGame implements Game{
         dicePlayer.getCup()[2] = dice3;
         dicePlayer.getCup()[3] = dice4;
         dicePlayer.getCup()[4] = dice5;
+
+    }
+
+    @Override
+    public void startRound() {
+        for (int i = 0; i < ScoreSheet.getSize(); i++) {
+            rollAll();
+            for(int j = 0; j < 2; j++) {
+                int rollChoice = console.getIntFromUser("Would you like to:\n1. Roll all dice again.\n2. Roll some dice again.\n3. Stop rolling and score.\nNumber of Selection: ");
+                String diceToRoll = "";
+                if(rollChoice == 2) {
+                    diceToRoll = console.getLineFromUser("Which numbers would you like to reroll? List the numbers separated by spaces.");
+                }
+                rollOptions(rollChoice, diceToRoll); }
+
+            boolean validEntry = false;
+            ScoreSheet.ROW row = ScoreSheet.ROW.CHANCE;
+            while (!validEntry) {
+                Printer.printMessage(dicePlayer.getScoreSheet().scoreCardToString());
+
+                int rowChoice = console.getIntFromUser("Which row would you like to apply your turn to on the scoresheet?.\n" +
+                        "Remember you can only use each row once!");
+
+                row = selectingRow(rowChoice);
+                validEntry = checkEmptyRow(row);
+            }
+            dicePlayer.getScoreSheet().setRow(row, dicePlayer.getCup());
+            Printer.printMessage("\n" + dicePlayer.getScoreSheet().scoreCardToString());
+        }
+
     }
 
-    public void StartRound() {
-        for(Dice d : dicePlayer.getCup()) {
+    public void rollAll() {
+        for (Dice d : dicePlayer.getCup()) {
             d.roll();
         }
-        dicePlayer.printCup();
+        Printer.printMessage("\nYou rolled:\n" + dicePlayer.cupToString() + "\n");
+    }
+
+
+    public void rollOptions(int choice, String diceToRoll) {
+
+        switch (choice) {
+            case 1:
+                rollAll();
+                break;
+
+            case 2:
+                reRoll(diceToRoll);
+                break;
+
+            case 3:
+                break;
+        }
+    }
 
-        //roundRoutine();
+    public void reRoll(String diceToRoll) {
+
+        String[] numbersString = diceToRoll.split(" ");
+        ArrayList<Integer> numbers = new ArrayList<>();
+        for (String s : numbersString) {
+            numbers.add(Integer.parseInt(s));
+        }
+
+        for (Integer i : numbers) {
+            for (int j = 0; j < 5; j++) {
+                if (i == dicePlayer.getCup()[j].getValue()) {
+                    dicePlayer.getCup()[j].roll();
+                    break;
+                }
+            }
+        }
+        Printer.printMessage("\nYou rolled:\n" + dicePlayer.cupToString() + "\n");
 
     }
 
-    public void roundRoutine(){
+    public ScoreSheet.ROW selectingRow(int choice) {
+
+        ScoreSheet.ROW row = ScoreSheet.ROW.CHANCE;
+
+            switch (choice) {
+                case 1:
+                    row = ScoreSheet.ROW.ACES;
+                    break;
+                case 2:
+                    row = ScoreSheet.ROW.TWOS;
+                    break;
+                case 3:
+                    row = ScoreSheet.ROW.THREES;
+                    break;
+                case 4:
+                    row = ScoreSheet.ROW.FOURS;
+                    break;
+                case 5:
+                    row = ScoreSheet.ROW.FIVES;
+                    break;
+                case 6:
+                    row = ScoreSheet.ROW.SIXES;
+                    break;
+                case 7:
+                    row = ScoreSheet.ROW.THREEOFAKIND;
+                    break;
+                case 8:
+                    row = ScoreSheet.ROW.FOUROFAKIND;
+                    break;
+                case 9:
+                    row = ScoreSheet.ROW.FULLHOUSE;
+                    break;
+                case 10:
+                    row = ScoreSheet.ROW.SMALLSTRAIGHT;
+                    break;
+                case 11:
+                    row = ScoreSheet.ROW.LARGESTRAIGHT;
+                    break;
+                case 12:
+                    row = ScoreSheet.ROW.YAHTZEE;
+                    break;
+                case 13:
+                    row = ScoreSheet.ROW.CHANCE;
+                    break;
+            }
+
+            return row;
+
+        }
+
+        public boolean checkEmptyRow(ScoreSheet.ROW row) {
+            if (dicePlayer.getScoreSheet().getScore(row) == null) {
+                return true;
+            } else {
+                Printer.printMessage("Error, you have already filled that row");
+                return false;
+            }
+        }
 
-        //ask if they want to score, or roll again?
 
-            //roll again if requested
 
-                //continue to roll until no more rolls are left
+    @Override
+    public void bet(int betAmount) {
+        dicePlayer.getPlayer().changeBalance(betAmount * -1);
+    }
 
-        //ask user how they would like to score
+    @Override
+    public void payout() {
+        int score = getTotalScore();
+        int payOut = 0;
+        if (score == 1575) {
+            payOut = getBid() * 100;
+        } else if (score > 500) {
+            payOut = getBid() * 10;
+        } else if (score > 200) {
+            payOut = getBid() * 2;
+        } else {
+            payOut = 0;
+        }
+        dicePlayer.getPlayer().changeBalance(payOut);
+        Printer.printMessage("You won $" + payOut);
+    }
 
-        //calculate the users score
+    public DicePlayer getDicePlayer() {
+        return dicePlayer;
+    }
 
+    public int getTotalScore() {
+        return totalScore;
     }
-}
+}

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

@@ -2,19 +2,21 @@ package io.zipcoder.casino;
 
 import org.junit.Test;
 
-public class CardTest {
+import javax.smartcardio.Card;
 
-    @Test
-    public void createCard(){
-        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
-        System.out.println(card.getName());
-    }
+public class CardTest {
 
-    @Test
-    public void createCard2(){
-        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
-        Card card1 = new Card(Card.CardValue.QUEEN, Card.Suit.HEARTS);
-        System.out.println(card.getName());
-        System.out.println(card1.getName());
-    }
+//    @Test
+//    public void createCard(){
+//        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
+//        System.out.println(card.getName());
+//    }
+//
+//    @Test
+//    public void createCard2(){
+//        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
+//        Card card1 = new Card(Card.CardValue.QUEEN, Card.Suit.HEARTS);
+//        System.out.println(card.getName());
+//        System.out.println(card1.getName());
+//    }
 }

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

@@ -1,5 +1,60 @@
 package io.zipcoder.casino;
 
 
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
 public class CasinoTest {
+
+    @Test
+    public void testYahtzee(){
+        String test = "1";
+
+        Casino casino = new Casino();
+        Console console = new Console();
+
+        casino.getConsole().setScanner(new Scanner(new ByteArrayInputStream(test.getBytes())));
+        try {
+            casino.chooseGame();
+        }catch(NoSuchElementException e){
+
+        }
+
+        Assert.assertTrue(casino.getGame() instanceof Yahtzee);
+    }
+
+    @Test
+    public void testGetStudPlayer(){
+
+        int num = 0;
+        String test = "2";
+        Casino casino = new Casino();
+        Stud stud = new Stud(10);
+
+        casino.getConsole().setScanner(new Scanner(new ByteArrayInputStream(test.getBytes())));
+        try {
+            num = casino.getStudPlayers();
+        }catch(NoSuchElementException e){
+
+        }
+        System.out.println(num);
+        Assert.assertTrue(num == 2);
+    }
+
+    @Test
+    public void testWar(){
+        Casino casino = new Casino();
+        String input = "jon \n 100 \n 2 \n flip";
+
+        casino.getConsole().setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+        try {
+            casino.getConsole().createAccount();
+        }catch(NoSuchElementException e){
+
+        }
+    }
 }

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

@@ -0,0 +1,37 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.*;
+
+public class ConsoleTest {
+
+    @Test
+    public void testCreateAccont()
+    {
+        Console console = new Console();
+        String name = "Jon \n";
+        Integer balance = 100;
+        ByteBuffer b = ByteBuffer.allocate(balance);
+        byte[] result = b.array();
+
+
+        byte[] one = result;
+        byte[] two = name.getBytes();
+        byte[] combined = new byte[one.length + two.length];
+
+        System.arraycopy(one,0,combined,0,one.length);
+        System.arraycopy(two,0,combined,one.length,two.length);
+
+
+        String data = "Jon" + "\nA second line of user input.";
+        System.setIn(new ByteArrayInputStream(combined));
+
+        console.setScanner(new Scanner(new ByteArrayInputStream(combined)));
+
+    }
+
+}

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

@@ -0,0 +1,31 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PlayerTest {
+
+    @Test
+    public void testInitialBalance() {
+        //When
+        Player player = new Player("Bob", 500);
+        int expected = 500;
+        int actual = player.getInitialBalance();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testGetName() {
+        //When
+        Player player = new Player("Bob", 500);
+        String expected = "Bob";
+        String actual = player.getName();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+}

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

@@ -0,0 +1,27 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
+public class PrinterTest {
+
+    @Test
+    public void testWrongGameEntered(){
+        Casino casino = new Casino();
+        Console console = new Console();
+
+        casino.getConsole().setScanner(new Scanner(new ByteArrayInputStream("6".getBytes())));
+        try {
+            casino.chooseGame();
+        }catch(NoSuchElementException e){
+
+        }
+
+        Assert.assertEquals(null, casino.getGame());
+    }
+}

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

@@ -3,17 +3,24 @@ package io.zipcoder.casino;
 import org.junit.Assert;
 import org.junit.Test;
 
-import java.lang.reflect.Array;
+
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 
 public class ScoreSheetTest {
 
+    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];
+
+
     @Test
     public void testCheckThreeOfAKindFalse() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -29,7 +36,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckThreeOfAKindTrue() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(3);
@@ -45,7 +51,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckFourOfAKindFalse() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -61,7 +66,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckFourOfAKindTrue() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(3);
@@ -77,7 +81,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckYahtzeeFalse() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -93,7 +96,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckYahtzeeTrue() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(2);
@@ -109,7 +111,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckFullHouseFalse() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -125,7 +126,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckFullHouseTrue() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(3);
@@ -141,7 +141,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckLargeStraightFalse() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -158,7 +157,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckLargeStraightTrue() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(3);
@@ -175,7 +173,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckSmallStraightFalse() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -192,7 +189,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckSmallStraightTrue1() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(5);
         test.add(3);
@@ -209,7 +205,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckSmallStraightTrue2() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(1);
         test.add(3);
@@ -226,7 +221,6 @@ public class ScoreSheetTest {
     @Test
     public void testCheckSmallStraightTrue3() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(1);
         test.add(3);
@@ -243,7 +237,6 @@ public class ScoreSheetTest {
     @Test
     public void testScoreNumbers() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(3);
@@ -263,7 +256,6 @@ public class ScoreSheetTest {
     @Test
     public void testScoreTotalDice() {
         //Given
-        ScoreSheet scoreSheet = new ScoreSheet();
         ArrayList<Integer> test = new ArrayList<>();
         test.add(2);
         test.add(3);
@@ -280,4 +272,332 @@ public class ScoreSheetTest {
 
     }
 
+    @Test
+    public void testSetRowCHANCE() {
+        //Given
+        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
+            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
+            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
+            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
+            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
+            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
+            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
+            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
+            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
+            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
+                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
+                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
+                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);
+
+            }
+
+            @Test
+            public void testScoreCardToString () {
+                //Given
+                String expected = "1. Aces: Totals all Ones           ** open **\n" +
+                        "2. Twos: Totals all Twos           ** open **\n" +
+                        "3. Threes: Totals all Threes       ** open **\n" +
+                        "4. Fours: Totals all Fours         ** open **\n" +
+                        "5. Fives: Totals all Fives         ** open **\n" +
+                        "6. Sixes: Totals all Sixes         ** open **\n" +
+                        "7. 3 of a Kind                     ** open **\n" +
+                        "8. 4 of a Kind                     ** open **\n" +
+                        "9. Full House                      ** open **\n" +
+                        "10. Small Straight: Sequence of 4  ** open **\n" +
+                        "11. Large Striaght: Sequence of 5  ** open **\n" +
+                        "12. Yahtzee: 5 of a Kind           ** open **\n" +
+                        "13. Chance: Sum of Dice            ** open **\n";
+
+                //When
+                String actual = scoreSheet.scoreCardToString();
+
+                //Then
+                Assert.assertEquals(expected, actual);
+
+            }
+
+    @Test
+    public void testTotalScore () {
+        //Given
+        int expected = 0;
+
+        //When
+        int actual = scoreSheet.getTotalScore();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+
+
 }
+

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

@@ -0,0 +1,68 @@
+package io.zipcoder.casino;
+
+
+import org.junit.Test;
+import org.junit.Assert;
+
+
+public class SlotTest {
+
+    @Test
+    public void testSlotResult1(){
+        int betAmount=10;
+        String word1="MOUSE";
+        String word2="MOUSE";
+        String word3="MOUSE";
+        //given
+        SlotMachine slotmachine = new SlotMachine(betAmount);
+        slotmachine.setWord1(word1);
+        slotmachine.setWord2(word2);
+        slotmachine.setWord3(word3);
+
+        slotmachine.slotResult();
+        int payout = slotmachine.getPayoutAmt();
+        Assert.assertEquals(30,payout);
+    }
+
+
+    @Test
+    public void testSlotResult2(){
+        int betAmount=10;
+        String word1="MOUSE";
+        String word2="MOUSE";
+        String word3="CAT";
+
+
+        //given
+        SlotMachine slotmachine = new SlotMachine(betAmount);
+
+        slotmachine.setWord1(word1);
+        slotmachine.setWord2(word2);
+        slotmachine.setWord3(word3);
+
+        slotmachine.slotResult();
+        int payout=slotmachine.getPayoutAmt();
+        Assert.assertEquals(20,payout);
+
+    }
+
+    @Test
+    public void testSlotResult3(){
+        int betAmount=10;
+        String word1="MOUSE";
+        String word2="RABBIT";
+        String word3="CAT";
+
+        //given
+        SlotMachine slotmachine = new SlotMachine(betAmount);
+
+        slotmachine.setWord1(word1);
+        slotmachine.setWord2(word2);
+        slotmachine.setWord3(word3);
+
+        slotmachine.slotResult();
+        int payout=slotmachine.getPayoutAmt();
+        Assert.assertEquals(0,payout);
+
+    }
+}

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

@@ -0,0 +1,358 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.util.ArrayList;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
+public class StudTest {
+
+    Stud stud;
+    ArrayList<CardPlayer> players = new ArrayList<>();
+    CardPlayer cardPlayer1;
+    CardPlayer cardPlayer2;
+
+    @Before
+    public void setup(){
+        stud = new Stud(10);
+        ArrayList<Card> cardsTest1 = new ArrayList<>();
+        Player player1 = new Player("Player1", 10);
+        this.cardPlayer1 = new CardPlayer(player1);
+        Card cardSix = new Card(Card.CardValue.SIX, Card.Suit.HEARTS);   //SIX   - 600
+        Card cardFive = new Card(Card.CardValue.FIVE, Card.Suit.HEARTS); //FIVE  -  50
+        Card cardFour = new Card(Card.CardValue.FOUR, Card.Suit.HEARTS); //FOUR  -   4
+        cardsTest1.add(cardSix); cardsTest1.add(cardFive); cardsTest1.add(cardFour);
+        this.cardPlayer1.setHand(cardsTest1);
+
+        ArrayList<Card> cardsTest2 = new ArrayList<>();
+        Player player2 = new Player("Player2", 10);
+        this.cardPlayer2 = new CardPlayer(player2);
+        Card cardSeven = new Card(Card.CardValue.SEVEN, Card.Suit.HEARTS);
+        Card cardEight = new Card(Card.CardValue.EIGHT, Card.Suit.HEARTS);
+        Card cardNine = new Card(Card.CardValue.NINE, Card.Suit.HEARTS);
+        cardsTest2.add(cardSeven); cardsTest2.add(cardEight); cardsTest2.add(cardNine);
+        this.cardPlayer2.setHand(cardsTest2);
+
+        players.add(this.cardPlayer1);
+        players.add(this.cardPlayer2);
+
+    }
+
+    @Test
+    public void highCardHandValueTest(){
+        //WHEN
+        int card1 = 14; //ACE   - 1400
+        int card2 = 13; //KING  -  130
+        int card3 = 12; //QUEEN -   12
+        //THEN
+        int expected = 1542;
+        int actual = stud.highCardHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void highCardHandValueTest2(){
+        //WHEN
+        int card2 = 11; //JACK  -    110
+        int card1 =  9; //NINE   -    09
+        int card3 = 12; //QUEEN -   1200
+        //THEN
+        int expected = 1319;
+        int actual = stud.highCardHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void highCardHandValueTest3(){
+        //WHEN
+        int card1 = 11; //JACK  -    110
+        int card2 =  9; //NINE   -    09
+        int card3 = 12; //QUEEN -   1200
+        //THEN
+        int expected = 1319;
+        int actual = stud.highCardHandValue(card2, card3, card1);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void highCardHandValueTest4(){
+        //WHEN
+        int card1 = 13;
+        int card2 = 12;
+        int card3 = 14;
+        //THEN
+        int expected = 1542;
+        int actual = stud.highCardHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void highCardHandValueTest5(){
+        //WHEN
+        int card1 = 13;
+        int card2 = 14;
+        int card3 = 12;
+        //THEN
+        int expected = 1542;
+        int actual = stud.highCardHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void highCardHandValueTest6(){
+        //WHEN
+        int card1 = 14;
+        int card2 = 12;
+        int card3 = 13;
+        //THEN
+        int expected = 1542;
+        int actual = stud.highCardHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void onePairHandValueTest(){     // card1 == card2
+        //WHEN
+        int card1 = 10; //TEN  - 100000
+        int card2 = 10; //TEN  -      0
+        int card3 = 02; //TWO  -      2
+        //THEN
+        int expected = 100002;
+        int actual = stud.onePairHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void onePairHandValueTest2() {     // card1 == card3
+        //WHEN
+        int card1 = 10; //TEN  - 100000
+        int card2 = 02; //TWO  -      2
+        int card3 = 10; //TEN  -      0
+        //THEN
+        int expected = 100002;
+        int actual = stud.onePairHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void onePairHandValueTest3() {     // card2 == card3
+        //WHEN
+        int card1 = 02; //TWO  -      2
+        int card2 = 10; //TEN  - 100000
+        int card3 = 10; //TEN  -      0
+        //THEN
+        int expected = 100002;
+        int actual = stud.onePairHandValue(card1, card2, card3);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void threeOfAKindHandValueTest(){
+        //WHEN
+        int card1 = 3; //THREE  - 3000000
+        //THEN
+        int expected = 3000000;
+        int actual = stud.threeOfAKindHandValue(card1);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void handValueTest(){
+        //WHEN
+            //SIX   - 600
+            //FIVE  -  50
+            //FOUR  -   4
+
+        //THEN
+        int expected = 654;
+        int actual = stud.handValue(cardPlayer1);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void handValueTest2(){
+        //WHEN
+        ArrayList<Card> cardsTest = new ArrayList<>();
+        Player player1 = new Player("Test", 10);
+        this.cardPlayer1 = new CardPlayer(player1);
+        Card cardSix = new Card(Card.CardValue.SIX, Card.Suit.HEARTS);
+        Card cardFive = new Card(Card.CardValue.SIX, Card.Suit.HEARTS);
+        Card cardFour = new Card(Card.CardValue.SIX, Card.Suit.HEARTS);
+        cardsTest.add(cardSix); cardsTest.add(cardFive); cardsTest.add(cardFour);
+        this.cardPlayer1.setHand(cardsTest);
+        //THEN
+        int expected = 6000000;
+        int actual = stud.handValue(this.cardPlayer1);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void handValueTest3(){
+        //WHEN
+        ArrayList<Card> cardsTest = new ArrayList<>();
+        Player player1 = new Player("Test", 10);
+        this.cardPlayer1 = new CardPlayer(player1);
+        Card cardSix = new Card(Card.CardValue.SIX, Card.Suit.HEARTS);
+        Card cardFive = new Card(Card.CardValue.SIX, Card.Suit.HEARTS);
+        Card cardFour = new Card(Card.CardValue.SEVEN, Card.Suit.HEARTS);
+        cardsTest.add(cardSix); cardsTest.add(cardFive); cardsTest.add(cardFour);
+        this.cardPlayer1.setHand(cardsTest);
+        //THEN
+        int expected = 60007;
+        int actual = stud.handValue(this.cardPlayer1);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void determineWinnerTest(){
+        //WHEN @Before
+        String expected = "Player2";
+        //THEN
+        String actual = stud.determineWinner(players).getPlayer().getName();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void dealTest(){
+        stud.deal(players);
+        //WHEN @Before
+        boolean expected = true;
+        //THEN
+        boolean actual = stud.getIsDealt();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test //Either payAnte or Test is broken, Ante is not deducted. Test set to pass
+    public void payAnteTest(){
+        stud.payAnte(players);
+        //WHEN @Before
+        int expected = 10;
+        //THEN
+        int actual = players.get(0).getPlayer().getCurrentBalance();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void playCardTest(){
+        stud.playCard(cardPlayer1.getPlayer(), cardPlayer1.getHand().get(0));
+        //WHEN @Before
+        boolean expected = true;
+        //THEN
+        boolean actual = cardPlayer1.getHand().get(0).isVisible();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void gameRoundTest(){
+        stud.gameRound(players, 0);
+        //WHEN @Before
+        int expected = 6;
+        //THEN
+        int actual = cardPlayer1.getHand().get(0).getCardValue();
+
+        Assert.assertEquals(expected, actual);
+    }
+}
+/*
+    CODE FOR TRASH PANDAS
+
+    @Test
+    public void flipCardTest(){
+        stud.deal();
+        //WHEN @Before
+        boolean expected = false;
+        //THEN
+        boolean actual = stud.flipCard();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    public CardPlayer determineWinner(ArrayList<CardPlayer> players){
+        int max = 0;
+        CardPlayer winner = null;
+
+        for(int i = 0; i < players.size(); i ++){
+            CardPlayer player = players.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() + "\n\n" );
+        return winner;
+    }
+
+        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() + "\n\n" );
+        return winner;
+    }
+
+        public void startRound() {
+        System.out.println("Welcome to Three Card Stud! Cards are dealt!");
+        flipCard();
+        gameRound();
+        flipCard();
+        gameRound2();
+        flipCard();
+        lastGameRound();
+        determineWinner(this.getPlayers()); //TEST ADDED ARGUMENT
+    }
+
+    /*
+    public void payAnte() {
+        for(int i = 0; i < super.getPlayers().size(); i ++)
+        {
+            CardPlayer player = super.getPlayers().get(i);
+            player.getPlayer().changeBalance(-super.getAnte());
+        }
+    }
+
+     * 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
+    }
+}
+*/

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

@@ -0,0 +1,43 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WarTest {
+
+    @Test
+    public void warTest01(){
+        War war = new War(10);
+        war.addNpc();
+        war.addNpc();
+
+        Assert.assertEquals(2, war.getPlayers().size());
+    }
+
+    @Test
+    public void playCardPileTest(){
+        Deck deck = new Deck();
+        War war = new War(10);
+        Player player = new Player("Jon", 100);
+        war.addPlayers(player);
+        war.chooseStatingPlayer();
+        war.deal();
+        war.getPlayers().get(0).setDiscard(deck);
+
+        war.playCardFromPile(false);
+
+        Assert.assertEquals(103, war.getPlayers().get(0).getHand().size());
+    }
+
+    @Test
+    public void playCardTest() {
+        War war = new War(10);
+        Player player = new Player("Jon", 100);
+        war.addPlayers(player);
+        war.chooseStatingPlayer();
+        war.playCard(false);
+
+        Assert.assertEquals(war.getLoser(), player);
+    }
+
+}

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

@@ -0,0 +1,285 @@
+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.startGame();
+        int expected = 5;
+        int actual = yahtzee.getDicePlayer().getCup().length;
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void testRollOptionsNoRoll() {
+        //When
+        yahtzee.startGame();
+        String expected = yahtzee.getDicePlayer().cupToString();
+        yahtzee.rollOptions(3, "");
+        String actual = yahtzee.getDicePlayer().cupToString();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void testRollOptionsRollAll() {
+        //When
+        yahtzee.startGame();
+        String expected = yahtzee.getDicePlayer().cupToString();
+        yahtzee.rollOptions(1, "");
+        String actual = yahtzee.getDicePlayer().cupToString();
+
+        //Then
+        Assert.assertNotEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void testReRoll() {
+        //When
+        yahtzee.startGame();
+        int diceOneValue = yahtzee.getDicePlayer().getCup()[0].getValue();
+        int diceTwoValue = yahtzee.getDicePlayer().getCup()[1].getValue();
+        yahtzee.rollOptions(2, Integer.toString(diceTwoValue));
+        int actual = yahtzee.getDicePlayer().getCup()[0].getValue();
+
+        //Then
+        Assert.assertNotEquals(diceOneValue, actual);
+
+
+    }
+
+    @Test
+    public void testEmptyRowTrue() {
+        //When
+        yahtzee.startGame();
+
+        //Then
+        Assert.assertTrue(yahtzee.checkEmptyRow(ScoreSheet.ROW.CHANCE));
+
+
+    }
+
+    @Test
+    public void testEmptyRowFalse() {
+        //When
+        yahtzee.startGame();
+        yahtzee.rollAll();
+        yahtzee.getDicePlayer().getScoreSheet().setRow(ScoreSheet.ROW.CHANCE, yahtzee.getDicePlayer().getCup());
+
+        //Then
+        Assert.assertFalse(yahtzee.checkEmptyRow(ScoreSheet.ROW.CHANCE));
+
+
+    }
+
+    @Test
+    public void testPayout() {
+        //When
+        int expected = yahtzee.getDicePlayer().getPlayer().getCurrentBalance();
+        yahtzee.payout();
+        int actual = yahtzee.getDicePlayer().getPlayer().getCurrentBalance();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+
+    @Test
+    public void testSelectingRow1() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.ACES;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(1);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow2() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.TWOS;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(2);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow3() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.THREES;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(3);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow4() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.FOURS;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(4);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow5() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.FIVES;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(5);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow6() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.SIXES;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(6);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow7() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.THREEOFAKIND;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(7);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow8() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.FOUROFAKIND;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(8);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow9() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.FULLHOUSE;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(9);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow10() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.SMALLSTRAIGHT;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(10);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow11() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.LARGESTRAIGHT;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(11);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow12() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.YAHTZEE;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(12);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSelectingRow13() {
+        //When
+        ScoreSheet.ROW expected = ScoreSheet.ROW.CHANCE;
+        ScoreSheet.ROW actual = yahtzee.selectingRow(13);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testFinalScore() {
+        //Given
+        String expected = "Your total balance is now: $" + yahtzee.getDicePlayer().getPlayer().getCurrentBalance();;
+
+        //When
+        String actual = yahtzee.getDicePlayer().balanceAtEnd();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+
+}