Final

README.md

@@ -24,4 +24,4 @@
 * `BlackJack` and `GoFish` are both Card Games and should therefore inherit from a common `CardGame`.
 * Any common logic or fields between the games should live CardGame class, **not** BlackJack **nor** GoFish.
 * You must have a completed and approved UML diagram before you proceed to do any development
-* All public methods should be tested.
+* All public methods should be tested

pom.xml

@@ -7,12 +7,34 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>casino</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
     <dependencies>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.stefanbirkner</groupId>
+            <artifactId>system-rules</artifactId>
+            <version>1.18.0</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>RELEASE</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

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

@@ -1,5 +1,119 @@
 package io.zipcoder.casino;
 
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.cardgames.individualcardgames.BlackJack;
+import io.zipcoder.casino.game.cardgames.individualcardgames.GoFish;
+import io.zipcoder.casino.game.cardgames.individualcardgames.HiLo;
+import io.zipcoder.casino.game.chancegames.Roulette;
+import io.zipcoder.casino.game.chancegames.Slots;
+import io.zipcoder.casino.game.dicegames.individualdicegames.Craps;
+import io.zipcoder.casino.game.interfaces.Game;
 
 public class Casino {
-}
+    Player player;
+    Game game;
+    int choice;
+    boolean playFlag;
+
+    public Casino() {
+        player = new Player();
+    }
+
+    public void startCasino() {
+
+        printWelcome();
+        askForName();
+        askForBank();
+        chooseGame();
+    }
+
+
+    public void printWelcome(){
+        Console.print("♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣");
+        Console.print("  /$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$ /$$   /$$  /$$$$$$ \n" +
+                " /$$__  $$ /$$__  $$ /$$__  $$|_  $$_/| $$$ | $$ /$$__  $$\n" +
+                "| $$  \\__/| $$  \\ $$| $$  \\__/  | $$  | $$$$| $$| $$  \\ $$\n" +
+                "| $$      | $$$$$$$$|  $$$$$$   | $$  | $$ $$ $$| $$  | $$\n" +
+                "| $$      | $$__  $$ \\____  $$  | $$  | $$  $$$$| $$  | $$\n" +
+                "| $$    $$| $$  | $$ /$$  \\ $$  | $$  | $$\\  $$$| $$  | $$\n" +
+                "|  $$$$$$/| $$  | $$|  $$$$$$/ /$$$$$$| $$ \\  $$|  $$$$$$/\n" +
+                " \\______/ |__/  |__/ \\______/ |______/|__/  \\__/ \\______/");
+        Console.print("♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣");
+        Console.print("Welcome to the Casino");
+    }
+
+    public void askForName() {
+        player.setName(Console.printAndTakeString("Enter your name:"));
+    }
+
+    public void printMenu() {
+        Console.print("Choose a game! Enter the option number (ex. 1 for Blackjack)"
+                + "\nPlayer Bank: "
+                + player.getBank()
+                + "\n1: Blackjack\n2: Hi Lo\n3: Roulette"
+                + "\n4: Craps\n5: Slots\n6: Go Fish\n7: Quit Casino");
+    }
+
+    public void askForBank() {
+
+        int userBank = Console.printAndTakeInt("Enter the amount you want to start playing with (bank) :");
+        if (!player.checkInitialBank(userBank)) {
+            Console.print("Didn't quite catch that, here's 10k Zimbabwean dollars to play.");
+            player.setBank(10000);
+        } else {
+            player.setBank(userBank);
+        }
+    }
+
+
+    private void chooseGame() {
+        boolean playGame = true;
+        while (playGame) {
+            printMenu();
+            choice = Console.getIntegerInput();
+            switch (choice) {
+                case 1:
+                    game = new BlackJack(player);
+                    game.play();
+                    break;
+
+                case 2:
+                    game = new HiLo(player);
+                    game.play();
+                    break;
+
+                case 3:
+                    game = new Roulette(player);
+                    game.play();
+                    break;
+
+                case 4:
+                    game = new Craps(player);
+                    game.play();
+                    break;
+
+                case 5:
+                    game = new Slots(player);
+                    game.play();
+                    break;
+
+                case 6:
+                    game = new GoFish(player);
+                    game.play();
+                    break;
+
+                case 7:
+                    System.exit(1);
+
+                default:
+                    Console.print("Incorrect choice. Choose the listed options");
+                    continue;
+            }
+
+            Console.print("\n\n\n\n\n♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣\n"
+                    + "Welcome back to the Casino Menu!");
+            }
+        }
+    }
+
+

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

@@ -0,0 +1,73 @@
+package io.zipcoder.casino;
+
+import sun.awt.image.IntegerInterleavedRaster;
+
+import java.io.IOException;
+import java.util.Scanner;
+
+public class Console {
+
+    private static Scanner input = new Scanner(System.in);
+
+    public static void print(String string){
+        System.out.println(string);
+    }
+
+    public static void printInSameLine(String string){
+        System.out.print(string);
+    }
+
+    public static String printAndTakeString(String s) {
+        System.out.println(s);
+        return input.next();
+    }
+
+    public static int printAndTakeInt(String s) {
+        System.out.println(s);
+        return input.nextInt();
+    }
+
+    public static String getStringInput(){
+        return input.next();
+    }
+
+    public static Integer getIntegerInput(){
+        return input.nextInt();
+    }
+
+    public static void print(int slot1, int slot2, int slot3)  {
+        System.out.printf("| %d | %d | %d |\n", slot1, slot2, slot3);
+    }
+
+    public static void pause(int t) {
+
+            try {
+                Thread.sleep(t); // In your case it would be: Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+    }
+
+    public static void pause(int t, String s){
+
+            try {
+                Console.printInSameLine(s);
+                Thread.sleep(t); // In your case it would be: Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+    }
+
+    public static void pause(int t, String s, int loop) {
+        for (int i = 0; i < loop; i++) {
+            try {
+                Console.printInSameLine(s);
+                Thread.sleep(t); // In your case it would be: Thread.sleep(100);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+//package io.zipcoder.casino;
+//
+//import GoFish;
+//import io.zipcoder.casino.game.Player;
+//
+//public class GoFishPlay {
+//
+//
+//public static void main(String[]args){
+//    Player player1 = new Player("Jared", 100);
+//    GoFish goFish = new GoFish(player1);
+//
+//    goFish.play();
+//
+////    System.out.println(player.getBank());
+////
+////    player.setBank(player.getBank()+ 200);
+////
+////    System.out.println("New bank amount: " + player.getBank());
+//
+//}
+//
+//    // Fix book logic
+//    // test quit
+//}

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

@@ -0,0 +1,11 @@
+package io.zipcoder.casino;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        Casino casino = new Casino();
+        casino.startCasino();
+
+    }
+}

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

@@ -0,0 +1,51 @@
+package io.zipcoder.casino.game;
+
+public class Player {
+    private String name;
+    private Integer bank;
+
+    public Player() {
+        this.name = "Default";
+        this.bank = 10000;
+    }
+    public Player(String name, Integer bank) {
+        this.name = name;
+        this.bank = bank;
+    }
+
+    public boolean checkbet(int amount) {
+        if ((this.getBank() - amount) < 0 || amount < 0 ) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    public boolean checkInitialBank(int amount) {
+        if (amount < 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Integer getBank() {
+        return bank;
+    }
+
+    public void setBank(Integer bank) {
+        this.bank = bank;
+    }
+    public String getState(){
+        return String.format("Highroller %s has $%,d", name, bank);
+    }
+}
+

src/main/java/io/zipcoder/casino/game/cardgames/cardutilities/Card.java

@@ -0,0 +1,48 @@
+package io.zipcoder.casino.game.cardgames.cardutilities;
+
+public class Card {
+
+
+        public Card(Suit suit, Rank value) {
+            this.suit = suit;
+            this.value = value;
+        }
+
+        private Suit suit;
+        private Rank value;
+
+
+        public Suit getSuit() {
+            return suit;
+        }
+
+        public void setSuit(Suit suit) {
+            this.suit = suit;
+        }
+
+        public Rank getValue() {
+            return value;
+        }
+
+        public void setValue(Rank value) {
+            this.value = value;
+        }
+
+        @Override
+        public String toString (){
+            String s = value + " of " + suit;
+            return s;
+        }
+
+
+        public int getSecondaryVal(Card c) {
+            return c.getValue().getSecondaryvalue();
+        }
+    }
+
+
+
+
+
+
+

src/main/java/io/zipcoder/casino/game/cardgames/cardutilities/Deck.java

@@ -0,0 +1,41 @@
+package io.zipcoder.casino.game.cardgames.cardutilities;
+
+import java.util.Collections;
+import java.util.Stack;
+
+public class Deck {
+
+    private Stack<Card> deck;
+
+    public Deck() {
+        refreshDeck();
+        deck = shuffleDeck();
+    }
+
+    public Stack<Card> getDeck() {
+        return deck;
+    }
+
+    public Stack<Card> shuffleDeck() {
+        Collections.shuffle(deck);
+        return deck;
+    }
+
+    public Card dealCard() {
+        return deck.pop();
+    }
+
+    public void refreshDeck() {
+
+        Stack<Card> newDeck = new Stack<>();
+        for (Rank r : Rank.values()) {
+            for (Suit s : Suit.values()) {
+                Card temp = new Card(s, r);
+                newDeck.push(temp);
+            }
+        }
+
+        this.deck = newDeck;
+
+    }
+}

src/main/java/io/zipcoder/casino/game/cardgames/cardutilities/Rank.java

@@ -0,0 +1,48 @@
+package io.zipcoder.casino.game.cardgames.cardutilities;
+
+public enum Rank {
+    Ace(1, 11, "ace"),
+    Two(2, 2, "two"),
+    Three(3, 3, "three"),
+    Four(4, 4, "four"),
+    Five(5, 5, "five"),
+    Six(6, 6, "six"),
+    Seven(7, 7, "seven"),
+    Eight(8, 8, "eight"),
+    Nine(9, 9, "nine"),
+    Ten(10, 10, "ten"),
+    Jack(11, 10, "jack"),
+    Queen(12, 10, "queen"),
+    King(13, 10, "king");
+
+    Rank(int value, int secondaryvalue, String thirdvalue) {
+        this.value = value;
+        this.secondaryvalue = secondaryvalue;
+        this.thirdvalue = thirdvalue;
+    }
+
+
+    Rank(int value, int secondaryvalue) {
+        this.value = value;
+        this.secondaryvalue = secondaryvalue;
+    }
+
+    private int value;
+
+    private int secondaryvalue;
+
+    public int getSecondaryvalue() {
+        return secondaryvalue;
+    }
+
+    public String getThirdvalue() {
+        return thirdvalue;
+    }
+
+    public String thirdvalue;
+
+    public int getValue() {
+        return value;
+    }
+
+}

src/main/java/io/zipcoder/casino/game/cardgames/cardutilities/Suit.java

@@ -0,0 +1,9 @@
+package io.zipcoder.casino.game.cardgames.cardutilities;
+
+public enum Suit  {
+
+    Spades, Hearts, Diamonds, Clubs
+
+}
+
+

src/main/java/io/zipcoder/casino/game/cardgames/individualcardgames/BlackJack.java

@@ -0,0 +1,233 @@
+package io.zipcoder.casino.game.cardgames.individualcardgames;
+
+
+import io.zipcoder.casino.Console;
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.cardgames.cardutilities.Card;
+import io.zipcoder.casino.game.interfaces.Gamble;
+
+import java.util.*;
+
+public class BlackJack extends CardGame implements Gamble {
+    private Player player;
+    public Integer playerTotal = 0;
+    public Integer houseTotal = 0;
+    public boolean nothaRound = true;
+    public boolean hitCheck = true;
+    public BlackJack(Player player) {
+        this.player = player;
+    }
+
+    public int bet(int betVal){
+        return betVal;
+    }
+
+    @Override
+    public void play() {
+        while (nothaRound) {
+            Console.print(intro());
+            int stakes = Console.printAndTakeInt("How much money would you like to bet " + player.getName());
+            if(!player.checkbet(stakes)){
+                Console.print("You don't have enough money get outa here!!!!");
+                break;
+            }
+            dealHand(2);
+            handSum();
+            firstShow();
+            if (playerTotal == 21) {
+                doBlackjack(stakes);
+            } else {
+                hitOrStand(getResponse(), stakes);
+            }
+            int round = Console.printAndTakeInt("Wanna play another round? ( 1 / 0 )");
+            if(round == 0) {
+                clearHands();
+                nothaRound = false;
+            }else{
+                hitCheck = true;
+                clearHands();
+            }
+        }
+    }
+    public void clearHands(){
+        getPlayerHand().clear();
+        getHouseHand().clear();
+        playerTotal = 0;
+        houseTotal = 0;
+    }
+
+    public String intro(){
+        return "♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣\n +" +
+                "♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦ WELCOME TO BLACKJACK ♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♠♥♦♣\n" +
+                "♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣\n";
+    }
+
+    public void hitOrStand(String s, int stakes){
+            switch (s.toLowerCase()) {
+                case "hit": {
+                    while(hitCheck) {
+                        dealSumFirstShow();
+                        if(playerTotal >= 21){
+                            break;
+                        }
+                        String answer = getResponse().toLowerCase();
+                        if(answer.equals("stand")){
+                            break;
+                        }
+                        hitOrStand(answer,stakes);
+                    }
+                }
+                case "stand": {
+                    if (playerTotal <= 21) {
+                        printState();
+                        if (houseTotal < 17) {
+                            dealHouse();
+                            winConditions(stakes);
+                            break;
+                        }
+                    }
+                    winConditions(stakes);
+                    break;
+                }
+            }
+    }
+    public boolean dealHouse(){
+        boolean dealtHouse = false;
+        int count = 0;
+        while (count < 4 && houseTotal < 17) {
+            dealSumPrint();
+            if (houseTotal > 21) {
+                break;
+            }
+            count++;
+        }
+        dealtHouse = true;
+        return dealtHouse;
+    }
+    public boolean dealSumPrint(){
+        boolean isSumDealt = false;
+        getHouseHand().add(deck.dealCard());
+        houseTotal = sum(getHouseHand());
+        printState();
+        isSumDealt = true;
+        return isSumDealt;
+    }
+
+    public boolean dealSumFirstShow(){
+        boolean isSumDealt = false;
+        getPlayerHand().add(deck.dealCard());
+        playerTotal = sum(getPlayerHand());
+        firstShow();
+        isSumDealt = true;
+        return isSumDealt;
+    }
+
+    public String getResponse(){
+        Console.print("Hit or Stand");
+        return Console.getStringInput();
+    }
+    public void handSum(){
+        playerTotal += sum(getPlayerHand());
+        houseTotal += sum(getHouseHand());
+    }
+    public void doBlackjack(int stakes){
+        Console.print("Hot Dog the PLAYER got Blackjack");
+        stakes = (int) (1.5 * stakes);
+        win(player, stakes);
+        Console.print(player.getState());
+    }
+    public void winConditions(int stakes){
+        if(playerTotal > 21){
+            Console.print("HOUSE WINS");
+            Console.print("PLAYER BUSTS");
+            printState();
+            loss(player, stakes);
+            Console.print(player.getState());
+            hitCheck = false;
+        }
+        else if(houseTotal > 21){
+            Console.print("PLAYER WINS");
+            Console.print("HOUSE BUSTS");
+            printState();
+            win(player,stakes);
+            Console.print(player.getState());
+            hitCheck = false;
+        }
+        else if(houseTotal > playerTotal){
+            Console.print("HOUSE WINS");
+            printState();
+            loss(player, stakes);
+            Console.print(player.getState());
+            hitCheck = false;
+        }
+        else if(houseTotal < playerTotal){
+            Console.print("PLAYER WINS");
+            printState();
+            win(player,stakes);
+            Console.print(player.getState());
+            hitCheck = false;
+        }
+        else if(houseTotal.equals(playerTotal)){
+            Console.print("PUSH");
+            printState();
+            win(player,0);
+            Console.print(player.getState());
+            hitCheck = false;
+        }
+    }
+
+    public boolean firstShow(){
+        boolean firstShown = true;
+        Console.pause(500);
+        Console.print("♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣");
+        Console.pause(500);
+        Console.print("PLAYER: " + getPlayerHand());
+        Console.pause(500);
+        Console.print("PLAYER: " + playerTotal + "\n");
+        Console.pause(500);
+        Console.print("HOUSE: [" +  getHouseHand().get(0) + ", ***** of *****]");
+        Console.pause(500);
+        Console.print("HOUSE: " +  getHouseHand().get(0).getSecondaryVal(getHouseHand().get(0)));
+        Console.pause(500);
+        Console.print("♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣");
+        Console.pause(1000);
+        return firstShown;
+    }
+
+    public void printState(){
+        Console.pause(500);
+        Console.print("♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣");
+        Console.pause(500);
+        Console.print("PLAYER: " + getPlayerHand());
+        Console.pause(500);
+        Console.print("PLAYER: " + playerTotal + "\n");
+        Console.pause(500);
+        Console.print("HOUSE: " + getHouseHand());
+        Console.pause(500);
+        Console.print("HOUSE: " + houseTotal);
+        Console.pause(500);
+        Console.print("♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣");
+        Console.pause(1000);
+    }
+    public int sum(ArrayList<Card> hand) {
+        Integer count = 0;
+        boolean aceFound = false;
+
+        for(Card crd : hand){
+            count += crd.getValue().getSecondaryvalue();
+            if(crd.getValue().getSecondaryvalue() == 11 && !aceFound){
+                if(count > 21){
+                    count -= 10;
+                    aceFound = true;
+                }
+            }
+        }
+        return count;
+    }
+
+    @Override
+    public boolean endGame(){
+        return false;
+    }
+
+}

src/main/java/io/zipcoder/casino/game/cardgames/individualcardgames/CardGame.java

@@ -0,0 +1,61 @@
+package io.zipcoder.casino.game.cardgames.individualcardgames;
+import io.zipcoder.casino.game.cardgames.cardutilities.Card;
+import io.zipcoder.casino.game.cardgames.cardutilities.Deck;
+import io.zipcoder.casino.game.interfaces.Game;
+
+import java.util.ArrayList;
+
+public abstract class CardGame implements Game {
+
+
+    Deck deck;
+    private ArrayList<Card> playerHand;
+    private ArrayList<Card> houseHand;
+
+    public void setPlayerHand(ArrayList<Card> playerHand) {
+        this.playerHand = playerHand;
+    }
+
+    public void setHouseHand(ArrayList<Card> houseHand) {
+        this.houseHand = houseHand;
+    }
+
+    public CardGame() {
+        deck = new Deck();
+        playerHand = new ArrayList<Card>();
+        houseHand = new ArrayList<Card>();
+
+    }
+
+    public void dealHand(int howManyCards) {
+
+        for (int i = 0; i < howManyCards; i++) {
+            playerHand.add(deck.dealCard());
+            houseHand.add(deck.dealCard());
+        }
+
+    }
+
+    public Integer sumPlayer(){
+        Integer count = 0;
+        for (int i = 0; i < playerHand.size(); i ++){
+            count+= playerHand.get(i).getValue().getSecondaryvalue();
+            if(count > 21 && playerHand.contains("Ace")){
+                count -= 10;
+            }
+        }
+        return count;
+    }
+
+    public ArrayList<Card> getPlayerHand() {
+        return playerHand;
+    }
+
+    public ArrayList<Card> getHouseHand() {
+        return houseHand;
+    }
+
+
+
+}
+

src/main/java/io/zipcoder/casino/game/cardgames/individualcardgames/CardPlayer.java

@@ -0,0 +1,6 @@
+package io.zipcoder.casino.game.cardgames.individualcardgames;
+
+import io.zipcoder.casino.game.Player;
+
+public class CardPlayer extends Player {
+}

src/main/java/io/zipcoder/casino/game/cardgames/individualcardgames/GoFish.java

@@ -0,0 +1,523 @@
+package io.zipcoder.casino.game.cardgames.individualcardgames;
+import io.zipcoder.casino.Console;
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.cardgames.cardutilities.Card;
+import io.zipcoder.casino.game.cardgames.cardutilities.Rank;
+
+import java.util.*;
+
+public class GoFish extends CardGame {
+
+    private Player player;
+
+    private ArrayList<Card> playerHand;
+
+    private ArrayList<Card> opponentHand;
+
+    private Card[] playerBookCheck;
+    private Card[] opponentBookCheck;
+
+    private HashMap<String, Integer> allRanks;
+
+    private boolean endGameCheck;
+
+    private int playerBook;
+    private int opponentBook;
+
+    private int playerTotalCards;
+    private int opponentTotalCards;
+
+    private int turnOrder;
+
+    public GoFish(Player player) {
+
+        this.player = player;
+
+        playerHand = getPlayerHand();
+        opponentHand = getHouseHand();
+
+        playerBookCheck = new Card[13];
+        opponentBookCheck = new Card[13];
+
+        playerBook = 0;
+        opponentBook = 0;
+        endGameCheck = false;
+
+        playerTotalCards = 0;
+        opponentTotalCards = 0;
+
+        turnOrder = randomTurnOrder();
+
+        allRanks = new HashMap<>();
+        for (Rank r: Rank.values()) {
+            allRanks.put(r.getThirdvalue(), r.getValue() - 1);
+        }
+    }
+
+    public void play() {
+
+        startOfGame();
+        firstBookCheck();
+
+
+        turnOrder = playerGoesFirst();
+
+        while (!endGameCheck) {
+            gameTurnOrder(turnOrder);
+        }
+
+        Console.print("Thanks for playing! \n ... Returning to main menu.");
+    }
+
+    public void gameTurnOrder(int turnOrder) {
+        if (turnOrder == 0) {
+            playerTurn();
+            opponentTurn();
+            bookStandings();
+
+        } else {
+            opponentTurn();
+            playerTurn();
+            bookStandings();
+        }
+    }
+
+    public void startOfGame() {
+        Console.print("Welcome to go fish, " + player.getName() + "!");
+        showRules();
+
+        startDealHands();
+    }
+
+    public void firstBookCheck() {
+        Console.print("Checking dealt hands for books... ");
+        Console.pause(250, " . ", 5);
+
+        updateBookChecker(playerHand, playerBookCheck, true);
+        updateBookChecker(opponentHand, opponentBookCheck, false);
+
+        bookStandings();
+
+    }
+
+    public void bookStandings() {
+        Console.print("\n\nCurrent book standings!"
+                + "\n" + player.getName() + "'s Books: " + getPlayerBook()
+                + "\nOpponent's Books: " + getOpponentBook() + "\n\n");
+    }
+
+    public void startDealHands() {
+        Console.print("Dealing cards...");
+        Console.pause(250, " . ", 5);
+        dealHand(7);
+        setPlayerTotalCards(7);
+        setOpponentTotalCards(7);
+    }
+
+    private void updateBookChecker(ArrayList<Card> hand, Card[] bookCheck, boolean isPlayersTurn) {
+        int cardIndex;
+        for(Card c: hand) {
+            cardIndex = c.getValue().getValue() - 1;
+            if (bookCheck[cardIndex] == null) {
+                bookCheck[cardIndex] = c;
+
+            } else {
+                String name = player.getName();
+                if (!isPlayersTurn) {
+                    name = "opponent";
+                }
+                addBookCountDecreaseCardTotal(isPlayersTurn);
+                Console.print("Removing cards " + c.toString() + " and " + bookCheck[cardIndex].toString() + " from " + name + "'s hand.");
+                bookCheck[cardIndex] = null;
+
+            }
+        }
+    }
+
+    private int randomTurnOrder() {
+        Random random = new Random();
+        return random.nextInt(2);
+    }
+
+    private int playerGoesFirst() {
+
+        Console.print("Determining who goes first...");
+        Console.pause(250, " . ", 5);
+
+        if (this.turnOrder == 0) {
+            Console.print("You go first!");
+            return 0;
+        } else {
+            Console.print("Your opponent goes first...");
+        }
+
+        return 1;
+    }
+
+
+    public void removeBook(Card[] hand, int newCardIndex) {
+        Console.print("Removing " + hand[newCardIndex].getValue().getValue() + "'s.");
+        hand[newCardIndex] = null;
+    }
+
+    public void increaseTotalCards(boolean isPlayersTurn) {
+        if (isPlayersTurn) {
+            incrementPlayersCards();
+        } else {
+            incrementOpponentCards();
+        }
+    }
+
+    public void addBookCountDecreaseCardTotal(boolean isPlayersTurn) {
+        if (isPlayersTurn) {
+            playerTurnTrue();
+        } else {
+            opponentTurnTrue();
+        }
+    }
+
+    private void goFish(Card[] hand, boolean isPlayersTurn) {
+        // put go fish here
+        Card newCard = deck.dealCard();
+        int newCardIndex = newCard.getValue().getValue() - 1;
+
+        Console.print("Adding " + newCard.toString() + " to the hand.");
+
+        if (hand[newCardIndex] != null) {
+            removeBook(hand, newCardIndex);
+            addBookCountDecreaseCardTotal(isPlayersTurn);
+
+        } else {
+            hand[newCardIndex] = newCard;
+            increaseTotalCards(isPlayersTurn);
+
+        }
+    }
+
+    public boolean endGame() {
+        return (deck.getDeck().isEmpty() || playerBook >= 13 || opponentBook >= 13);
+    }
+
+    private boolean checkRank(String s) {
+        return allRanks.get(s) != null;
+    }
+
+    private String startPlayerTurn() {
+
+        String userAsk = Console.printAndTakeString("What card do you want to ask for?");
+
+        if (!checkRank(userAsk)) {
+            userAsk = Console.printAndTakeString("Invalid entry type,"
+                + "try typing out the card number/face.. ie. Ace or two\n");
+        }
+
+        return userAsk.toLowerCase();
+    }
+
+    private boolean addAsktoHand(Card[] takeFromThisHand, Card[] addToThisHand , String userAsk, boolean isPlayersTurn) {
+
+        Card requestedCard = takeFromThisHand[allRanks.get(userAsk)];
+
+        if (requestedCard != null) {
+            Console.print("Found a card! Adding " + requestedCard.toString() + " to hand.");
+            takeFromThisHand[allRanks.get(userAsk)] = null;
+
+            if (addToThisHand[allRanks.get(userAsk)] != null) {
+
+                Console.print("Removing cards "
+                        + requestedCard.toString()
+                        + " and "
+                        + addToThisHand[allRanks.get(userAsk)].toString()
+                        + ".");
+
+                addToThisHand[allRanks.get(userAsk)] = null;
+                addBookCountDecreaseCardTotal(isPlayersTurn);
+
+            } else {
+
+                addToThisHand[allRanks.get(userAsk)] = requestedCard;
+                increaseTotalCards(isPlayersTurn);
+
+            }
+        }
+
+        return requestedCard != null;
+    }
+
+
+    private void playerTurn() {
+
+        boolean validCardAsked = false;
+
+        printSortedHand();
+
+        if (playerTotalCards == 0) {
+            Card newCard = deck.dealCard();
+            int newCardIndex = newCard.getValue().getValue() - 1;
+            Console.print("Adding " + newCard.toString() + " to the player's hand.");
+            playerBookCheck[newCardIndex] = newCard;
+            incrementPlayersCards();
+        }
+
+        while (!validCardAsked) {
+            String cardAskedFor = startPlayerTurn();
+            checkingOpponentHand();
+            if (checkHandForCard(playerBookCheck, cardAskedFor)) {
+                if (!addAsktoHand(opponentBookCheck, playerBookCheck, cardAskedFor, true)) {
+                    Console.print("No cards of that number found, sorry!\nGO FISH!");
+                    goFish(playerBookCheck, true);
+                }
+                validCardAsked = true;
+            } else {
+                Console.print("You don't have that card! Try again...");
+            }
+        }
+
+        checkPlayerBook();
+        endGameCheck = endGame();
+        endCheck(true);
+    }
+
+    private void checkingOpponentHand() {
+        Console.print("Checking opponent's hand...");
+        Console.pause(250, " . ", 5);
+    }
+
+    private boolean checkHandForCard(Card[] cards, String string) {
+        return cards[allRanks.get(string)] != null;
+    }
+
+    private void checkPlayerBook() {
+        Console.print("\nChecking for books... ");
+        Console.pause(350, " . ", 5);
+        Console.print("You have " + playerBook + " book(s).\n");
+    }
+
+    private void opponentTurn() {
+        printSortedHand();
+        opponentAsk();
+        endGameCheck = endGame();
+        endCheck(false);
+    }
+
+    private void opponentAsk() {
+
+        Console.print("Opponent's turn...\n");
+        Random random = new Random();
+
+        if (opponentTotalCards == 0) {
+            Card newCard = deck.dealCard();
+            int newCardIndex = newCard.getValue().getValue() - 1;
+            Console.print("Adding " + newCard.toString() + " to the owner's hand.");
+            opponentBookCheck[newCardIndex] = newCard;
+            incrementOpponentCards();
+        }
+
+        int result = random.nextInt(opponentTotalCards);
+
+        int counter = 0;
+        Card randomCard = null;
+
+        for (int i = 0; i < opponentBookCheck.length; i++) {
+            if (opponentBookCheck[i] != null) {
+                counter++;
+                randomCard = opponentBookCheck[i];
+
+                if (counter >= result) {
+                    break;
+                }
+            }
+        }
+
+        String opponentAsk = getRankString(opponentBookCheck[randomCard.getValue().getValue()-1]);
+
+        Console.print("Opponent is asking for " + opponentAsk + "'s. \nSearching your hand...");
+        Console.pause(250, " . ", 5);
+
+        if (!addAsktoHand(playerBookCheck, opponentBookCheck, opponentAsk, false)) {
+            goFish(opponentBookCheck, false);
+        }
+    }
+
+    public void notGameOver(Card[] bookCheck) {
+        Console.print("The hand is empty! Adding a card...");
+        Card newCard = deck.dealCard();
+        bookCheck[newCard.getValue().getValue() - 1] = newCard ;
+
+    }
+
+    private void endCheck(boolean isPlayersTurn) {
+        if (endGameCheck) {
+            printResult();
+        } else {
+            if (isPlayersTurn && playerTotalCards == 0) {
+
+                notGameOver(playerBookCheck);
+                incrementPlayersCards();
+
+            } else if (opponentTotalCards == 0) {
+
+                notGameOver(opponentBookCheck);
+                incrementOpponentCards();
+            }
+
+            Console.print("+++++ End of Turn +++++\n\n");
+        }
+
+        Console.pause(350, " . ", 5);
+    }
+
+    private String getRankString(Card c) {
+        return c.getValue().getThirdvalue();
+    }
+
+    private void showRules() {
+
+        boolean validInput = false;
+
+        Console.print("Do you want to see the rules? Y or N");
+
+        while(!validInput) {
+            String userRuleSelect = Console.getStringInput().toLowerCase();
+
+            switch (userRuleSelect) {
+                case "y" :
+                    rules();
+                    validInput = true;
+                    break;
+                case "n":
+                    validInput = true;
+                    break;
+                default:
+                    Console.print("Invalid entry, try \'Y\' or \'N\'");
+                    break;
+            }
+        }
+    }
+
+    private void rules() {
+
+        Console.print("Go Fish a game for all ages!"
+                + "\nEach player starts with 7 cards and the object of the game "
+                + "\nis to collect books, which are pairs of the same card number/rank."
+                + "\nFor example, a Three of hearts and a Three of diamonds makes a book!"
+                + "\ngame ends when the pile of cards is empty or one player has more than 13 pairs."
+                + "\n\nEach round, the player will ask the opponent if they have a card, but the card"
+                + "\nthe player asks for must be in their hand!"
+                + "\nIf the opponent has the card, they have to give ALL the cards that match that card "
+                + "\nto the player asking. If the opponent doesn't have it, the player must \"go fish\"."
+                + "\nGo fish means you have to get 1 card from the pile (all the leftover cards)."
+                + "\nThe first player to empty their hand wins!"
+                + "\nGood luck! :) \n\n");
+
+        pressAnyKeyToContinue();
+    }
+
+    private void pressAnyKeyToContinue()
+    {
+        Console.print("Press Enter key to continue...");
+        try {
+            System.in.read();
+        } catch(Exception e) {
+
+            e.printStackTrace();}
+    }
+
+    private void printResult() {
+        if (opponentBook > playerBook) {
+            Console.print("Your opponent won! :( ");
+        } else if (opponentBook == playerBook) {
+            Console.print("It was a draw :|");
+        } else {
+            Console.print("Grats, you won! :)");
+        }
+    }
+
+    public void printSortedHand() {
+        Console.printInSameLine("Your hand: [");
+
+        boolean firstCard = true;
+
+        for (int i = 0; i < playerBookCheck.length; i++) {
+
+            if (playerBookCheck[i] != null) {
+                if (!firstCard) {
+                    Console.printInSameLine(", ");
+                }
+                Console.printInSameLine(playerBookCheck[i].toString());
+                firstCard = false;
+            }
+
+        }
+        Console.printInSameLine("]\n");
+    }
+
+    public int getPlayerBook() {
+        return playerBook;
+    }
+
+    public void setPlayerBook(int playerBook) {
+        this.playerBook = playerBook;
+    }
+
+    public int getOpponentBook() {
+        return opponentBook;
+    }
+
+    public void setOpponentBook(int opponentBook) {
+        this.opponentBook = opponentBook;
+    }
+
+    public int getPlayerTotalCards() {
+        return playerTotalCards;
+    }
+
+    public void setPlayerTotalCards(int playerTotalCards) {
+        this.playerTotalCards = playerTotalCards;
+    }
+
+    public int getOpponentTotalCards() {
+        return opponentTotalCards;
+    }
+
+    public void setOpponentTotalCards(int opponentTotalCards) {
+        this.opponentTotalCards = opponentTotalCards;
+    }
+
+    public void incrementPlayersBook() {
+        setPlayerBook(getPlayerBook() + 1);
+    }
+
+    public void incrementOpponentBook() {
+        setOpponentBook(getOpponentBook() + 1);
+    }
+
+    public void decrementPlayersCards() {
+        setPlayerTotalCards(getPlayerTotalCards() - 1);
+    }
+
+    public void decrementOpponentCards() {
+        setOpponentTotalCards(getOpponentTotalCards() - 1);
+    }
+
+    public void incrementPlayersCards() {
+        setPlayerTotalCards(getPlayerTotalCards() + 1);
+    }
+
+    public void incrementOpponentCards() {
+        setOpponentTotalCards(getOpponentTotalCards() + 1);
+    }
+
+
+    public void playerTurnTrue() {
+        incrementPlayersBook();
+        decrementPlayersCards();
+        decrementPlayersCards();
+    }
+
+    public void opponentTurnTrue(){
+        incrementOpponentBook();
+        decrementOpponentCards();
+        decrementOpponentCards();
+    }
+}

src/main/java/io/zipcoder/casino/game/cardgames/individualcardgames/HiLo.java

@@ -0,0 +1,283 @@
+
+        package io.zipcoder.casino.game.cardgames.individualcardgames;
+
+        import io.zipcoder.casino.game.Player;
+        import io.zipcoder.casino.game.cardgames.cardutilities.Card;
+        import io.zipcoder.casino.game.interfaces.Gamble;
+        import io.zipcoder.casino.Console;
+
+        import java.util.ArrayList;
+        import java.util.Scanner;
+
+        public class HiLo extends CardGame implements Gamble {
+
+    //Variables
+    Scanner in = new Scanner(System.in);
+
+    boolean gameon;
+
+    boolean cont;
+
+    boolean enoughmoney;
+
+    private Player player;
+
+    //-----------Some Verbiage--------------
+
+    String intro = "Welcome to HiLo!" + System.lineSeparator() + "Please place a bet.";
+
+    //In Next Steps Matrix
+
+    String nextsteps = "Feeling lucky today? Try your luck again then! (Yes or No)";
+
+    String outro = "Thanks for playing!";
+
+    String invalid = "That is not a valid response. Try again.";
+
+    String assout = "You're out of cash! Come back with deeper pockets!!";
+
+    //In Bet method
+
+    String notenough = "You do not have the amount specified. Would you like to place another bet or return to the main menu? (Type \"Bet\" or \"Quit\"";
+
+    String ohwell = "Better Luck Next Time!";
+
+
+    //Constructors
+    public HiLo(Player player) {
+        this.player = player;
+        gameon = true;
+        cont = false;
+    }
+
+//Main game Method
+
+    @Override
+    public void play() {
+
+        while (gameon) {
+            // place a bet
+            Console.print(intro);
+            int betbet = in.nextInt();
+
+            while (!enoughmoney) {
+                bet(betbet); }
+
+            //check to make sure deck has 52 cards
+            if (deck.getDeck().isEmpty()) {
+                deck.refreshDeck();
+            }
+
+            //deal a card to the player and house
+            getPlayerHand().add(deck.dealCard());
+            getHouseHand().add(deck.dealCard());
+
+            //prompt for high or low input
+            System.out.println("You have drawn a " + getPlayerHand().get(0).toString() + " would you like to bet High or Low?");
+            String input = in.next();
+
+            //evaluate for Win or Loss
+            int playerCard = (getPlayerHand().get(0).getValue().ordinal());
+            int dealerCard = (getHouseHand().get(0).getValue().ordinal());
+            winlossmatrix(input, playerCard, dealerCard, betbet);
+
+            //Next steps matrix
+            nextstepsmatrix();
+        }
+    }
+
+//Logic and Extra Methods
+
+
+    @Override
+    public boolean endGame() {
+
+        return true;
+    }
+
+
+    @Override
+    public int bet(int bet) {
+        int bankroll = player.getBank();
+        if (!player.checkbet(bet)) {
+            Console.print(notenough);
+            String response = in.next();
+            if (response.equalsIgnoreCase("Bet")) { play(); }
+            else if (response.equalsIgnoreCase("Quit")) {
+                Console.print(ohwell);
+                enoughmoney = false;
+                gameon = false;
+            }
+        } else {
+            enoughmoney = true;}
+        return bet;
+    }
+
+
+
+
+    public void winlossmatrix(String nput, int theplayer, int dealer, int hedge) {
+        int winnings = 0;
+
+        if (nput.equalsIgnoreCase("high")){
+            if(theplayer > dealer) {
+                winnings = (int) Math.floor(highLogic(hedge, dealer));
+                win(player, winnings);
+                System.out.println("You've won! The dealer's card was " + getHouseHand().get(0).toString() + " and your new bank is " + player.getBank() + "!");
+            } else if (theplayer == dealer ){
+                System.out.println("Bad luck! You and the dealer drew the same card. Dealer had a " + getHouseHand().get(0).toString());
+            } else {
+                loss(player, hedge);
+                System.out.println("You've lost! The dealer's card was " + getHouseHand().get(0).toString() + ". Your new bank is " + player.getBank());
+                in.nextLine();
+            }
+        } else if (nput.equalsIgnoreCase("low")){
+            if(theplayer < dealer){
+                winnings = (int)Math.floor(lowLogic(hedge, dealer));
+                win(player, winnings);
+                System.out.println("You've won! The dealer's card was " + getHouseHand().get(0).toString() + " and your new bank is " + player.getBank() + "!");
+            } else if (theplayer == dealer ){
+                System.out.println("Bad luck! You and the dealer drew the same card. Dealer had a " + getHouseHand().get(0).toString());
+            } else {
+                loss(player, hedge);
+                System.out.println("You've lost! The dealer's card was " + getHouseHand().get(0).toString() + ". Your new bank is " + player.getBank());
+                in.nextLine();
+            }
+        }
+
+    }
+
+
+
+    public void  nextstepsmatrix () {
+        while (!cont) {
+            if (player.getBank() > 0) {
+                Console.print(nextsteps);
+                String again = in.next();
+                if (again.equalsIgnoreCase("yes")) {
+                    enoughmoney = false;
+                    ArrayList<Card> newPlayerHand = new ArrayList<>();
+                    ArrayList<Card> newHouseHand = new ArrayList<>();
+                    setPlayerHand(newPlayerHand);
+                    setHouseHand(newHouseHand);
+                    play();
+                } else if (again.equalsIgnoreCase("no")) {
+                    Console.printInSameLine(outro);
+                    enoughmoney = false;
+                    gameon = false;
+                    cont = true;
+                    break;
+                } else {
+                    Console.print(invalid);
+                }
+            } else {
+                Console.print(assout);
+                enoughmoney = false;
+                gameon = false;
+                break;
+            }
+        }
+    }
+
+
+
+
+    public static double highLogic(int bet, int dealerCard){
+        double sum = 0;
+
+        switch (dealerCard) {
+            case 1:
+                sum = bet;
+                return sum;
+            case 2:
+                sum = bet * 1.1;
+                return sum;
+            case 3:
+                sum = bet * 1.2;
+                return sum;
+            case 4:
+                sum = bet * 1.4;
+                return sum;
+            case 5:
+                sum = bet * 1.4;
+                return sum;
+            case 6:
+                sum = bet * 1.5;
+                return sum;
+            case 7:
+                sum = bet * 1.8;
+                return sum;
+            case 8:
+                sum = bet * 2;
+                return sum;
+            case 9:
+                sum = bet * 3;
+                return sum;
+            case 10:
+                sum = bet * 4;
+                return sum;
+            case 11:
+                sum = bet * 5;
+                return sum;
+            case 12:
+                sum = bet * 12;
+                return sum;
+            case 13:
+                sum = bet;
+                return sum;
+        }
+
+        return sum;
+    }
+
+    public static double lowLogic(int bet, int dealerCard){
+        double sum = 0;
+
+        switch (dealerCard) {
+            case 1:
+                sum = bet;
+                return sum;
+            case 2:
+                sum = bet * 12;
+                return sum;
+            case 3:
+                sum = bet * 5;
+                return sum;
+            case 4:
+                sum = bet * 3;
+                return sum;
+            case 5:
+                sum = bet * 3;
+                return sum;
+            case 6:
+                sum = bet * 2;
+                return sum;
+            case 7:
+                sum = bet * 1.8;
+                return sum;
+            case 8:
+                sum = bet * 1.5;
+                return sum;
+            case 9:
+                sum = bet * 1.4;
+                return sum;
+            case 10:
+                sum = bet * 1.3;
+                return sum;
+            case 11:
+                sum = bet * 1.2;
+                return sum;
+            case 12:
+                sum = bet * 1.1;
+                return sum;
+            case 13:
+                sum = bet;
+                return sum;
+        }
+
+        return sum;
+    }
+
+
+}
+

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

@@ -0,0 +1,184 @@
+
+package io.zipcoder.casino.game.chancegames;
+
+import io.zipcoder.casino.Console;
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.chancegames.chancegameutilities.RandomNumGen;
+import io.zipcoder.casino.game.chancegames.chancegameutilities.RouletteWheel;
+import io.zipcoder.casino.game.interfaces.Gamble;
+import io.zipcoder.casino.game.interfaces.Game;
+
+import java.util.*;
+
+public class Roulette implements Gamble, Game {
+
+    Player player;
+    private int numResult;
+    private String clrResult;
+    private int numGuess;
+    private String clrGuess;
+    private int betAmount;
+    private RouletteWheel wheel = new RouletteWheel();
+    private RandomNumGen random = new RandomNumGen();
+    boolean runner = true;
+
+
+
+    public Roulette(Player player) {
+        this.player = player;
+
+    }
+
+    public void play() {
+
+        while (runner == true) {
+
+            Console.print("Welcome to Zip Roulette: please enter a wager");
+            Console.print("Player Bank: " + player.getBank());
+            betAmount = Console.getIntegerInput();
+            int input = Console.printAndTakeInt("Great job! Enter 1 for to bet on a number; enter 2 to bet on a color");
+            playEntry(input);
+            win(betAmount);
+            runner = endGame();
+        }
+    }
+
+    @Override
+    public boolean endGame() {
+
+        String input = Console.printAndTakeString("Do you want to end the game or play again? Yes or No?");
+        if (input.equalsIgnoreCase("yes")) {
+            return runner = true;
+        } else {
+            return runner = false;
+        }
+    }
+
+
+    public void getResult(RandomNumGen random) {
+        Object[] keys = wheel.getWheel().keySet().toArray();
+        Object tempKey = keys[random.randomRoulette()];
+        numResult = (int) tempKey;
+        clrResult = wheel.getWheel().get(tempKey);
+        Console.print("\n****** " + numResult + " " + clrResult + " ******");
+    }
+
+    public void playEntry(int input) {
+        if (input == 1) {
+            numberEntry();
+        } else if (input == 2) {
+            colorEntry();
+        } else {
+            Console.print("Please try again");
+        }
+    }
+
+    public void numberEntry() {
+        numGuess = Console.printAndTakeInt("Please enter number between 0 and 36");
+        Console.pause(500, ". ",4);
+        getResult(random);
+        compareNumbers(numGuess);
+    }
+
+    public void colorEntry() {
+        clrGuess = Console.printAndTakeString("Please enter black, red or green");
+        Console.pause(500, ". ",4);
+        getResult(random);
+        compareBlckRd(clrGuess);
+
+
+    }
+
+    public boolean compareNumbers(int numGuess) {
+
+        if (numGuess == numResult) {
+            bet(5);
+            return true;
+        } else {
+            loss(betAmount);
+            betAmount = 0;
+            return false;}
+
+    }
+
+    public boolean compareBlckRd(String clrGuess) {
+
+        if(clrGuess.equalsIgnoreCase(clrResult)){
+            bet(2);
+            return true;
+        } else {
+            loss(betAmount);
+            betAmount = 0;
+            return false;}
+
+    }
+
+
+    @Override
+    public int bet(int betMultiplier) {
+
+        return betAmount *= betMultiplier;
+
+    }
+
+    public void win(int betAmount) {
+        player.setBank(player.getBank() + betAmount);
+    }
+
+
+    public void loss(int betAmount) {
+        player.setBank(player.getBank() - betAmount);
+
+    }
+
+
+    public void checkBet() {
+        if (betAmount > player.getBank()) {
+            Console.print("Not enough funds: enter another wager");
+
+        }
+    }
+
+    public int getNumResult() {
+        return numResult;
+    }
+
+    public String getClrResult() {
+        return clrResult;
+    }
+
+    public void setNumResult(int numResult) {
+        this.numResult = numResult;
+    }
+
+    public void setClrResult(String clrResult) {
+        this.clrResult = clrResult;
+    }
+
+    public int getNumGuess() {
+        return numGuess;
+    }
+
+    public String getClrGuess() {
+        return clrGuess;
+    }
+
+    public int getBetAmount() {
+        return betAmount;
+    }
+
+    public void setBetAmount(int betAmount) {
+        this.betAmount = betAmount;
+    }
+
+    public void setNumGuess(int numGuess) {
+        this.numGuess = numGuess;
+    }
+
+    public void setClrGuess(String clrGuess) {
+        this.clrGuess = clrGuess;
+    }
+
+    public boolean isRunner() { return runner; }
+}
+

src/main/java/io/zipcoder/casino/game/chancegames/Slots.java

@@ -0,0 +1,88 @@
+package io.zipcoder.casino.game.chancegames;
+
+import io.zipcoder.casino.Console;
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.interfaces.Gamble;
+import io.zipcoder.casino.game.interfaces.Game;
+
+public class Slots implements Game, Gamble {
+
+    Player player;
+    private int slots[];
+    private int amount;
+
+    public Slots(Player player){
+        this.player = player;
+        slots = new int[3];
+    }
+
+    public void play(){
+        amount = Console.printAndTakeInt("Enter the bet amount you want to bet");
+
+        if(player.checkbet(amount)){
+            spin();
+        }
+        else{
+            String choice = Console.printAndTakeString("You have insufficient balance.\nEnter \"yes\" to continue with some new amount or \"no\" to exit the game");
+            if(choice.equals("yes"))
+                play();
+        }
+
+    }
+
+    @Override
+    public boolean endGame() {
+        return false;
+    }
+
+    public void result(){
+        int endAmount = bet(amount);
+
+        if(endAmount > amount)
+            win(player, endAmount);
+        else
+            loss(player, endAmount);
+        Console.print("Amount in your Bank : " + player.getBank());
+    }
+
+
+    public void spin() {
+
+            for (int i = 0; i < this.slots.length; i++)
+                this.slots[i] = (int)(Math.random() * 7 + 1);
+            Console.print(slots[0],slots[1], slots[2]);
+
+        result();
+
+    }
+
+
+
+    @Override
+    public int bet(int initialAmount) {
+        int returnBet = checkMatching(initialAmount);
+
+        if(returnBet > initialAmount)
+            Console.print("Congrats!! You won");
+        else
+            Console.print("YOu Lost!!");
+        return returnBet;
+    }
+
+    public int checkMatching(int initialAmount){
+        if(slots[0] == slots[1] && slots[1] == slots[2])
+            return initialAmount * 3;
+        else if(slots[0] == slots[1] || slots[1] == slots[2] || slots[2] == slots[0])
+            return initialAmount * 2;
+        else
+            return initialAmount;
+    }
+
+    public int[] getSlots() {
+        return this.slots;
+    }
+
+    public void setSlots(int[] slots) {
+        this.slots = slots;
+    }
+}

src/main/java/io/zipcoder/casino/game/chancegames/chancegameutilities/RandomNumGen.java

@@ -0,0 +1,16 @@
+package io.zipcoder.casino.game.chancegames.chancegameutilities;
+
+import java.util.Random;
+
+public class RandomNumGen {
+Random random;
+
+    public RandomNumGen() {
+        random = new Random();
+    }
+
+
+    public int randomRoulette() {
+        return random.nextInt(37);
+    }
+}

src/main/java/io/zipcoder/casino/game/chancegames/chancegameutilities/RouletteWheel.java

@@ -0,0 +1,64 @@
+package io.zipcoder.casino.game.chancegames.chancegameutilities;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RouletteWheel {
+    private final Map<Integer, String> wheel;
+
+
+
+    public RouletteWheel() {
+        wheel = new HashMap<>();
+        wheel.put(0, "Green");
+        wheel.put(1, "Red");
+        wheel.put(2, "Black");
+        wheel.put(3, "Red");
+        wheel.put(4, "Black");
+        wheel.put(5, "Red");
+        wheel.put(6, "Black");
+        wheel.put(7, "Red");
+        wheel.put(8, "Black");
+        wheel.put(9, "Red");
+        wheel.put(10, "Black");
+        wheel.put(11, "Red");
+        wheel.put(12, "Black");
+        wheel.put(13, "Red");
+        wheel.put(14, "Black");
+        wheel.put(15, "Red");
+        wheel.put(16, "Black");
+        wheel.put(17, "Red");
+        wheel.put(18, "Black");
+        wheel.put(19, "Red");
+        wheel.put(20, "Black");
+        wheel.put(21, "Red");
+        wheel.put(22, "Black");
+        wheel.put(23, "Red");
+        wheel.put(24, "Black");
+        wheel.put(25, "Red");
+        wheel.put(26, "Black");
+        wheel.put(27, "Red");
+        wheel.put(28, "Black");
+        wheel.put(29, "Black");
+        wheel.put(30, "Red");
+        wheel.put(31, "Black");
+        wheel.put(32, "Red");
+        wheel.put(33, "Black");
+        wheel.put(34, "Black");
+        wheel.put(35, "Black");
+        wheel.put(36, "Red");
+
+    }
+
+    public RouletteWheel(Map<Integer, String> wheel) {
+        this.wheel = wheel;
+    }
+
+    public Map<Integer, String> getWheel() {
+        return wheel;
+    }
+
+    public int getWheelSize() {
+       return wheel.size();
+    }
+}

src/main/java/io/zipcoder/casino/game/dicegames/diceutilities/Dice.java

@@ -0,0 +1,32 @@
+package io.zipcoder.casino.game.dicegames.diceutilities;
+
+import java.util.Random;
+
+public class Dice {
+
+    RandomDice randomDice;
+    private int numOfDice;
+
+    public Dice(int numOfDice){
+        this.numOfDice = numOfDice;
+        randomDice = new RandomDice();
+    }
+
+    public void setRandomDice(RandomDice randomDice) {
+        this.randomDice = randomDice;
+    }
+
+    public int tossAndSum() {
+
+        int sumRoll = 0;
+
+        for (int i = 0; i < numOfDice; i++) {
+            sumRoll += randomDice.randDice();
+        }
+        return sumRoll;
+    }
+
+    public int getNumOfDice() {
+        return numOfDice;
+    }
+}

src/main/java/io/zipcoder/casino/game/dicegames/diceutilities/RandomDice.java

@@ -0,0 +1,16 @@
+package io.zipcoder.casino.game.dicegames.diceutilities;
+
+import java.util.Random;
+
+public class RandomDice {
+
+    public int randDice()
+
+    {
+        int sum = 0;
+        Random rand = new Random();
+        sum = rand.nextInt(6) + 1;
+
+        return sum;
+    }
+}

src/main/java/io/zipcoder/casino/game/dicegames/individualdicegames/Craps.java

@@ -0,0 +1,165 @@
+package io.zipcoder.casino.game.dicegames.individualdicegames;
+
+import io.zipcoder.casino.Console;
+import io.zipcoder.casino.game.dicegames.diceutilities.Dice;
+import io.zipcoder.casino.game.interfaces.Gamble;
+import io.zipcoder.casino.game.Player;
+
+public class Craps extends DiceGame implements Gamble {
+
+    private Player player;
+    private Dice pairOfDice;
+    private int numOfRolls;
+    public boolean win;
+    public boolean continueGame;
+    private int amount;
+    public int rollOne;
+    public int rollTwo;
+
+
+    public Craps(Player player){
+        this.player = player;
+        numOfRolls = 0;
+        pairOfDice = createDice(2);
+        rollOne = 0;
+        rollTwo = 0;
+    }
+
+    public int getNumOfRolls(){
+        return numOfRolls;
+    }
+
+    public Dice getPairOfDice() {
+        return pairOfDice;
+    }
+
+    public int roll(){
+        int sum = pairOfDice.tossAndSum();
+        return sum;
+    }
+
+    @Override
+    public Dice createDice(int numberOfDice) {
+        Dice crapsDice = new Dice(numberOfDice);
+        return crapsDice;
+    }
+
+    @Override
+    public int bet(int initialAmount) {
+        int returnBet = initialAmount;
+
+        if (win){
+            returnBet *= 2;
+            win(player, returnBet);
+        } else if (!win) {
+            loss(player, returnBet);
+        }
+        return -1;
+    }
+
+    @Override
+    public void play() {
+
+        continueGame = true;
+
+        Console.print("  _______________________________________________________________ ___________________    _____ __________  _________\n" +
+                " /   _____/\\__    ___/\\______   \\_   _____/\\_   _____/\\__    ___/ \\_   ___ \\______   \\  /  _  \\\\______   \\/   _____/\n" +
+                " \\_____  \\   |    |    |       _/|    __)_  |    __)_   |    |    /    \\  \\/|       _/ /  /_\\  \\|     ___/\\_____  \\ \n" +
+                " /        \\  |    |    |    |   \\|        \\ |        \\  |    |    \\     \\___|    |   \\/    |    \\    |    /        \\\n" +
+                "/_______  /  |____|    |____|_  /_______  //_______  /  |____|     \\______  /____|_  /\\____|__  /____|   /_______  /\n" +
+                "        \\/                    \\/        \\/         \\/                     \\/       \\/         \\/                 \\/");
+
+        Console.print("               (( _______\n" +
+                "     _______     /\\O    O\\\n" +
+                "    /O     /\\   /  \\      \\\n" +
+                "   /   O  /O \\ / O  \\O____O\\ ))\n" +
+                "((/_____O/    \\\\    /O     /\n" +
+                "  \\O    O\\    / \\  /   O  /\n" +
+                "   \\O    O\\ O/   \\/_____O/\n" +
+                "    \\O____O\\/ ))          ))\n" +
+                "  ((");
+
+        while(continueGame) {
+            Console.print("Player Bank: " + "$" + player.getBank());
+            Console.print("Enter the amount you want to bet");
+            amount = Console.getIntegerInput();
+            Console.print("\n");
+
+            if (player.checkbet(amount)) {
+                runGame();
+            } else {
+                Console.print("You have insufficient funds.\nEnter \"yes\" to continue with a new bet or \"no\" to exit the game");
+                String choice = Console.getStringInput();
+                if (choice.equals("yes")) {
+                    continue;
+                } else if (choice.equals("no")) {
+                    continueGame = false;
+                    break;
+                }
+            }
+            continueGame = endGame();
+        }
+    }
+
+    public void runGame() {
+        firstRoll();
+        bet(amount);
+    }
+
+    public boolean isWin() {
+        return win;
+    }
+
+    public void firstRoll() {
+
+        rollOne = roll();
+        if (rollOne == 7 || rollOne == 11) {
+            Console.print("Your first roll is: " + rollOne);
+            Console.print("You Win!! (⌐■_■)");
+            win = true;
+
+        } else if (rollOne == 2 || rollOne == 3 || rollOne == 12) {
+            Console.print("Your first roll is: " + rollOne);
+            Console.print("You Lose ಠ_ಠ");
+            win = false;
+        } else{
+            Console.print("Your first roll is: " + rollOne + ", Rolling again.");
+            Console.pause(500/2, " ⚀ ");
+            Console.pause(500/2, " ⚁ ");
+            Console.pause(500/2, " ⚂ ");
+            Console.pause(500/2, " ⚃ ");
+            Console.pause(500/2, " ⚄ ");
+            Console.pause(500/2, " ⚅ ");
+            secondRoll();}
+    }
+
+        public void secondRoll() {
+            rollTwo = roll();
+
+            if (rollTwo == rollOne) {
+                Console.print("Your second roll is your point number");
+                Console.print("You Win!! (⌐■_■)");
+                win = true;
+            } else  {
+                Console.print("\nYour second roll is: " + rollTwo);
+                Console.print("You Lose ಠ_ಠ");
+                win = false;
+            }
+        }
+
+    @Override
+    public boolean endGame() {
+        Console.print("Do you want to continue Street Craps, Yes or No?");
+        String input = Console.getStringInput();
+
+        if (input.equalsIgnoreCase("yes")) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+}
+
+
+

src/main/java/io/zipcoder/casino/game/dicegames/individualdicegames/DiceGame.java

@@ -0,0 +1,10 @@
+package io.zipcoder.casino.game.dicegames.individualdicegames;
+
+import io.zipcoder.casino.game.dicegames.diceutilities.Dice;
+import io.zipcoder.casino.game.interfaces.Gamble;
+import io.zipcoder.casino.game.interfaces.Game;
+
+public abstract class DiceGame implements Game, Gamble {
+
+    public abstract Dice createDice(int numberOfDice);
+}

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

@@ -0,0 +1,17 @@
+package io.zipcoder.casino.game.interfaces;
+
+import io.zipcoder.casino.game.Player;
+
+public interface Gamble {
+
+    int bet(int initialAmount);
+
+    default void win(Player player, int winnings) {
+        player.setBank(player.getBank() + winnings);
+    }
+
+    default void loss(Player player, int losses) {
+        player.setBank(player.getBank() - losses);
+    }
+
+}

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

@@ -0,0 +1,7 @@
+package io.zipcoder.casino.game.interfaces;
+
+public interface Game {
+
+    void play();
+    boolean endGame();
+}

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

@@ -0,0 +1,262 @@
+package io.zipcoder.casino;
+
+
+
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.cardgames.cardutilities.Card;
+import io.zipcoder.casino.game.cardgames.cardutilities.Deck;
+import io.zipcoder.casino.game.cardgames.cardutilities.Rank;
+import io.zipcoder.casino.game.cardgames.cardutilities.Suit;
+import io.zipcoder.casino.game.cardgames.individualcardgames.BlackJack;
+import org.junit.*;
+public class BlackJackTest {
+    private DeckMock deck;
+    @Before
+    public void initialize(){
+        deck = new DeckMock();
+    }
+
+
+@Test
+public void clearHandsTest(){
+    //Given
+    PlayerMock playerMock = new PlayerMock();
+    BlackJack blackJack = new BlackJack(playerMock);
+    blackJack.playerTotal = 21;
+    Integer actual = 0;
+    //When
+    blackJack.clearHands();
+    //Then
+    Assert.assertEquals(blackJack.playerTotal, actual);
+}
+    @Test
+    public void endGameTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.playerTotal = 21;
+        //When
+        boolean actual = blackJack.endGame();
+        //Then
+        Assert.assertFalse(actual);
+    }
+
+
+@Test
+public void introTest(){
+    //Given
+    PlayerMock playerMock = new PlayerMock();
+    BlackJack blackJack = new BlackJack(playerMock);
+    String expected = "♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣\n +" +
+            "♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦ WELCOME TO BLACKJACK ♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♠♥♦♣\n" +
+            "♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣♠♥♦♣\n";
+    //When
+    String actual = blackJack.intro();
+    //Then
+    Assert.assertEquals(expected, actual);
+
+}
+
+@Test
+public void dealHouseTest(){
+    //Given
+    PlayerMock playerMock = new PlayerMock();
+    BlackJack blackJack = new BlackJack(playerMock);
+    boolean expected = true;
+    //When
+    boolean actual = blackJack.dealHouse();
+    //Then
+    Assert.assertTrue(actual);
+
+}
+
+@Test
+public void handSumTest(){
+    //Given
+    PlayerMock playerMock = new PlayerMock();
+    BlackJack blackJack = new BlackJack(playerMock);
+    blackJack.getPlayerHand().add(new CardMock());
+    blackJack.getHouseHand().add(new CardMock());
+    int expected = 11;
+    //When
+    blackJack.handSum();
+    int actual = blackJack.playerTotal;
+    //Then
+    Assert.assertEquals(expected,actual);
+
+
+}
+@Test
+public void doBlackjackTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        int stakes = 1000;
+        int expected = 12500;
+        //When
+        blackJack.doBlackjack(stakes);
+        int actual = playerMock.getBank() + stakes;
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public void winConditionsPlayerBustTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.playerTotal = 22;
+        int stakes = 1000;
+        int expected = 9000;
+        //When
+        blackJack.winConditions(stakes);
+        int actual = playerMock.getBank();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public void winConditionsHouseBustTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.playerTotal = 10;
+        blackJack.houseTotal = 22;
+        int stakes = 1000;
+        int expected = 11000;
+        //When
+        blackJack.winConditions(stakes);
+        int actual = playerMock.getBank();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public void winConditionsPlayerWinsTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.playerTotal = 20;
+        blackJack.houseTotal = 10;
+        int stakes = 1000;
+        int expected = 11000;
+        //When
+        blackJack.winConditions(stakes);
+        int actual = playerMock.getBank();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public void winConditionsHouseWinsTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.playerTotal = 10;
+        blackJack.houseTotal = 20;
+        int stakes = 1000;
+        int expected = 9000;
+        //When
+        blackJack.winConditions(stakes);
+        int actual = playerMock.getBank();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public void winConditionsPushTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.playerTotal = 10;
+        blackJack.houseTotal = 10;
+        int stakes = 1000;
+        int expected = 10000;
+        //When
+        blackJack.winConditions(stakes);
+        int actual = playerMock.getBank();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public void dealHouseWith21Test(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.houseTotal = 22;
+        boolean expected = true;
+        //When
+        boolean actual = blackJack.dealHouse();
+        //Then
+        Assert.assertTrue(actual);
+
+    }
+    @Test
+    public void dealSumPrintTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.houseTotal = 22;
+        boolean expected = true;
+        //When
+        boolean actual = blackJack.dealSumPrint();
+        //Then
+        Assert.assertTrue(actual);
+
+    }
+    @Test
+    public void dealSumFirstShowTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.getHouseHand().add(new CardMock());
+        blackJack.houseTotal = 22;
+        boolean expected = true;
+        //When
+        boolean actual = blackJack.dealSumFirstShow();
+        //Then
+        Assert.assertTrue(actual);
+
+    }
+    @Test
+    public void firstShownTest(){
+        //Given
+        PlayerMock playerMock = new PlayerMock();
+        BlackJack blackJack = new BlackJack(playerMock);
+        blackJack.houseTotal = 22;
+        blackJack.getHouseHand().add(new CardMock());
+        boolean expected = true;
+        //When
+        boolean actual = blackJack.firstShow();
+        //Then
+        Assert.assertTrue(actual);
+    }
+
+private class CardMock extends Card{
+    private CardMock() {
+        super(Suit.Spades, Rank.Ace);
+    }
+
+
+}
+    public class DeckMock extends Deck{
+        CardMock cardMock = new CardMock();
+        public DeckMock() {
+        }
+        @Override
+        public Card dealCard(){
+            return cardMock;
+
+        }
+
+    }
+
+    private class PlayerMock extends Player{
+
+        public PlayerMock() {
+            super("John", 10000);
+        }
+    }
+}
+

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

@@ -1,5 +0,0 @@
-package io.zipcoder.casino;
-
-
-public class CasinoTest {
-}

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

@@ -0,0 +1,167 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.dicegames.diceutilities.RandomDice;
+import io.zipcoder.casino.game.dicegames.individualdicegames.Craps;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CrapsTest {
+
+    Craps craps;
+    Player player;
+    mockRandom rand = new mockRandom();
+
+    public CrapsTest(){
+        player = new Player();
+        craps = new Craps(player);
+    }
+
+    private class mockRandom extends RandomDice {
+        public Integer rollNumber;
+
+        @Override
+        public int randDice(){
+            return rollNumber;
+        }
+    }
+
+    @Test
+    public void createDiceTest() {
+        craps.createDice(2);
+
+        int expected = 2;
+
+        int actual = craps.getPairOfDice().getNumOfDice();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void rollTest() {
+        craps.createDice(2);
+
+        boolean actualRoll = false;
+
+        int diceRoll = craps.roll();
+        if (diceRoll <= 12 && diceRoll >= 2){
+            actualRoll = true;
+        }
+        //then
+        System.out.println(diceRoll);
+        Assert.assertTrue(actualRoll);
+
+    }
+
+    @Test
+    public void getNumOfRollsTest() {
+        int expected = 0;
+
+        int actual = craps.getNumOfRolls();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void playTest() {
+    }
+
+    @Test
+    public void betTest() {
+        craps.win = true;
+        craps.bet(10);
+
+        int expected = player.getBank();
+        int actual = 10020;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void betTest1() {
+        craps.win = false;
+        craps.bet(10);
+
+        int expected = player.getBank();
+        int actual = 9990;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void firstRoll() {
+        craps.firstRoll();
+
+        Assert.assertTrue(craps.rollOne >= 2 && craps.rollOne <= 12);
+    }
+
+    @Test
+    public void firstRoll2(){
+        Craps craps = new Craps(player);
+
+        rand.rollNumber = 6;
+
+        craps.getPairOfDice().setRandomDice(rand);
+
+        craps.firstRoll();
+
+        Assert.assertFalse(craps.isWin());
+}
+
+    @Test
+    public void firstRoll3(){
+        Craps craps = new Craps(player);
+
+        rand.rollNumber = 1;
+
+        craps.getPairOfDice().setRandomDice(rand);
+
+        craps.firstRoll();
+
+        Assert.assertFalse(craps.isWin());
+    }
+
+    @Test
+    public void secondRoll() {
+        Craps craps = new Craps(player);
+
+        rand.rollNumber = 3;
+
+        craps.getPairOfDice().setRandomDice(rand);
+
+        craps.firstRoll();
+
+        Assert.assertTrue(craps.isWin());
+    }
+
+    @Test
+    public void secondRoll2() {
+        Craps craps = new Craps(player);
+
+        rand.rollNumber = 4;
+
+        craps.getPairOfDice().setRandomDice(rand);
+
+        craps.firstRoll();
+
+        Assert.assertTrue(craps.isWin());
+    }
+
+
+
+    @Test
+    public void endGameTest() {
+        craps.continueGame = true;
+        Assert.assertTrue("yes", true);
+    }
+
+    @Test
+    public void endGameTest2() {
+        craps.continueGame = false;
+        Assert.assertTrue("no", true);
+    }
+
+}
+

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

@@ -0,0 +1,22 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.dicegames.diceutilities.Dice;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DiceTest {
+
+    @Test
+    public void DiceTest1(){
+
+        Dice dice = new Dice(2);
+
+        boolean actual = false;
+        int roll = dice.tossAndSum();
+        if (roll <= 12 && roll >= 1){
+            actual = true;
+        }
+        System.out.println(roll);
+        Assert.assertTrue(actual);
+    }
+}

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

@@ -0,0 +1,53 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.Player;
+import org.junit.*;
+
+public class PlayerTest {
+
+    @Test
+    public  void playerNameTest(){
+        //Given
+        Player player = new Player("Bob", 5000);
+        String expected = "John";
+        //When
+        player.setName("John");
+        String actual = player.getName();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public  void playerBankTest(){
+        //Given
+        Player player = new Player("Bob", 5000);
+        Integer expected = 10000;
+        //When
+        player.setBank(10000);
+        Integer actual = player.getBank();
+        //Then
+        Assert.assertEquals(expected,actual);
+
+    }
+    @Test
+    public  void playerStateTest(){
+        //Given
+        Player player = new Player("Bob", 5000);
+        String expected = "Highroller Bob has $5,000";
+        //When
+        String actual = player.getState();
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void playerDefaultTest(){
+        //Given
+        Player player = new Player();
+        String expected = "Highroller Default has $10,000";
+        //When
+        String actual = player.getState();
+        //Then
+        Assert.assertEquals(expected,actual);
+    }
+}

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

@@ -0,0 +1,28 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.chancegames.chancegameutilities.RandomNumGen;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RandomNumGenTest {
+
+    @Test
+    public void randomRouletteTest() {
+        RandomNumGen gen = new RandomNumGen();
+
+        int actual = gen.randomRoulette();
+
+        Assert.assertTrue(actual >= 0 && actual<= 37);
+    }
+
+    @Test
+    public void randomRouletteChangeTest() {
+        RandomNumGen gen = new RandomNumGen();
+
+        int first = gen.randomRoulette();
+        int second = gen.randomRoulette();
+
+        Assert.assertFalse(first == second);
+
+    }
+}

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

@@ -0,0 +1,179 @@
+
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.chancegames.chancegameutilities.RandomNumGen;
+import org.junit.Assert;
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.chancegames.Roulette;
+import org.junit.Before;
+import org.junit.Test;
+
+
+public class RouletteTest {
+    Player player;
+    MockRandom random;
+    Roulette test;
+
+    private class MockRandom extends RandomNumGen {
+        @Override
+        public int randomRoulette() {
+            return 1;
+        }
+    }
+
+    @Before
+    public void initialize() {
+        random = new MockRandom();
+        player = new Player();
+        test = new Roulette(player);
+        player.setBank(1000);
+    }
+
+    @Test
+    public void setGetNumResultTest() {
+
+        Roulette test = new Roulette(player);
+        test.setNumResult(1);
+
+        int expected = 1;
+        int actual = test.getNumResult();
+
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void setGetColorResultTest() {
+        String expected = "Red";
+        test.setClrResult("Red");
+        String actual = test.getClrResult();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void setGetNumGuessTest() {
+        int expected = 10;
+        test.setNumGuess(10);
+
+        int actual = test.getNumGuess();
+
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void setGetClrGuessTest() {
+        String expected = "Black";
+        test.setClrGuess("Black");
+
+        String actual = test.getClrGuess();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void setGetBetAmountTest() {
+        int expected = 100;
+        test.setBetAmount(100);
+
+        int actual = test.getBetAmount();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void compareNumbersTest01() {
+        test.setNumResult(10);
+
+        boolean actual = test.compareNumbers(10);
+
+        Assert.assertTrue(actual);
+
+    }
+
+    @Test
+    public void compareNumbersTest02() {
+        test.setNumResult(100);
+
+        boolean actual = test.compareNumbers(10);
+
+        Assert.assertFalse(actual);
+
+    }
+
+    @Test
+    public void compareBlckRd01() {
+        test.setClrResult("Black");
+
+        boolean actual = test.compareBlckRd("Black");
+
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void compareBlckRd02() {
+        test.setClrResult("Red");
+
+        boolean actual = test.compareBlckRd("Black");
+
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void betMultiplierTest() {
+        test.setBetAmount(5);
+        int expected = 500;
+        int actual = test.bet(100);
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void lossTest() {
+       int expected = 900;
+       test.loss(100);
+
+       int actual = player.getBank();
+
+       Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void winTest() {
+        int expected = 1100;
+
+        test.win(100);
+        int actual = player.getBank();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void getResultNumTest() {
+        test.getResult(random);
+        int expected = 1;
+
+        int actual = test.getNumResult();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void getResultClrTest02() {
+        test.getResult(random);
+        String expected = "Red";
+
+        String actual = test.getClrResult();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+    
+}

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

@@ -0,0 +1,36 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.chancegames.chancegameutilities.RouletteWheel;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RouletteWheelTest {
+
+    @Test
+    public void getWheelSizeTest() {
+
+    RouletteWheel wheelTest = new RouletteWheel();
+
+    int expected = 37;
+    int actual = wheelTest.getWheelSize();
+
+    Assert.assertEquals(expected, actual);
+}
+
+    @Test
+    public void getWheelTest() {
+        Map<Integer, String> test = new HashMap<>();
+        test.put(1, "black");
+        test.put(2, "red");
+        RouletteWheel wheelTest = new RouletteWheel(test);
+
+        int expected = test.size();
+        int actual = wheelTest.getWheelSize();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+}

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

@@ -0,0 +1,91 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.game.Player;
+import io.zipcoder.casino.game.chancegames.Slots;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SlotsTest {
+    Slots slots;
+    Player player;
+    int slotsArr[];
+    @Before
+    public void setup(){
+        player = new Player();
+        slots = new Slots(player);
+    }
+
+    @Test
+    public void testPlay(){
+
+    }
+
+    @Test
+    public void testSpin(){
+
+        slots.spin();
+
+       //System.out.println(slots.getSlots()[0]);
+
+        Assert.assertTrue(slots.getSlots()[0] > 0 && slots.getSlots()[0] < 8);
+    }
+
+    @Test
+    public void testCheckWin(){
+        slotsArr = new int[3];
+        //when all the three slots have same value
+        slotsArr[0] = 2;
+        slotsArr[1] = 2;
+        slotsArr[2] = 2;
+
+        slots.setSlots(slotsArr);
+        slots.bet(3);
+        int actual = slots.checkMatching(3);
+        int expectedAmount = 9;
+        Assert.assertEquals(expectedAmount, actual);
+    }
+
+    @Test
+    public void testCheckTwoMatching(){
+        slotsArr = new int[3];
+        //when all the three slots have same value
+        slotsArr[0] = 1;
+        slotsArr[1] = 1;
+        slotsArr[2] = 9;
+        slots.setSlots(slotsArr);
+        int actual = slots.checkMatching(2);
+        int expectedAmount = 4;
+        Assert.assertEquals(expectedAmount, actual);
+    }
+
+    @Test
+    public void testCheckNoMatching(){
+        slotsArr = new int[3];
+        //when all the three slots have same value
+        slotsArr[0] = 4;
+        slotsArr[1] = 6;
+        slotsArr[2] = 9;
+        slots.setSlots(slotsArr);
+        int actual = slots.checkMatching(2);
+        int expectedAmount = 2;
+        Assert.assertEquals(expectedAmount, actual);
+    }
+
+    @Test
+    public void testResult(){
+
+    }
+
+    @Test
+    public void testGetSlots(){
+        int slotsArr[] = slots.getSlots();
+        Assert.assertTrue(slotsArr.length == 3);
+    }
+
+    @Test
+    public void testEndGame(){
+
+    }
+
+}

src/test/java/io/zipcoder/casino/game/cardgames/individualcardgames/GoFishTest.java

@@ -0,0 +1,254 @@
+package io.zipcoder.casino.game.cardgames.individualcardgames;
+
+import io.zipcoder.casino.game.Player;
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+
+import org.junit.contrib.java.lang.system.SystemOutRule;
+
+public class GoFishTest {
+    Player player;
+    GoFish goFishTest;
+    public GoFishTest() {
+        player = new Player();
+        goFishTest = new GoFish(player);
+    }
+
+    /* Test Section : Setters and Getters */
+    @Test
+    public void testSetPlayerBookTrue() {
+
+        int expectedBookCount = 1;
+
+        goFishTest.setPlayerBook(1);
+
+        int actualBookCount = goFishTest.getPlayerBook();
+
+        Assert.assertEquals(expectedBookCount, actualBookCount);
+    }
+
+    @Test
+    public void testSetPlayerBookFalse() {
+        int expectedBookCount = 1;
+
+        goFishTest.setPlayerBook(18);
+
+        int actualBookCount = goFishTest.getPlayerBook();
+
+        Assert.assertNotEquals(expectedBookCount, actualBookCount);
+
+    }
+
+    @Test
+    public void testSetOpponentBookTrue() {
+
+        int expectedBookCount = 1;
+
+        goFishTest.setOpponentBook(1);
+
+        int actualBookCount = goFishTest.getOpponentBook();
+
+        Assert.assertEquals(expectedBookCount, actualBookCount);
+
+    }
+
+    @Test
+    public void testSetOpponentBookFalse() {
+
+        int expectedBookCount = 1;
+
+        goFishTest.setPlayerBook(18);
+
+        int actualBookCount = goFishTest.getPlayerBook();
+
+        Assert.assertNotEquals(expectedBookCount, actualBookCount);
+
+    }
+
+    @Test
+    public void testSetPlayerTotalCards() {
+        int expectedTotalCards = 7;
+
+        goFishTest.setPlayerTotalCards(7);
+
+        int actualCardCount = goFishTest.getPlayerTotalCards();
+
+        Assert.assertEquals(expectedTotalCards, actualCardCount);
+
+    }
+
+    @Test
+    public void testSetOpponentTotalCards() {
+        int expectedTotalCards = 7;
+
+        goFishTest.setOpponentTotalCards(7);
+
+        int actualCardCount = goFishTest.getOpponentTotalCards();
+
+        Assert.assertEquals(expectedTotalCards, actualCardCount);
+
+    }
+
+    @Test
+    public void testIncrementPlayersBookOnce() {
+
+        int expectedTotalBooks = 2;
+
+        goFishTest.setPlayerBook(1);
+        goFishTest.incrementPlayersBook();
+
+        int actualCardCount = goFishTest.getPlayerBook();
+
+        Assert.assertEquals(expectedTotalBooks, actualCardCount);
+
+    }
+
+    @Test
+    public void testIncrementPlayersBook10Times() {
+
+        int expectedTotalBooks = 10;
+
+        for (int i = 0; i < 10; i++) {
+            goFishTest.incrementPlayersBook();
+        }
+
+        int actualCardCount = goFishTest.getPlayerBook();
+
+        Assert.assertEquals(expectedTotalBooks, actualCardCount);
+
+    }
+
+    @Test
+    public void testIncrementOpponentBookOnce() {
+        int expectedTotalBooks = 2;
+
+        goFishTest.setOpponentBook(1);
+        goFishTest.incrementOpponentBook();
+
+        int actualCardCount = goFishTest.getOpponentBook();
+
+        Assert.assertEquals(expectedTotalBooks, actualCardCount);
+
+    }
+
+    @Test
+    public void testIncrementOpponentBook7Times() {
+
+        int expectedTotalBooks = 7;
+
+        for (int i = 0; i < 7; i++) {
+            goFishTest.incrementOpponentBook();
+        }
+
+        int actualCardCount = goFishTest.getOpponentBook();
+
+        Assert.assertEquals(expectedTotalBooks, actualCardCount);
+
+    }
+
+    @Test
+    public void testDecrementPlayerCards() {
+        int expectedTotalCards = 6;
+
+        goFishTest.setPlayerTotalCards(7);
+        goFishTest.decrementPlayersCards();
+
+        int actualCards = goFishTest.getPlayerTotalCards();
+
+        Assert.assertEquals(expectedTotalCards, actualCards);
+
+    }
+
+    @Test
+    public void testDecrementOpponentCards() {
+        int expectedTotalCards = 3;
+
+        goFishTest.setOpponentTotalCards(4);
+        goFishTest.decrementOpponentCards();
+
+        int actualCards = goFishTest.getOpponentTotalCards();
+
+        Assert.assertEquals(expectedTotalCards, actualCards);
+
+    }
+
+    @Test
+    public void testIncrementPlayersCards() {
+        int expectedTotalCards = 8;
+
+        goFishTest.setPlayerTotalCards(7);
+        goFishTest.incrementPlayersCards();
+
+        int actualCards = goFishTest.getPlayerTotalCards();
+
+        Assert.assertEquals(expectedTotalCards, actualCards);
+
+    }
+
+    @Test
+    public void testIncrementOpponentsCards() {
+        int expectedTotalCards = 5;
+
+        goFishTest.setOpponentTotalCards(4);
+        goFishTest.incrementOpponentCards();
+
+        int actualCards = goFishTest.getOpponentTotalCards();
+
+        Assert.assertEquals(expectedTotalCards, actualCards);
+
+    }
+
+    /* Combination Setters */
+
+    @Test
+    public void testPlayerTurnTrue() {
+        // Expect to increment players book by 1
+        // expect to decrement players cards by 2
+
+        int expectedCards = 3;
+        int expectedBooks = 1;
+
+        goFishTest.setPlayerTotalCards(5);
+
+        goFishTest.playerTurnTrue();
+
+        Assert.assertEquals(expectedCards, goFishTest.getPlayerTotalCards());
+        Assert.assertEquals(expectedBooks, goFishTest.getPlayerBook());
+
+    }
+
+    @Test
+    public void testOpponentTurnTrue() {
+
+        int expectedCards = 1;
+        int expectedBooks = 3;
+
+        goFishTest.setOpponentTotalCards(7);
+
+        for (int i = 0; i < 3; i++) {
+            goFishTest.opponentTurnTrue();
+        }
+
+        Assert.assertEquals(expectedCards, goFishTest.getOpponentTotalCards());
+        Assert.assertEquals(expectedBooks, goFishTest.getOpponentBook());
+
+    }
+
+    @Rule
+    public final SystemOutRule systemOutRule = new SystemOutRule().enableLog();
+
+    @Test
+    public void overrideProperty() {
+        System.out.print("hello world");
+        Assert.assertEquals("hello world", systemOutRule.getLog());
+    }
+
+    @Test
+    public void testPrintSortedHand() {
+
+        goFishTest.printSortedHand();
+
+
+    }
+}