diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 000000000..84a24410a
Binary files /dev/null and b/.DS_Store differ
diff --git a/.gitignore b/.gitignore
index 53c83987d..14d9a6ea5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@ local.properties
 .settings/
 .loadpath
 .recommenders
+.DS_Store
 
 # External tool builders
 .externalToolBuilders/
diff --git a/README.md b/README.md
index 14d017d9b..02c34dd94 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@
     * `Player` objects should be created upon input from a user.
   * `Game` interface
     * Contract which ensures that a class enforces some aspect of _playing_.
-  * `GamblingGame` interface
+  * `io.zipcoder.casino.GamblingGame` interface
     * Contract which ensures that a game enforces some aspect of _waging money_.
   * `GamblingPlayer` interface
     * Contract which ensures that a player has some ability to _wage money_.
diff --git a/src/Casino Structure.png b/src/Casino Structure.png
new file mode 100644
index 000000000..413f2b63f
Binary files /dev/null and b/src/Casino Structure.png differ
diff --git a/src/Casino Structure.puml b/src/Casino Structure.puml
new file mode 100644
index 000000000..cbe321f24
--- /dev/null
+++ b/src/Casino Structure.puml	
@@ -0,0 +1,199 @@
+@startuml
+'https://plantuml.com/class-diagram
+
+Game <|-- GamblingGame
+Game <|-- CardGame
+GamblingPlayer <|-- Player
+GamblingGame <|-- Blackjack
+GamblingGame <|-- DiceGame
+
+DiceGame <|-- Beetle
+DiceGame <|-- Craps
+CardGame <|-- Blackjack
+CardGame <|-- GoFish
+
+
+Display <|-- BeetleDisplay
+Display <|-- CrapsDisplay
+Display <|-- BlackjackDisplay
+Display <|-- GoFishDisplay
+
+
+'INTERFACE
+interface Game {
+Random
+Boolean gameState
+checkForWinner()
+setPlayer()
+}
+
+interface GamblingGame {
+acceptBetFrom()
+calculateReward()
+calculateLoss()
+}
+
+interface GamblingPlayer {
+placeBet()
+}
+
+
+'ABSTRACT CLASS
+abstract class CardGame{
+Stack decksOfCards
+ArrayList playersHand
+ArrayList dealersHand
+shuffleCards()
+dealCards(Int numberOfCards)
+skipDeal()
+
+}
+
+abstract class DiceGame {
+rollDice(numberOfDice)
+}
+
+
+'CLASS
+class Main{
+
+}
+
+class CasinoEngine {
+runCasino()
+}
+
+class Player {
+String name
+Double accountBalance
+getName()
+getAccountBalance()
+setAccountBalance()
+}
+
+class GoFish {
+HashMap <Player, Hand>
+HashMap <Player, NumberOfPairs>
+exchangeCard()
+getNumberOfPairs()
+setNumberOfPairs()
+}
+
+class GoFishDisplay {
+chooseAPlayerToAsk()
+chooseACardtoAskFor()
+playerHasCard()
+goFish()
+pairMade()
+
+}
+
+class Blackjack {
+HashMap <String cardFaceValue, Int CardPointValue>
+gotBlackJack(int betPlaced)
+standOrHit()
+}
+
+class BlackjackDisplay {
+dealersFirstCard()
+bustMessage(String whoBusted)
+dealersTotal()
+dealerStands()
+dealerHits()
+chooseStandOrHit()
+}
+
+class Craps {
+Boolean isNatural()
+Boolean isCraps()
+Boolean isPoint()
+analyzeComeOutRoll()
+analyzeFollowingRolls()
+'comeBet()
+'dontComeBet()
+'passBet()
+'dontPassBet()
+'fieldBet()
+'bigSixOrEightBet()
+getTypeOfBet()
+}
+
+class CrapsDisplay {
+rulesMenu()
+optionsMenu()
+shooterScores()
+shooterSevenedOut()
+push()
+oneRollBetLoss()
+onRollBetWin()
+natural()
+craps()
+shooterRolled()
+setTypeOfBet()
+comeOutRoll()
+
+}
+
+class Beetle {
+createNextImage()
+}
+
+class BeetleDisplay {
+drawBugHead()
+drawBugBody()
+drawBugLeg1()
+drawBugLeg2()
+drawBugLeg3()
+drawBugLeg4()
+playerBugComplete()
+opponentBugComplete()
+repeatRoll()
+bodyPartValue()
+}
+
+class PlayerWarehouse {
+playerGroup <password, Player>
+getPlayer()
+}
+
+class Console {
+Scanner input
+PrintStream output
+print()
+println()
+getStringInput()
+getDoubleInput()
+getLongInput()
+getIntegerInput()
+}
+
+class Display {
+String currentDisplay
+
+errorMessage()
+
+'casino messages
+welcomeMessage()
+gamesMenu()
+lowFundsWarning()
+zeroFundsWarning()
+
+'game messages
+rollResult()
+dealResult()
+youWin()
+youLose()
+doYouWantToBet()
+
+'new user messages
+userId()
+requestUserId()
+initialDeposit()
+
+'returning user messages
+welcomeBack()
+
+}
+
+
+@enduml
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/Beetle.java b/src/main/java/io/zipcoder/casino/Beetle.java
new file mode 100644
index 000000000..4b39af3f5
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Beetle.java
@@ -0,0 +1,155 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.utilities.Console;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+
+public class Beetle extends DiceGame{
+    Player player;
+    Random random = new Random();
+    Console console;
+    private InputStream in;
+    private PrintStream out;
+    BeetleDisplay display = new BeetleDisplay();
+    BeetleService service = new BeetleService();
+
+    private Double purse = 0.00;
+
+    public Beetle(Player player) {
+        this.player = player;
+        this.in = System.in;
+        this.out = System.out;
+        this.console = new Console(in, out);
+    }
+    
+// FACILITATOR
+    public void gameEngine() {
+        Boolean userHasNotWon = true;
+        Boolean opponentHasNotWon = true;
+        Boolean playersHaveNotTied = true;
+
+        display.displayWelcomeSequence(player, service.getCompleteBeetle());
+        tableMinimumDeposit();
+        display.currentPurse(getPurse());
+        while (playersHaveNotTied && userHasNotWon && opponentHasNotWon) {
+
+            //BET
+            Double userBetAmount = (console.getDoubleInput("how much would you like to bet?"));
+            acceptBetFromUser(userBetAmount);
+            Double opponentBet = opponentBet(userBetAmount);
+            setPurse(opponentBet);
+
+            //PLAY
+            Integer userRollValue = diceRollSum(1);
+            analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), userRollValue);
+            Integer opponentsRollValue = diceRollSum(1);
+            analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), opponentsRollValue);
+
+            //DISPLAY
+            display.gameBoard(userRollValue, service.getUsersBeetle(), opponentsRollValue, service.getOpponentsBeetle(), getPurse(),userBetAmount,opponentBet);
+
+            //ANALYZE
+            playersHaveNotTied = tieStateDoesNotExist(service.getUsersBeetle(), service.getOpponentsBeetle());
+            userHasNotWon = winningStateDoesNotExist(service.getUsersBeetle());
+            opponentHasNotWon = losingStateDoesNotExist(service.getOpponentsBeetle());
+        }
+        display.printAccountBalance(player.getWallet());
+    }
+
+    //GAME STATE
+    public Boolean tieStateDoesNotExist(String[][] usersBeetle, String[][] opponentsBeetle) {
+        if (Arrays.deepEquals(service.getCompleteBeetle(), usersBeetle) && Arrays.deepEquals(service.getCompleteBeetle(), opponentsBeetle)) {
+            display.bothBeetlesComplete();
+            player.setWallet(player.getCurrentBet());
+            System.out.println("Your bets were returned to your wallet.");
+            return false;
+        }
+        return true;
+    }
+
+    public Boolean winningStateDoesNotExist(String[][] usersBeetle) {
+        if (Arrays.deepEquals(service.getCompleteBeetle(), usersBeetle)) {
+            display.userBugIsComplete();
+            player.setWallet(purse);
+            player.setCurrentBet(0.00);
+            return false;
+        }
+        return true;
+    }
+
+    public Boolean losingStateDoesNotExist(String[][] opponentsBeetle) {
+        if (Arrays.deepEquals(service.getCompleteBeetle(), opponentsBeetle)) {
+            display.opponentsBugisComplete();
+            player.setWallet(-player.getCurrentBet());
+            player.setCurrentBet(0.00);
+            return false;
+        }
+        return true;
+    }
+
+    public void analyzeRoll(Set<Integer> rollSet, String[][] playersBeetle, Integer diceRoll){
+        if(!rollSet.contains(diceRoll)) {
+            service.updateBeetleDrawing(playersBeetle,diceRoll);
+            rollSet.add(diceRoll);
+        }
+    }
+
+    //BETTING
+    public void acceptBetFromUser(Double betAmount) {
+        player.makeBet(betAmount);
+        purse += betAmount;
+    }
+
+
+    public Double tableMinimumDeposit() {
+        acceptBetFromUser(1.00);
+        purse += 1;
+        return purse;
+    }
+
+    public Double opponentBet(Double userBet) {
+        Double opponentBet = 0.0;
+        if (service.getOpponentsRolls().size() >= service.getUsersRolls().size()) {
+            Double multiplier = random.nextDouble() + 0.5;
+            opponentBet = userBet * Math.round(multiplier * 100) / 100;
+        }
+        BigDecimal formattedBet = new BigDecimal(opponentBet).setScale(2, RoundingMode.HALF_UP);
+        opponentBet = formattedBet.doubleValue();
+        return opponentBet;
+    }
+
+    public Double calculateReward() {
+        double reward = purse - player.getCurrentBet();
+        return reward;
+    }
+
+    //PURSE
+    public Double calculateLoss() {
+        return player.getCurrentBet();
+    }
+
+    public Double getPurse() {
+        BigDecimal purseFormatted = new BigDecimal(purse).setScale(2, RoundingMode.HALF_UP);
+        purse = purseFormatted.doubleValue();
+        return purse;
+    }
+
+    public Double setPurse(Double betAmount) {
+        purse += betAmount;
+        return purse;
+    }
+
+    //UNUSED METHODS FROM ABSTRACT CLASS
+    public String endGame() {
+        return null;
+    }
+
+    public String startGame() {
+        return null;
+    }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/BeetleDisplay.java b/src/main/java/io/zipcoder/casino/BeetleDisplay.java
new file mode 100644
index 000000000..b99f4195c
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/BeetleDisplay.java
@@ -0,0 +1,130 @@
+package io.zipcoder.casino;
+
+public class BeetleDisplay extends Display {
+
+    String[][] beetle = new String[][]{{"\\","0","/"},
+            {"⎛","|","⎞"},
+            {"⎝","|","⎠"},
+            {"/","⏝","\\"}
+    };
+
+    public BeetleDisplay() {
+    }
+
+    public String welcome(String playerName) {
+        String message ="WELCOME TO BEETLE, "+ playerName +"!\n(1 dollar per player table minimum)\n";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+    public void rules() {
+        setPrintCurrentDisplay("\nDraw the beetle before your opponent and win big!\nThe rules are simple:\nEach side of the die corresponds to a part of the beetle." +
+                "\nIf you roll a number, you get to draw that part.\nIf you roll the same number again, you do not get to add to your beetle." +
+                "\nBetween each roll you will add to your wager.\nThe first person to draw a beetle keeps the purse." +
+                "\nIf both players complete their beetle on the same set of rolls the wagers are returned." +
+                "\n\nWhat to draw for each roll:" +
+                "\n1 - head\n2 - body\n3 - left front leg\n4 - right front leg\n5 - left back leg\n6 - right back leg\n\n");
+    }
+
+    public String userBugIsComplete() {
+        String message ="Your beetle is complete!\nYOU WIN!!!!";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public String opponentsBugisComplete() {
+        String message ="Your opponents beetle is complete.\nYou lose.";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public String bothBeetlesComplete() {
+        String message ="You both drew beetles. The game is a tie.";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public void usersRollResults(Integer usersRoll) {
+        setPrintCurrentDisplay("You rolled a " + usersRoll);
+    }
+
+    public void opponentsRollResults(Integer opponentsRoll) {
+        setPrintCurrentDisplay("Your opponent rolled a " + opponentsRoll);
+    }
+
+    public String repeatedRollResult() {
+        String message ="You already rolled that number.";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public String border() {
+        String message ="======================";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public String borderWithSpace() {
+        String message ="\n======================\n";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public void opponentHasPlacedABet(Double betAmount) {
+        setPrintCurrentDisplay("Opponent bet: $" + betAmount);
+    }
+    public void userHasPlacedABet(Double betAmount) {
+        setPrintCurrentDisplay("Your bet: $" + betAmount);
+    }
+
+    public void currentPurse(Double purse) {
+        setPrintCurrentDisplay("The purse is currently at $" + purse);
+    }
+
+    public String yourBeetleTitleLine() {
+        String message ="YOUR BEETLE";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public String opponentsBeetleTitleLine() {
+        String message ="OPPONENTS BEETLE";
+        setPrintCurrentDisplay(message);
+        return message;
+    }
+
+    public String[][] drawPlayerBeetle(String[][] playersBeetle){
+        for (int i = 0; i < playersBeetle.length; i++) {
+            for (int j = 0; j < playersBeetle[i].length; j++) {
+                System.out.print(playersBeetle[i][j] + " ");
+            }
+            System.out.println();
+        }
+        return playersBeetle;
+    }
+
+    public void displayWelcomeSequence(Player player, String[][] beetle) {
+        welcome(player.getName());
+        drawPlayerBeetle(beetle);
+        rules();
+    }
+
+    public void gameBoard(Integer userRollValue, String[][] usersBeetle, Integer opponentsRollValue,
+                          String[][] opponentsBeetle, Double purse, Double userBetAmount, Double opponentBet) {
+        System.out.println();
+        border();
+        userHasPlacedABet(userBetAmount);
+        opponentHasPlacedABet(opponentBet);
+        currentPurse(purse);
+        border();
+        yourBeetleTitleLine();
+        usersRollResults(userRollValue);
+        drawPlayerBeetle(usersBeetle);
+        border();
+        opponentsBeetleTitleLine();
+        opponentsRollResults(opponentsRollValue);
+        drawPlayerBeetle(opponentsBeetle);
+        border();
+        System.out.println();
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/BeetleService.java b/src/main/java/io/zipcoder/casino/BeetleService.java
new file mode 100644
index 000000000..0f484ad22
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/BeetleService.java
@@ -0,0 +1,94 @@
+package io.zipcoder.casino;
+import java.util.*;
+
+
+
+public class BeetleService {
+
+    private String[][] completeBeetle = new String[][]{{"\\","0","/"},
+            {"⎛","|","⎞"},
+            {"⎝","|","⎠"},
+            {"/","⏝","\\"}
+    };
+
+    private String[][] usersBeetle = new String[][]{{" "," "," "},
+            {" "," "," "},
+            {" "," "," "},
+            {" "," "," "}
+    };
+    private String[][] opponentsBeetle = new String[][]{{" "," "," "},
+            {" "," "," "},
+            {" "," "," "},
+            {" "," "," "}
+    };
+
+    private Set<Integer> usersRolls = new HashSet<Integer>();
+    private Set<Integer> opponentsRolls = new HashSet<Integer>();
+
+    public BeetleService() {
+
+    }
+
+    public void updateBeetleDrawing(String[][] playersBeetle, Integer diceRoll) {
+
+        switch (diceRoll) {
+            case 1:
+                playersBeetle[0][0] = completeBeetle[0][0];
+                break;
+
+            case 2:
+                playersBeetle[0][2] = completeBeetle[0][2];
+                break;
+
+            case 3:
+                playersBeetle[3][0] = completeBeetle[3][0];
+                break;
+
+            case 4:
+                playersBeetle[3][2] = completeBeetle[3][2];
+                break;
+
+            case 5:
+                playersBeetle[0][1] = completeBeetle[0][1];
+                playersBeetle[1][1] = completeBeetle[1][1];
+                playersBeetle[2][1] = completeBeetle[2][1];
+                break;
+
+            case 6:
+                playersBeetle[1][0] = completeBeetle[1][0];
+                playersBeetle[1][2] = completeBeetle[1][2];
+                playersBeetle[2][0] = completeBeetle[2][0];
+                playersBeetle[2][2] = completeBeetle[2][2];
+                playersBeetle[3][1] = completeBeetle[3][1];
+                break;
+
+            default:
+                System.out.println("something went wrong");
+                break;
+        }
+    }
+
+    public String[][] getCompleteBeetle(){
+        return completeBeetle;
+    }
+
+    public Set<Integer> getUsersRolls() {
+        return usersRolls;
+    }
+
+    public Set<Integer> getOpponentsRolls() {
+        return opponentsRolls;
+    }
+
+    public String[][] getUsersBeetle(){
+        return usersBeetle;
+    }
+
+    public String[][] getOpponentsBeetle(){
+        return opponentsBeetle;
+    }
+
+
+
+
+}
diff --git a/src/main/java/io/zipcoder/casino/BlackJackDisplay.java b/src/main/java/io/zipcoder/casino/BlackJackDisplay.java
new file mode 100644
index 000000000..5c92b7ceb
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/BlackJackDisplay.java
@@ -0,0 +1,100 @@
+package io.zipcoder.casino;
+
+public class BlackJackDisplay extends Display {
+
+    public void rules() {
+        setPrintCurrentDisplay("Your goal is to draw cards that total 21, or come closer to 21 than the dealer without going over"+
+
+                "\nMake a bet from $1 to all-in, receive your cards" +
+
+                "\nThe dealer will give you two blackjack cards and show one of his cards, decide if you want to double your bet" +
+
+                "\nYou can double your bet any time before you hit OR stand and split your bet if you get two cards of the same value." +
+
+                "\nConsider if you want to ‘hit’" +
+
+                "\nYou have an option to add more blackjack cards by choosing 'hit', but you lose automatically if your value of cards exceeds 21." +
+
+                "\nChoose 'stand' when you are ready to play your hand. learn the dealer’s hand" +
+
+                "\nThe dealer will reveal his hidden blackjack card and must always hit if they have 16 or lower. They will stop hitting if they have 17 or more." +
+
+                "\nYou win when the combined value of your cards is greater than that of the dealer."+
+
+                "\nYou lose if you have a lower score than the dealer, or if the total of your cards exceeds 21.");
+
+                //TIPS
+                /*"\nThe dealer and each player start with two cards. The dealer’s first card faces up, the second faces down."+
+
+                "\nFace cards each count as 10, Aces count as 1 or 11, all others count at face value."+
+
+                "\nAn Ace with any 10, Jack, Queen, or King is a “Blackjack.”:");*/
+    }
+
+    public void dealtHand(){
+
+        setPrintCurrentDisplay("You were dealt ");
+    }
+
+    public void hitOrStand(){
+
+        setCurrentDisplay("Do you want to hit or stand?");
+    }
+
+    public void dealerHit() {
+
+        setPrintCurrentDisplay("Your hand total is ");
+    }
+
+    public void playerHit(){
+
+        setPrintCurrentDisplay("You hit 21!");
+
+    }
+
+    public void dealerStand() {
+
+        setPrintCurrentDisplay("Do you want to hit or stand?");
+
+    }
+
+    public void bust(){
+
+        setPrintCurrentDisplay("You passed 21! Bust...");
+    }
+
+    public void dealerBust(){
+
+        setPrintCurrentDisplay("The dealer busted.");
+    }
+
+    public void wonGame(){
+
+        setPrintCurrentDisplay("You win");
+
+    }
+
+    public void lostGame(){
+
+        setPrintCurrentDisplay("You lost");
+    }
+
+    public void blackJack(){
+
+        setPrintCurrentDisplay("You got Black Jack!");
+
+    }
+
+    public void splitPairs() {
+
+        setPrintCurrentDisplay("Would you like to split pairs?");
+
+    }
+
+    public void doubleDown() {
+
+        setPrintCurrentDisplay("");
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java
new file mode 100644
index 000000000..975535be3
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/CardGame.java
@@ -0,0 +1,107 @@
+package io.zipcoder.casino;
+
+import java.util.*;
+
+public abstract class CardGame implements Game {
+
+    ArrayList<String> deck;
+    String[] ranks;
+    String[] suits;
+
+    ArrayList<String> playersHand;
+    ArrayList<String> dealersHand;
+
+    public CardGame() {
+
+        this.deck = new ArrayList<String>(52);
+        // Set zeroth element to null to indicate an unused element (only valid ranks from 1-13)
+        this.ranks = new String[]{null, "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"};
+        this.suits = new String[]{"Clubs", "Diamonds", "Hearts", "Spades"};
+
+        this.playersHand = new ArrayList<String>();
+        this.dealersHand = new ArrayList<String>();
+    }
+
+    // GETTERS
+    public ArrayList<String> getDeck() {
+        return this.deck;
+    }
+
+    public ArrayList<String> getPlayersHand() {
+        return this.playersHand;
+    }
+
+    public ArrayList<String> getDealersHand() {
+        return this.dealersHand;
+    }
+
+    // SETTERS
+    public void setPlayersHand(ArrayList<String> playersHand) {
+        this.playersHand = playersHand;
+    }
+
+    public void setDealersHand(ArrayList<String> dealersHand) {
+        this.dealersHand = dealersHand;
+    }
+
+    public void setDeck(ArrayList<String> deck) {this.deck = deck;}
+
+    // GAME SET-UP METHODS
+    public void createNewDeck() {
+        for (int suit = 0; suit <=3; suit++) {
+            for (int rank = 1; rank <= 13; rank++) {
+                this.deck.add(this.ranks[rank] + " of " + this.suits[suit]);
+            }
+        }
+    }
+
+    public void shuffleCards() {
+        ArrayList<String> temp = new ArrayList<String>(52);
+        while(!this.deck.isEmpty()) {
+            int randCard = (int) (Math.random() * deck.size());
+            temp.add(this.deck.get(randCard));
+            this.deck.remove(randCard);
+        }
+        this.deck = temp;
+    }
+
+    public void dealCards(int numberOfCards) {
+        int i = 0;
+        while (i < numberOfCards * 2) {
+            if (i < numberOfCards) {
+                this.playersHand.add(this.deck.get(i));
+            } else if (i >= numberOfCards) {
+                this.dealersHand.add(this.deck.get(i));
+            }
+            this.deck.remove(i);
+            i++;
+        }
+    }
+
+    // GET CARD INFO METHODS
+    public String getRankOnCard(String cardRankAndSuit) {
+        return cardRankAndSuit.substring(0, cardRankAndSuit.indexOf(" "));
+    }
+
+    public int getValueOfCard(String rankOnCard) {
+        int valueOfCard = 0;
+        if (rankOnCard.equals("Ace") || rankOnCard.equals("Jack") || rankOnCard.equals("King") || rankOnCard.equals("Queen")) {
+            valueOfCard = 10;
+        } else {
+            valueOfCard = Integer.parseInt(rankOnCard);
+        }
+
+        return valueOfCard;
+    }
+
+    public String displayPlayersHand(ArrayList<String> playersHand) {
+        Collections.sort(playersHand);
+        String playersHandOutput = "";
+        Iterator itr = playersHand.iterator();
+        while(itr.hasNext()) {
+            playersHandOutput += itr.next() + "\n";
+        }
+        return playersHandOutput;
+    }
+    
+}
diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java
index 86953f995..99fce7166 100644
--- a/src/main/java/io/zipcoder/casino/Casino.java
+++ b/src/main/java/io/zipcoder/casino/Casino.java
@@ -1,8 +1,131 @@
 package io.zipcoder.casino;
 
+import io.zipcoder.casino.utilities.Console;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Random;
+import java.util.Scanner;
 
 public class Casino {
-    public static void main(String[] args) {
-        // write your tests before you start
+
+    private Console c;
+    private Scanner s;
+    private Display d;
+    private InputStream in;
+    private PrintStream out;
+    private PlayerWarehouse pwh;
+    private Random rand;
+    private Boolean atLogin;
+    private Player currentPlayer;
+
+    public Casino() {
+        this.in = System.in;
+        this.out = System.out;
+        this.c = new Console(in, out);
+        this.d = new Display();
+        this.pwh = new PlayerWarehouse();
+        this.rand = new Random();
+        this.atLogin = true;
+        this.currentPlayer = new Player("TIMBERDOODLE72", 2.0);
+    }
+
+    public void run() {
+        d.printWelcomeMessage();
+        while (atLogin) {
+
+            d.setPrintCurrentDisplay("Welcome! Are you a new or returning user?");
+            Integer input1 = c.getIntegerInput("Press 1 for new, 2 for returning.");
+
+            if (input1 == 1) {
+
+                String newName = c.getStringInput("What's your name?");
+                String newPass = c.getStringInput("Make a password.");
+                Double newDeposit = c.getDoubleInput("Make an initial deposit.");
+                String newId;
+
+                while(true) {
+                    newId = "" + rand.nextInt(9999);
+                    if(pwh.validateUniquePlayer(newId)){
+                        break;
+                    }
+                }
+
+                d.setPrintCurrentDisplay("Your user ID is " + newId + ". Remember it!\n");
+                pwh.addNewPlayer(newId, new Player(newName, newDeposit), newPass);
+                d.setPrintCurrentDisplay("And you're all set!\n");
+
+            } else if (input1 == 2) {
+
+                while(true) {
+                    String oldId;
+                    oldId = c.getStringInput("What's your user ID?");
+                    String oldPass;
+                    oldPass = c.getStringInput("What's your password?");
+                    if(pwh.validateLoginCredentials(oldId, oldPass)){
+                        currentPlayer = pwh.getPlayer(oldId);
+                        break;
+                    }else{
+                        d.setPrintCurrentDisplay("Improper login credentials.\n");
+                        break;
+                    }
+                }
+
+            } else {
+                d.printErrorMessage();
+            }
+
+            if(currentPlayer.getName() != "TIMBERDOODLE72"){
+                break;
+            }
+        }
+        gamesMenu();
+    }
+
+    public void gamesMenu() {
+     d.printGamesMenu();
+     Integer gamesListedMenu = c.getIntegerInput(" ");
+     switch (gamesListedMenu) {
+         case 1:
+             System.out.println("Feature Under Construction");
+             break;
+
+         case 2:
+             Craps craps = new Craps(currentPlayer);
+             craps.crapsEngine();
+             break;
+
+         case 3:
+             Beetle beetle = new Beetle(currentPlayer);
+             beetle.gameEngine();
+             break;
+
+         case 4:
+             GoFishEngine goFish = new GoFishEngine(currentPlayer);
+             goFish.playGame();
+             break;
+         case 5:
+             d.printAccountBalance(currentPlayer.getWallet());
+             break;
+         case 6:
+             d.printDepositMessage();
+             Double deposit = c.getDoubleInput("");
+             currentPlayer.makeDeposit(deposit);
+             break;
+         case 7:
+             System.exit(0);
+         default:
+             System.out.println("Please enter a valid input.");
+             break;
+        }
+    if(currentPlayer.getWallet() == 0.00) {
+        d.printZeroFundsWarning();
+    }
+    else if (currentPlayer.getWallet() <= 50.00) {
+        d.printLowFundsWarning(currentPlayer.getWallet());
+    } else {
+        System.out.println("\n\n\nHaving fun? KEEP PLAYING!!");
+    }
+    gamesMenu();
     }
 }
diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java
new file mode 100644
index 000000000..0b019dc6e
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Craps.java
@@ -0,0 +1,596 @@
+package io.zipcoder.casino;
+
+import io.zipcoder.casino.utilities.Console;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Scanner;
+
+public class Craps extends DiceGame{
+
+    private Console c;
+    private Scanner s;
+    private Display d;
+    private InputStream in;
+    private PrintStream out;
+    private Player player;
+    private CrapsDisplay cd;
+
+    private Integer input;
+    private Integer innerInput;
+    private Integer furtherInput;
+    private Integer yetFurtherInput;
+
+    private Boolean[] outcomes;
+    private Boolean[] bets;
+    private Double[] betAmounts;
+    private Double lastBet;
+    private Integer point;
+
+    public Craps(Player player){
+        this.in = System.in;
+        this.out = System.out;
+        this.c = new Console(in, out);
+        this.d = new Display();
+        this.player = player;
+        this.cd = new CrapsDisplay();
+
+        this.input = 0;
+        this.innerInput = 0;
+        this.furtherInput = 0;
+
+        this.outcomes = new Boolean[21];
+        this.bets = new Boolean[21];
+        this.betAmounts = new Double[21];
+        this.lastBet = 0.0;
+
+        for(int i = 0; i < 21; i++){
+            outcomes[i] = false;
+        }
+
+        for(int i = 0; i < 21; i++){
+            bets[i] = false;
+        }
+
+        for(int i = 0; i < 21; i++){
+            betAmounts[i] = 0.0;
+        }
+    }
+
+    /* *** Here is the index of every ***
+       *** bet in the boolean arrays. ***
+    0- pass
+    1- don't pass
+    2- come
+    3- don't come
+    4- field
+    5- place bet 4
+    6- place bet 5
+    7- place bet 6
+    8- place bet 8
+    9- place bet 9
+    10- place bet 10
+    11- one-roll 7
+    12- one-roll craps
+    13- one-roll 6
+    14- one-roll 8
+    15- one-roll 4
+    16- one-roll 10
+    17- one-roll 3
+    18- one-roll 11
+    19- one-roll 2
+    20- one-roll 12 */
+
+    public void crapsEngine(){
+
+        this.initialRulesPrompt();
+
+        Boolean noPointSet = true;
+        Boolean firstRoll = true;
+        Boolean decisionUnmade = true;
+        Boolean notSevenedOut = true;
+
+        while(noPointSet){
+            while(decisionUnmade) {
+                cd.printSetTypeOfBet();
+                input = c.getIntegerInput("Type 0 for no bet, 2 for 'pass,' 3 for 'don't pass,' or 4 for a proposition.");
+                switch(input){
+                    case 1:
+                        cd.printRulesMenu1();
+                        cd.printRulesMenuMid();
+                        innerInput = c.getIntegerInput("Type 1 for yes, 2 for no.");
+                        switch(innerInput){
+                            case 1:
+                                cd.printRulesMenu2();
+                                break;
+                            case 2:
+                                break;
+                            default:
+                                cd.printErrorMessage();
+                                continue;
+                        }
+                        break;
+                    case 2:
+                        chooseBetAmountAndMakeBet(0);
+                        break;
+                    case 3:
+                        chooseBetAmountAndMakeBet(1);
+                        break;
+                    case 0:
+                        decisionUnmade = false;
+                        break;
+                    case 4:
+                        furtherInput = c.getIntegerInput("You can make a one roll bet. Type 2, 3, 4, 6, 7, 8, 10, 11, or 12 to bet on that number, 1 for craps, or 0 to cancel.");
+                        switch(furtherInput){
+                            case 1:
+                                chooseBetAmountAndMakeBet(12);
+                                break;
+                            case 2:
+                                chooseBetAmountAndMakeBet(19);
+                                break;
+                            case 3:
+                                chooseBetAmountAndMakeBet(17);
+                                break;
+                            case 4:
+                                chooseBetAmountAndMakeBet(15);
+                                break;
+                            case 6:
+                                chooseBetAmountAndMakeBet(13);
+                                break;
+                            case 7:
+                                chooseBetAmountAndMakeBet(11);
+                                break;
+                            case 8:
+                                chooseBetAmountAndMakeBet(14);
+                                break;
+                            case 10:
+                                chooseBetAmountAndMakeBet(16);
+                                break;
+                            case 11:
+                                chooseBetAmountAndMakeBet(18);
+                                break;
+                            case 12:
+                                chooseBetAmountAndMakeBet(20);
+                                break;
+                            default:
+                                cd.printErrorMessage();
+                                continue;
+                        }
+                        break;
+                    default:
+                        cd.printErrorMessage();
+                        continue;
+                }
+                if(decisionUnmade) {
+                    cd.youCanBetAgain();
+                }
+            }
+
+            decisionUnmade = true;
+            if(firstRoll){
+                cd.printComeOutRoll();
+                firstRoll = false;
+            }
+            Integer x = diceRollSum(2);
+            cd.printShooterRolled(x);
+            checkBetsPrePoint(x);
+            oneRollReset();
+            if(x == 4 || x == 5 || x == 6 || x == 8 || x == 9 || x == 10){
+                point = x;
+                noPointSet = false;
+                cd.printThatPoint();
+            } else {
+                cd.printNoPoint();
+            }
+        }
+
+
+
+        while(notSevenedOut){
+            while(decisionUnmade){
+                cd.printSetTypeOfBet();
+                input = c.getIntegerInput("Type 0 for no bet, 2 for 'come,' 3 for 'don't come,' or 4 for a proposition.");
+                switch(input) {
+                    case 1:
+                        cd.printRulesMenu1();
+                        cd.printRulesMenuMid();
+                        innerInput = c.getIntegerInput("Type 1 for yes, 2 for no.");
+                        switch (innerInput) {
+                            case 1:
+                                cd.printRulesMenu2();
+                                break;
+                            case 2:
+                                break;
+                            default:
+                                cd.printErrorMessage();
+                                continue;
+                        }
+                    case 2:
+                        chooseBetAmountAndMakeBet(2);
+                        break;
+                    case 3:
+                        chooseBetAmountAndMakeBet(3);
+                        break;
+                    case 0:
+                        decisionUnmade = false;
+                        break;
+                    case 4:
+                        furtherInput = c.getIntegerInput("Type 1 to bet the field, 2 for a place bet, or 3 for a one-roll bet.");
+                        switch(furtherInput){
+                            case 1:
+                                chooseBetAmountAndMakeBet(4);
+                                break;
+                            case 2:
+                                yetFurtherInput = c.getIntegerInput("Type the number you want to make your place bet on (4, 5, 6, 8, 9, or 10, but not the point.");
+                                if(yetFurtherInput == point){
+                                    cd.printErrorMessage();
+                                    continue;
+                                }
+                                switch(yetFurtherInput){
+                                    case 4:
+                                        chooseBetAmountAndMakeBet(5);
+                                        break;
+                                    case 5:
+                                        chooseBetAmountAndMakeBet(6);
+                                        break;
+                                    case 6:
+                                        chooseBetAmountAndMakeBet(7);
+                                        break;
+                                    case 8:
+                                        chooseBetAmountAndMakeBet(8);
+                                        break;
+                                    case 9:
+                                        chooseBetAmountAndMakeBet(9);
+                                        break;
+                                    case 10:
+                                        chooseBetAmountAndMakeBet(10);
+                                        break;
+                                    default:
+                                        cd.printErrorMessage();
+                                        continue;
+                                }
+                            case 3:
+                                yetFurtherInput = c.getIntegerInput("You can make a one roll bet. Type 2, 3, 4, 6, 7, 8, 10, 11, or 12 to bet on that number, 1 for craps, or 0 to cancel.");
+                                switch(yetFurtherInput) {
+                                    case 1:
+                                        chooseBetAmountAndMakeBet(12);
+                                        break;
+                                    case 2:
+                                        chooseBetAmountAndMakeBet(19);
+                                        break;
+                                    case 3:
+                                        chooseBetAmountAndMakeBet(17);
+                                        break;
+                                    case 4:
+                                        chooseBetAmountAndMakeBet(15);
+                                        break;
+                                    case 6:
+                                        chooseBetAmountAndMakeBet(13);
+                                        break;
+                                    case 7:
+                                        chooseBetAmountAndMakeBet(11);
+                                        break;
+                                    case 8:
+                                        chooseBetAmountAndMakeBet(14);
+                                        break;
+                                    case 10:
+                                        chooseBetAmountAndMakeBet(16);
+                                        break;
+                                    case 11:
+                                        chooseBetAmountAndMakeBet(18);
+                                        break;
+                                    case 12:
+                                        chooseBetAmountAndMakeBet(20);
+                                        break;
+                                    case 0:
+                                        continue;
+                                    default:
+                                        cd.printErrorMessage();
+                                        continue;
+                                }
+                        }
+                        break;
+                    default:
+                        cd.printErrorMessage();
+                        continue;
+                }
+            }
+            decisionUnmade = true;
+            Integer x = diceRollSum(2);
+            cd.printShooterRolled(x);
+            checkBetsPostPoint(x, point);
+            oneRollReset();
+            if(x == 7){
+                notSevenedOut = false;
+                d.setPrintCurrentDisplay(endGame());
+            }
+
+        }
+
+
+    }
+
+    public void initialRulesPrompt(){
+        cd.initalRulesAsk();
+        Boolean haventAnswered = true;
+        while(haventAnswered){
+            input = c.getIntegerInput("Type 1 for yes, 2 for no.");
+            switch(input) {
+                case 1:
+                    cd.printRulesMenu1();
+                    cd.printRulesMenu2();
+                    d.setPrintCurrentDisplay(startGame());
+                    haventAnswered = false;
+                    break;
+                case 2:
+                    d.setPrintCurrentDisplay(startGame());
+                    haventAnswered = false;
+                    break;
+                default:
+                    d.setPrintCurrentDisplay("Invalid user input. Please reread instructions.");
+            }
+        }
+    }
+
+    public void chooseBetAmountAndMakeBet(Integer x){
+        Double middleMan;
+        middleMan = c.getDoubleInput("How much money are you going to bet?");
+        lastBet = player.makeBet(middleMan);
+        betAmounts[x] = lastBet;
+        bets[x] = true;
+    }
+
+    public void oneRollReset(){
+        bets[4] = false;
+        betAmounts[4] = 0.0;
+        for(int i = 11; i < 21; i++){
+            bets[i] = false;
+            betAmounts[i] = 0.0;
+        }
+    }
+
+    public void checkBetsPrePoint(Integer x){
+        if(x == 2 && bets[19]){
+            player.setWallet(betAmounts[19] * 60);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[19] * 60);
+        }
+        if(x == 2 && bets[12]){
+            player.setWallet(betAmounts[12] * 14);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[12] * 14);
+        }
+        if(x == 2 && bets[1]){ //pass
+            player.setWallet(betAmounts[1] * 2);
+            cd.printCraps();
+            cd.printWinnings(betAmounts[1] * 2);
+        }
+        if(x == 3 && bets[17]){
+            player.setWallet(betAmounts[17] * 30);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[17] * 30);
+        }
+        if(x == 3 && bets[12]){
+            player.setWallet(betAmounts[12] * 14);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[12] * 14);
+        }
+        if(x == 3 && bets[1]){ //pass
+            player.setWallet(betAmounts[1] * 2);
+            cd.printCraps();
+            cd.printWinnings(betAmounts[1] * 2);
+        }
+        if(x == 4 && bets[15]){
+            player.setWallet(betAmounts[15] * 14);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[15] * 14);
+        }
+        if(x == 6 && bets[13]){
+            player.setWallet(betAmounts[13] * 18);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[13] * 18);
+        }
+        if(x == 7 && bets[11]){
+            player.setWallet(betAmounts[11] * 8);
+            cd.printNatural();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[11] * 8);
+        }
+        if(x == 7 && bets[0]){ //pass
+            player.setWallet(betAmounts[0] * 2);
+            cd.printNatural();
+            cd.printWinnings(betAmounts[0] * 2);
+        }
+        if(x == 8 && bets[14]){
+            player.setWallet(betAmounts[14] * 18);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[14] * 18);
+        }
+        if(x == 10 && bets[16]){
+            player.setWallet(betAmounts[16] * 14);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[16] * 14);
+        }
+        if(x == 11 && bets[18]){
+            player.setWallet(betAmounts[18] * 30);
+            cd.printOneRollBetWin();
+            cd.printNatural();
+            cd.printWinnings(betAmounts[18] * 30);
+        }
+        if(x == 11 && bets[0]){ //pass
+            player.setWallet(betAmounts[0] * 2);
+            cd.printNatural();
+            cd.printWinnings(betAmounts[0] * 2);
+        }
+        if(x == 12 && bets[20]){
+            player.setWallet(betAmounts[20] * 60);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[20] * 60);
+        }
+        if(x == 12 && bets[12]){
+            player.setWallet(betAmounts[12] * 14);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[12] * 14);
+        }
+        if(x == 12 && bets[1]){ //pass
+            player.setWallet(betAmounts[1]);
+            cd.printCraps();
+            cd.printPush();
+        }
+    }
+
+    public void checkBetsPostPoint(Integer x, Integer point){
+        if(x == 2 && bets[19]){
+            player.setWallet(betAmounts[19] * 60);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[19] * 60);
+        }
+        if(x == 2 && bets[12]){
+            player.setWallet(betAmounts[12] * 14);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[12] * 14);
+        }
+        if(x == 3 && bets[17]){
+            player.setWallet(betAmounts[17] * 30);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[17] * 30);
+        }
+        if(x == 3 && bets[12]){
+            player.setWallet(betAmounts[12] * 14);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[12] * 14);
+        }
+        if(x == 4 && bets[15]){
+            player.setWallet(betAmounts[15] * 14);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[15] * 14);
+        }
+        if(x == 6 && bets[13]){
+            player.setWallet(betAmounts[13] * 18);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[13] * 18);
+        }
+        if(x == 7 && bets[11]){
+            player.setWallet(betAmounts[11] * 8);
+            cd.printNatural();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[11] * 8);
+        }
+        if(x == 8 && bets[14]){
+            player.setWallet(betAmounts[14] * 18);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[14] * 18);
+        }
+        if(x == 10 && bets[16]){
+            player.setWallet(betAmounts[16] * 14);
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[16] * 14);
+        }
+        if(x == 11 && bets[18]){
+            player.setWallet(betAmounts[18] * 30);
+            cd.printOneRollBetWin();
+            cd.printNatural();
+            cd.printWinnings(betAmounts[18] * 30);
+        }
+        if(x == 12 && bets[20]){
+            player.setWallet(betAmounts[20] * 60);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[20] * 60);
+        }
+        if(x == 12 && bets[12]){
+            player.setWallet(betAmounts[12] * 14);
+            cd.printCraps();
+            cd.printOneRollBetWin();
+            cd.printWinnings(betAmounts[12] * 14);
+        }
+        if(x == point){
+            bets[3] = false;
+            betAmounts[3] = 0.0;
+        }
+        if(x == 7){
+            bets[2] = false;
+            betAmounts [2] = 0.0;
+        }
+        if(x == point && bets[2]){
+            player.setWallet(betAmounts[2]);
+            cd.printShooterScores();
+            cd.printWinnings(betAmounts[2]);
+        }
+        if(x == 7 && bets[3]){
+            player.setWallet(betAmounts[3] * 2);
+            cd.printShooterSevenedOut();
+            cd.printWinnings(betAmounts[3] * 2);
+        }
+        if(x == 3 && bets[4] || x == 4 && bets[4] || x == 9 && bets[4] || x == 10 && bets[4] || x == 11 && bets[4]){
+            player.setWallet(betAmounts[4] * 2);
+            cd.printWinnings(betAmounts[4] * 2);
+        }
+        if(x == 2 && bets[4] || x == 12 && bets[4]){
+            player.setWallet(betAmounts[4] * 4);
+            cd.printWinnings(betAmounts[4] * 4);
+        }
+        if(x == 4 && bets[5]){
+            player.setWallet(betAmounts[5] * 2);
+            cd.printWinnings(betAmounts[5] * 2);
+        }
+        if(x == 5 && bets[6]){
+            player.setWallet(betAmounts[6] * 2);
+            cd.printWinnings(betAmounts[6] * 2);
+        }
+        if(x == 6 && bets[7]){
+            player.setWallet(betAmounts[7] * 2);
+            cd.printWinnings(betAmounts[7] * 2);
+        }
+        if(x == 8 && bets[8]){
+            player.setWallet(betAmounts[8] * 2);
+            cd.printWinnings(betAmounts[8] * 2);
+        }
+        if(x == 9 && bets[9]){
+            player.setWallet(betAmounts[9] * 2);
+            cd.printWinnings(betAmounts[9] * 2);
+        }
+        if(x == 10 && bets[10]){
+            player.setWallet(betAmounts[10] * 2);
+            cd.printWinnings(betAmounts[10] * 2);
+        }
+    }
+
+    public String startGame() {
+        return "Alright! Let's play Craps!";
+    }
+
+    public Double setPurse(Double betAmount) {
+        return null;
+    }
+
+    public Double calculateReward() {
+        return null;
+    }
+
+    public Double calculateLoss() {
+        return null;
+    }
+
+    public String endGame() {
+        return "That's the end of the round!";
+    }
+
+}
+
+
+
+
+
+
+
diff --git a/src/main/java/io/zipcoder/casino/CrapsDisplay.java b/src/main/java/io/zipcoder/casino/CrapsDisplay.java
new file mode 100644
index 000000000..ea6c496a7
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/CrapsDisplay.java
@@ -0,0 +1,88 @@
+package io.zipcoder.casino;
+
+public class CrapsDisplay extends Display {
+
+    public void initalRulesAsk(){
+        setPrintCurrentDisplay("Welcome! Would you like the rules first?");
+    }
+
+    public void printRulesMenu1(){
+        setPrintCurrentDisplay("Welcome to Craps!\nIn Craps, the 'shooter' rolls two dice repeatedly.\nTheir first roll, the 'come out roll,' has three potential outcomes.\nA 7 or 11 total is a pass. A 2, 3, or 12 is craps. Anything else is a point.\nYou can bet 'pass' (the shooter rolls a pass) or 'don't pass' (the shooter rolls craps) for 1 to 1 payout.\nThe shooter keeps rolling until a point is set. On a point outcome, the number rolled is saved.\nNow, the shooter can 'come' by hitting the point outcome again, or 'seven out,' ending the round by rolling a 7.\nYou can bet 'come' (shooter hits point before sevening out) or 'don't come' (vice versa) for 1 to 1 payout.\n");
+    }
+
+    public void printRulesMenuMid(){
+        setPrintCurrentDisplay("There are more technical rules. Do you want them?");
+    }
+
+    public void printRulesMenu2(){
+        setPrintCurrentDisplay("There are a number of extra bets you can make, called propositions.\nOne-roll propositions are a bet that the next roll will land on a specific number, with variable payouts.\n6 or 8- 9 to 1 payout. 4 or 10- 7 to 1. 2 or 12- 30 to 1. 3 or 11- 15 to 1. Craps- 7 to 1. 7- 4 to 1.\nThe field bet is the final one-roll bet. Rolling 3, 4, 9, 10, or 11 pays 1 to 1. Rolling 2 or 12 pays 2 to 1.\nPlace bets can be performed once the point is known. You're betting that a specific different point option will be rolled- this has 1 to 1 payout.\nThat's every bet in Craps! Have fun!\n");
+    }
+
+    public void youCanBetAgain(){
+        setPrintCurrentDisplay("You can make more bets!");
+    }
+
+    public void printWinnings(Double winnings){
+        setPrintCurrentDisplay("You made $" + winnings + "!");
+    }
+
+    public void printLosings(Double bet){
+        setPrintCurrentDisplay("There goes $" + bet + ".");
+    }
+
+    public void printShooterScores(){
+        setPrintCurrentDisplay("The shooter got the point!");
+    }
+
+    public void printShooterSevenedOut(){
+        setPrintCurrentDisplay("The shooter sevened out... The round is over.");
+    }
+
+    public void printPush(){
+        setPrintCurrentDisplay("Your bet is a push.");
+    }
+
+    public void printOneRollBetWin(){
+        setPrintCurrentDisplay("You won your one-roll proposition!");
+    }
+
+    public void printNatural(){
+        setPrintCurrentDisplay("It's a natural!");
+    }
+
+    public void printCraps(){
+        setPrintCurrentDisplay("It's craps!");
+    }
+
+    public void printShooterRolled(Integer x){
+        setPrintCurrentDisplay("The shooter rolled a " + x);
+    }
+
+    public void printThatPoint(){
+        setPrintCurrentDisplay("That's the point!");
+    }
+
+    public void printNoPoint(){
+        setPrintCurrentDisplay("No point yet!");
+    }
+
+    public void printSetTypeOfBet(){
+        setPrintCurrentDisplay("What kind of bet do you want to make? You can also type 1 for help.");
+    }
+
+    public void printComeOutRoll(){
+        setPrintCurrentDisplay("Here's the come out roll...");
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/java/io/zipcoder/casino/DiceGame.java b/src/main/java/io/zipcoder/casino/DiceGame.java
new file mode 100644
index 000000000..29625b0c6
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/DiceGame.java
@@ -0,0 +1,20 @@
+package io.zipcoder.casino;
+
+import java.util.Random;
+
+
+abstract class DiceGame implements GamblingGame {
+
+
+    public Integer diceRollSum(int i) {
+        Random random = new Random();
+        Integer thisToss = 0;
+
+        while (i >= 1) {
+            int randomGen = (random.nextInt(6) + 1);
+            thisToss += randomGen;
+            i--;
+        }
+        return thisToss;
+    }
+}
diff --git a/src/main/java/io/zipcoder/casino/Display.java b/src/main/java/io/zipcoder/casino/Display.java
new file mode 100644
index 000000000..231678077
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Display.java
@@ -0,0 +1,205 @@
+package io.zipcoder.casino;
+import io.zipcoder.casino.utilities.Console;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+
+import java.util.Scanner;
+
+public class Display {
+
+    String currentDisplay;
+
+    private Scanner s;
+    private InputStream in;
+    private PrintStream out;
+
+    private Console c;
+
+    public Display(){
+
+        // INPUT/OUTPUT
+        this.in = System.in;
+        this.out = System.out;
+        this.c = new Console(in, out);
+
+        this.currentDisplay = "";
+    }
+
+    // UPDATE/PRINT CURRENT DISPLAY
+    public void setCurrentDisplay(String newDisplay){
+        this.currentDisplay = newDisplay;
+    }
+
+    public void printCurrentDisplay(){
+        System.out.println(currentDisplay);
+    }
+
+    public void setPrintCurrentDisplay(String newDisplay){
+        this.setCurrentDisplay(newDisplay);
+        this.printCurrentDisplay();
+    }
+
+
+    // WELCOME MESSAGING
+    public void printWelcomeMessage() {
+        this.setPrintCurrentDisplay(
+            "'########:'####:'########::::::'######:::'#######::'########::'########::::\n"+
+            "..... ##::. ##:: ##.... ##::::'##... ##:'##.... ##: ##.... ##: ##.....:::::\n"+
+            ":::: ##:::: ##:: ##:::: ##:::: ##:::..:: ##:::: ##: ##:::: ##: ##::::::::::\n"+
+            "::: ##::::: ##:: ########::::: ##::::::: ##:::: ##: ##:::: ##: ######::::::\n"+
+            ":: ##:::::: ##:: ##.....:::::: ##::::::: ##:::: ##: ##:::: ##: ##...:::::::\n"+
+            ": ##::::::: ##:: ##::::::::::: ##::: ##: ##:::: ##: ##:::: ##: ##::::::::::\n"+
+            " ########:'####: ##:::::::::::. ######::. #######:: ########:: ########::::\n"+
+            "........::....::..:::::::::::::......::::.......:::........:::........:::::\n"+
+            ":'######:::::'###:::::'######::'####:'##::: ##::'#######::\n"+
+            "'##... ##:::'## ##:::'##... ##:. ##:: ###:: ##:'##.... ##:\n"+
+            " ##:::..:::'##:. ##:: ##:::..::: ##:: ####: ##: ##:::: ##:\n"+
+            " ##:::::::'##:::. ##:. ######::: ##:: ## ## ##: ##:::: ##:\n"+
+            " ##::::::: #########::..... ##:: ##:: ##. ####: ##:::: ##:\n"+
+            " ##::: ##: ##.... ##:'##::: ##:: ##:: ##:. ###: ##:::: ##:\n"+
+            ". ######:: ##:::: ##:. ######::'####: ##::. ##:. #######::\n"+
+            ":......:::..:::::..:::......:::....::..::::..:::.......:::\n\n"+
+            "WELCOME TO ZIP CODE CASINO, LOCATED IN WILMINGTON, DE!"
+        );
+    }
+
+    public void printWelcomeMessage(String name, double getAccountBalance) {
+        this.setPrintCurrentDisplay(
+            "Welcome " + name + "!\n"+
+            "Your current account balance is $" + getAccountBalance + "."
+        );
+    }
+
+    // MENUS
+    public void printLoginMenu() {
+        this.setPrintCurrentDisplay(
+            "What would you like to do?\n" +
+                "1.Login\n" +
+                "2.Create New Account"
+        );
+    }
+
+    public void printGamesMenu() {
+        this.setPrintCurrentDisplay(
+            "Pick a Game to Play:\n"+
+            "   1. BlackJack\n" +
+            "   2. Craps\n" +
+            "   3. Beetle\n" +
+            "   4. GoFish\n" +
+            "   5. Check Account Balance\n" +
+            "   6. Make a Deposit\n" +
+            "   7. Exit\n"
+        );
+    }
+
+    // ERROR MESSAGING
+    public void printErrorMessage() {
+        this.setPrintCurrentDisplay("Invalid Input!");
+    }
+
+
+    // FUNDS MESSAGING
+    public void printAccountBalance(double accountBalance) {
+        BigDecimal formattedBalance = new BigDecimal(accountBalance).setScale(2, RoundingMode.HALF_UP);
+        accountBalance = formattedBalance.doubleValue();
+        this.setPrintCurrentDisplay(
+           "Account Balance: " + accountBalance
+        );
+    }
+
+    public void printLowFundsWarning(double accountBalance){
+        this.setPrintCurrentDisplay(
+            "\n\nWARNING: YOUR FUNDS ARE GETTING LOW!\n"+
+            "Please consider making a deposit.\n"
+        );
+        this.printAccountBalance(accountBalance);
+
+    }
+
+    public void printZeroFundsWarning() {
+        this.setPrintCurrentDisplay(
+            "\n\nWARNING: YOUR ACCOUNT BALANCE HAS REACHED $0.00.\n"+
+            "PLEASE MAKE A DEPOSIT TO CONTINUE PLAYING."
+        );
+    }
+
+    public void printDepositMessage() {
+        this.setPrintCurrentDisplay(
+            "How much are you depositing?"
+        );
+    }
+
+    // GENERIC GAME RESULT MESSAGING
+    public void printRollResult(Integer[] diceResults) {
+        String formattedRollResults = "";
+        for(int i = 0; i < diceResults.length; i++) {
+            formattedRollResults += "Dice " + (i+1) + ": " + diceResults[i] + "\n";
+        }
+
+        this.setPrintCurrentDisplay(
+            formattedRollResults
+        );
+    }
+
+    public void printDealResult(ArrayList dealResults) {
+        String formattedDealResults = "";
+        for(int i = 0; i < dealResults.size(); i++) {
+            formattedDealResults += "Card " + (i+1) + ": " + dealResults.get(i) + "\n";
+        }
+
+        this.setPrintCurrentDisplay(
+            formattedDealResults
+        );
+    }
+
+    public void printAmountOfWinnings(Double winningsAmount) {
+        setPrintCurrentDisplay("You won $" + winningsAmount+ "!!!");
+    }
+
+    public void printAmountOfLoss(Double lossAmount) {
+        setPrintCurrentDisplay("You lost $" + lossAmount + ".");
+    }
+
+    // USER SET-UP MESSAGING
+    public void printUserId(String userName){
+        this.setPrintCurrentDisplay(
+            "UserId: " + userName
+        );
+    }
+
+    public void printRequestUserId() {
+        this.setPrintCurrentDisplay(
+            "Please enter username:"
+        );
+    }
+
+    public void printRequestPassword() {
+        this.setPrintCurrentDisplay(
+            "Please enter your password:"
+        );
+    }
+
+    public void printRequestInitialDeposit(){
+        this.setPrintCurrentDisplay(
+            "Please enter deposit amount:"
+        );
+    }
+
+    // GENERIC BETTING MESSAGES
+    public void printRequestBetAmount() {
+        this.setPrintCurrentDisplay(
+            "How much money would you like to bet?"
+        );
+    }
+
+    public String getCurrentDisplay(){
+        System.out.println(currentDisplay);
+        return currentDisplay;
+    }
+
+
+}
diff --git a/src/main/java/io/zipcoder/casino/GamblingGame.java b/src/main/java/io/zipcoder/casino/GamblingGame.java
new file mode 100644
index 000000000..21ded58a4
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GamblingGame.java
@@ -0,0 +1,16 @@
+package io.zipcoder.casino;
+
+public interface GamblingGame {
+
+    public String startGame();
+
+    public Double setPurse(Double betAmount);
+
+    public Double calculateReward();
+
+    public Double calculateLoss();
+
+    public String endGame();
+
+
+}
diff --git a/src/main/java/io/zipcoder/casino/GamblingPlayer.java b/src/main/java/io/zipcoder/casino/GamblingPlayer.java
new file mode 100644
index 000000000..19678e558
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GamblingPlayer.java
@@ -0,0 +1,11 @@
+package io.zipcoder.casino;
+
+public interface GamblingPlayer {
+
+public String placeBet();
+
+public String getName();
+
+public Double accountBalance();
+
+}
diff --git a/src/main/java/io/zipcoder/casino/Game.java b/src/main/java/io/zipcoder/casino/Game.java
new file mode 100644
index 000000000..a6a26a001
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Game.java
@@ -0,0 +1,13 @@
+package io.zipcoder.casino;
+
+import java.util.Random;
+
+public interface Game {
+    Random random =new Random();
+
+    Integer numberOfPlayers = 0;
+    Boolean GameState = false;
+
+    public String checkForWinner();
+
+}
diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java
new file mode 100644
index 000000000..1d5871321
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GoFish.java
@@ -0,0 +1,241 @@
+package io.zipcoder.casino;
+import io.zipcoder.casino.utilities.Console;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class GoFish extends CardGame {
+
+    private Console c;
+    private GoFishDisplay d;
+    private Player p;
+    private Integer pairCountHuman;
+    private Integer pairCountComputer;
+    private String rankRequested;
+    private String turn;
+
+    public GoFish(Player currentPlayer) {
+
+        this.c = new Console(System.in, System.out);
+        this.d = new GoFishDisplay();
+        this.p = currentPlayer;
+
+        this.pairCountHuman = 0;
+        this.pairCountComputer = 0;
+        this.turn = "Player";
+        this.rankRequested = "";
+    }
+
+    // GETTERS
+    public String getTurn() { return this.turn; }
+
+    public int getPairCountHuman() { return this.pairCountHuman; }
+
+    public int getPairCountComputer() {return this.pairCountComputer;}
+
+    public String getRankRequested() { return this.rankRequested; }
+
+    // SETTERS
+    public void setTurn(String newTurn) { this.turn = newTurn; }
+
+    public void setPairCounts(int pairCountPlayer, int pairCountDealer) {
+        this.pairCountHuman = pairCountPlayer;
+        this.pairCountComputer = pairCountDealer;
+    }
+
+    public void setRankRequested(String rank) { this.rankRequested = rank; }
+
+    // GAME PLAY METHODS
+    public String startGame() {
+        d.printGoFishRules();
+        d.printWelcomeMessage(p.getName(), p.getWallet());
+        this.setupGame(5);
+        return null;
+    }
+
+    public void setupGame(int numberOfCards) {
+        this.createNewDeck();
+        this.shuffleCards();
+        this.dealCards(numberOfCards);
+    }
+
+    public boolean getRankToAskFor_Player() {
+        d.printWhatRankYouWillAskFor();
+        this.rankRequested = c.getStringInput("", (Object[]) null);
+        if (!checkIfRankInHand(this.playersHand)) {
+            d.printInvalidRankRequested();
+            return false;
+        }
+        return true;
+    }
+
+    public String getRankToAskFor_Computer () {
+        int pickCard = (int) Math.floor(Math.random() * (this.dealersHand.size()));
+        this.rankRequested = this.getRankOnCard(this.dealersHand.get(pickCard));
+        return this.rankRequested;
+    }
+
+    public boolean checkIfRankInHand (ArrayList < String > handToCheck) {
+        for (int i = 0; i < handToCheck.size(); i++) {
+            if (getRankOnCard(handToCheck.get(i)).equals(this.rankRequested)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void takeCardFromOtherPlayer (ArrayList < String > playerTakingCard, ArrayList < String > playerGivingCard, String rankAskedFor){
+        for (int i = 0; i < playerGivingCard.size(); i++) {
+            if (this.getRankOnCard(playerGivingCard.get(i)).equals(rankAskedFor)) {
+                playerTakingCard.add(playerGivingCard.get(i));
+                playerGivingCard.remove(i);
+            }
+        }
+
+        if (this.turn.equals("Computer")) {
+            d.printComputerTookCard();
+        } else {
+            d.printPlayerTookCard();
+        }
+    }
+
+    public String stealOrGoFish(ArrayList<String> currentPlayer, ArrayList<String> opposingPlayer, String rankRequested) {
+        if (checkIfRankInHand(opposingPlayer)) {
+            this.takeCardFromOtherPlayer(currentPlayer, opposingPlayer, rankRequested);
+            return "Take Card";
+        } else {
+            this.goFish(this.turn);
+            return "Go Fish";
+        }
+    }
+
+    public String goFish(String currentTurn) {
+        if (currentTurn.equals("Computer")) {
+            d.printTellComputerGoFish();
+            if (!this.drawCardFromDeck(this.dealersHand).equals(this.rankRequested)) {
+                this.setTurn("Player");
+            } else {
+                d.printAnotherTurn();
+            };
+        } else if (currentTurn.equals("Player")) {
+            String cardDrawnRank = this.drawCardFromDeck(this.playersHand);
+            d.printComputerSaysGoFish(cardDrawnRank);
+            if (!cardDrawnRank.equals(this.rankRequested)) {
+                this.setTurn("Computer");
+            } else {
+                d.printAnotherTurn();
+            }
+        }
+        return this.turn;
+    }
+
+    public String drawCardFromDeck (ArrayList < String > playerHand) {
+        String cardDrawnRank = this.getRankOnCard(this.deck.get(0));
+        playerHand.add(this.deck.get(0));
+        this.deck.remove(0);
+        return cardDrawnRank;
+    }
+
+    public String checkPairInHand (ArrayList < String > currentPlayer) {
+        Collections.sort(currentPlayer);
+        int count = 1;
+        for (int i = 1; i < currentPlayer.size(); i++) {
+            if (this.getRankOnCard(currentPlayer.get(i - 1)).equals(this.getRankOnCard(currentPlayer.get(i)))) {
+                count += 1;
+                if (count == 2) {
+                    return this.getRankOnCard(currentPlayer.get(i));
+                }
+            } else {
+                count = 1;
+            }
+        }
+        return null;
+    }
+
+    public String removePairFromHand (ArrayList < String > currentPlayer) {
+        String rankToRemove = checkPairInHand(currentPlayer);
+        String allRanksRemoved = "";
+        while (rankToRemove != null) {
+            int i = 0, count = 0;
+            while (i < currentPlayer.size()) {
+                if (getRankOnCard(currentPlayer.get(i)).equals(rankToRemove) && count < 3) {
+                    currentPlayer.remove(i);
+                    count++;
+                } else {
+                    i++;
+                }
+            }
+            this.incrementPairCount(rankToRemove);
+            allRanksRemoved += rankToRemove;
+            rankToRemove = checkPairInHand(currentPlayer);
+
+        }
+        return allRanksRemoved;
+    }
+
+    // this method is super duper ugly :( need to clean up
+    public void incrementPairCount(String rankRemoved){
+        if (this.turn.equals("Computer")) {
+            this.pairCountComputer++;
+            d.printNumPairsComputer(rankRemoved, this.pairCountComputer);
+            // Draw card if hand is empty
+            if (this.dealersHand.size() == 0 && this.deck.size() != 0) {
+                this.drawCardFromDeck(this.dealersHand);
+                d.printRanOutOfCards();
+            } else if (this.dealersHand.size() == 0 && this.deck.size() == 0) {
+                this.checkGameOver();
+            };
+        } else if (this.turn.equals("Player")) {
+            this.pairCountHuman++;
+            d.printNumPairsPlayer(rankRemoved, this.pairCountHuman);
+            // Draw card if hand is empty
+            if (this.playersHand.size() == 0 && this.deck.size() != 0) {
+                this.drawCardFromDeck(this.playersHand);
+                d.printRanOutOfCards();
+            } else if (this.playersHand.size() == 0 && this.deck.size() == 0) {
+                this.checkGameOver();
+            }
+            d.printPlayersHand(this.displayPlayersHand(this.playersHand));
+        }
+    }
+
+    public boolean checkGameOver () {
+        if (this.deck.size() == 0) {
+            this.removePairFromHand(this.playersHand);
+            this.removePairFromHand(this.dealersHand);
+            return true;
+        }
+        return false;
+    }
+
+    public String checkForWinner () {
+        String winner = "";
+        d.printGameOver();
+        System.out.println("Final No. Pairs Computer: " + this.pairCountComputer);
+        System.out.println("Final No. Pairs Player: " + this.pairCountHuman);
+        if (this.pairCountComputer > this.pairCountHuman) {
+            d.printComputerWinner();
+            winner = "Computer";
+        } else if (this.pairCountComputer < this.pairCountHuman){
+            d.printPlayerWinner();
+            winner = "Player";
+        } else {
+            d.printTiedGame();
+            winner = "Tied";
+        }
+        return winner;
+    }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/main/java/io/zipcoder/casino/GoFishDisplay.java b/src/main/java/io/zipcoder/casino/GoFishDisplay.java
new file mode 100644
index 000000000..0adfa50ad
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GoFishDisplay.java
@@ -0,0 +1,97 @@
+package io.zipcoder.casino;
+
+public class GoFishDisplay extends Display{
+
+    // GAME START MESSAGING
+    public void printGoFishRules(){
+        setPrintCurrentDisplay("GO FISH RULES:\n"+
+                "Two players will be dealt 5 cards each to begin.\n"+
+                "The object of the game is to have the most pairs.\n"+
+                "A player creates a pair by asking the other player if they have cards of a specific rank in their hand.\n" +
+                "If the other player is holding cards of the requested rank, they must hand them over.\n"+
+                "You can only request card ranks that you already have in your hand.\n" +
+                "Game play continues until the deck is empty.\n"+
+                "Humans play first!\n");
+    }
+
+    // TURN SEPARATORS
+    public void printTurnSeparator(int deckSize, String currentPlayer) {
+        setPrintCurrentDisplay("\n=================================================================================="+
+                "\nCARDS REMAINING IN DECK: " + deckSize+
+                "\nCURRENT PLAYER: " + currentPlayer);
+    }
+
+    // FOR PRINTING PLAYER'S CARDS
+    public void printPlayersHand(String playersHand) {
+        setPrintCurrentDisplay("\nCARDS IN YOUR HAND:\n"+
+                playersHand);
+    }
+
+    // ASKING FOR CARDS
+    public void printWhatRankYouWillAskFor(){
+        setPrintCurrentDisplay("\nWhat card rank will you ask for?");
+    }
+
+    public void printInvalidRankRequested() {
+        setPrintCurrentDisplay("You must request a card rank that is already in your hand.");
+    }
+
+    public void printComputerAskedFor(String rankRequested){
+        setPrintCurrentDisplay("\nComputer Requested Rank: " + rankRequested);
+    }
+
+    // TAKING CARDS
+    public void printPlayerTookCard(){
+        setPrintCurrentDisplay("That card rank is in the computer's hand! It will now be given to you!\n"+
+                "You get to play another turn!");
+    }
+
+    public void printComputerTookCard() {
+        setPrintCurrentDisplay("You have the requested rank in your hand! The computer has taken it from you!\n"+
+                "The computer gets to play another turn!");
+    }
+
+    // GO FISH
+    public void printComputerSaysGoFish(String cardDrawnRank){
+        setPrintCurrentDisplay("\nTHE COMPUTER SAYS: GO FISH!\nRank Drawn: " + cardDrawnRank + ".");
+    }
+
+    public void printTellComputerGoFish() {
+        setPrintCurrentDisplay("\nYOU TOLD THE COMPUTER TO GO FISH!\nThe Computer has drawn a card from the deck.");
+    }
+
+    public void printAnotherTurn() {
+        setPrintCurrentDisplay("\nCard drawn from deck is same rank as that requested. Current player gets another turn.");
+    }
+
+    // PAIRS
+    public void printNumPairsPlayer(String rankRemoved, int numPairsPlayer) {
+        setPrintCurrentDisplay("\nYay! You made a pair of rank " + rankRemoved + "!\nCurrent Number of Pairs You Have: " + numPairsPlayer);
+    }
+
+    public void printNumPairsComputer(String rankRemoved, int numPairsComputer) {
+        setPrintCurrentDisplay("\nThe Computer made a pair of rank " + rankRemoved + "!\nCurrent Number of Pairs Computer Has: " + numPairsComputer);
+    }
+
+    public void printRanOutOfCards() {
+        setPrintCurrentDisplay("\nEmpty hand - one card drawn from deck.");
+    }
+
+
+    // FINAL GAME RESULTS
+    public void printGameOver() {
+        setPrintCurrentDisplay("\nGAME OVER");
+    }
+    public void printPlayerWinner() {
+        setPrintCurrentDisplay("\nCongratulations, you WIN!!!");
+    }
+
+    public void printComputerWinner() {
+        setPrintCurrentDisplay("\nSorry, the computer BEAT you!");
+    }
+
+    public void printTiedGame() {
+        setPrintCurrentDisplay("\nYou TIED with the computer!");
+    }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/GoFishEngine.java b/src/main/java/io/zipcoder/casino/GoFishEngine.java
new file mode 100644
index 000000000..a12aae1af
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/GoFishEngine.java
@@ -0,0 +1,51 @@
+package io.zipcoder.casino;
+
+public class GoFishEngine {
+
+    private GoFish g;
+    private GoFishDisplay d;
+
+    public GoFishEngine(Player currentPlayer) {
+        this.g = new GoFish(currentPlayer);
+        this.d = new GoFishDisplay();
+    }
+
+    public void playGame() {
+        g.startGame();
+        this.playGameLoop();
+        g.checkForWinner();
+    }
+
+    public void playGameLoop() {
+        while (!g.checkGameOver()) {
+            if (g.getTurn().equals("Player")) {
+                d.printTurnSeparator(g.getDeck().size(), "You!");
+                this.playHumansTurn();
+
+            } else if (g.getTurn().equals("Computer")) {
+                d.printTurnSeparator(g.getDeck().size(), "Computer");
+                this.playComputer();
+            }
+        }
+    }
+
+    public void playHumansTurn() {
+        d.printPlayersHand(g.displayPlayersHand(g.getPlayersHand()));
+        g.removePairFromHand(g.getPlayersHand());
+
+        if (g.getRankToAskFor_Player()) {
+            g.stealOrGoFish(g.getPlayersHand(), g.getDealersHand(), g.getRankRequested());
+        }
+    }
+
+    public void playComputer() {
+        if(g.getDealersHand().size() == 0 && g.getDeck().size() != 0) {g.drawCardFromDeck(g.getDealersHand());}
+
+        g.removePairFromHand(g.getDealersHand());
+
+        g.getRankToAskFor_Computer();
+        d.printComputerAskedFor(g.getRankRequested());
+        g.stealOrGoFish(g.getDealersHand(), g.getPlayersHand(), g.getRankRequested());
+    }
+}
+
diff --git a/src/main/java/io/zipcoder/casino/Main.java b/src/main/java/io/zipcoder/casino/Main.java
new file mode 100644
index 000000000..ef25eeb1c
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Main.java
@@ -0,0 +1,9 @@
+package io.zipcoder.casino;
+
+public class Main {
+
+    public static void main(String args[]) {
+        Casino casino = new Casino();
+        casino.run();
+    }
+}
diff --git a/src/main/java/io/zipcoder/casino/Player.java b/src/main/java/io/zipcoder/casino/Player.java
new file mode 100644
index 000000000..5aae3d890
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/Player.java
@@ -0,0 +1,48 @@
+package io.zipcoder.casino;
+
+public class Player{
+
+    private String name;
+    private Double wallet = 0.0;
+    private Double currentBet = 0.0;
+
+    public Player(String name, Double initialDeposit) {
+        this.name = name;
+        this.wallet = initialDeposit;
+    }
+
+
+    public String getName() {
+        return name;
+    }
+
+
+    public Double getWallet() {
+        return wallet;
+    }
+
+    public void setWallet(Double deposit) {
+        this.wallet = wallet + deposit;
+    }
+
+
+    public Double makeBet(Double betAmount) {
+        currentBet += betAmount;
+        wallet = wallet - betAmount;
+        return currentBet;
+    }
+
+    public Double getCurrentBet() {
+        return currentBet;
+    }
+
+    public void setCurrentBet(Double currentBet) {
+        this.currentBet = currentBet;
+    }
+
+    public Double makeDeposit(Double depositAmount) {
+        wallet += depositAmount;
+        return wallet;
+    }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java
new file mode 100644
index 000000000..45298c924
--- /dev/null
+++ b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java
@@ -0,0 +1,41 @@
+package io.zipcoder.casino;
+
+import java.util.HashMap;
+
+public class PlayerWarehouse {
+
+    private HashMap<String, Player> playerGroup;
+    private HashMap<String, String> userNamePasswordMap;
+
+    public PlayerWarehouse() {
+        this.playerGroup = new HashMap<String, Player>();
+        this.userNamePasswordMap = new HashMap<String, String>();
+    }
+
+    public Player getPlayer(String userId) {
+        return this.playerGroup.get(userId);
+    }
+
+    public boolean validateUniquePlayer(String userId) {
+        if (userNamePasswordMap.containsKey(userId)) {
+            return false;
+        }
+        return true;
+    }
+
+    public void addNewPlayer(String userId, Player player, String password) {
+        playerGroup.put(userId, player);
+        userNamePasswordMap.put(userId, password);
+    }
+
+    public boolean validateLoginCredentials(String userId, String password) {
+
+
+
+        if (userNamePasswordMap.containsKey(userId) && userNamePasswordMap.get(userId).equals(password)) {
+            return true;
+        }
+    return false;
+    }
+
+}
diff --git a/src/main/java/io/zipcoder/casino/utilities/Console.java b/src/main/java/io/zipcoder/casino/utilities/Console.java
index ab896c956..ce2e5cf78 100644
--- a/src/main/java/io/zipcoder/casino/utilities/Console.java
+++ b/src/main/java/io/zipcoder/casino/utilities/Console.java
@@ -55,6 +55,7 @@ public Long getLongInput(String prompt, Object... args) {
     }
 
     public Integer getIntegerInput(String prompt, Object... args) {
+
         return getLongInput(prompt, args).intValue();
     }
 }
diff --git a/src/test/java/io/zipcoder/casino/BeetleDisplayTests.java b/src/test/java/io/zipcoder/casino/BeetleDisplayTests.java
new file mode 100644
index 000000000..f975ecc09
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/BeetleDisplayTests.java
@@ -0,0 +1,82 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BeetleDisplayTests {
+    Display d = new Display();
+    BeetleDisplay bd = new BeetleDisplay();
+
+
+    @Test
+    public void userBugIsCompleteTest() {
+        bd.userBugIsComplete();
+        String actual = "Your beetle is complete!\nYOU WIN!!!!";
+        String expected = bd.userBugIsComplete();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void opponentsBugisCompleteTest() {
+        bd.opponentsBugisComplete();
+        String actual = "Your opponents beetle is complete.\nYou lose.";
+        String expected = bd.opponentsBugisComplete();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void bothBeetlesCompleteTest() {
+        bd.bothBeetlesComplete();
+        String actual = "You both drew beetles. The game is a tie.";
+        String expected = bd.bothBeetlesComplete();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void repeatedRollResult() {
+        bd.repeatedRollResult();
+        String actual = "You already rolled that number.";
+        String expected = bd.repeatedRollResult();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void border() {
+        bd.border();
+        String actual = "======================";
+        String expected = bd.border();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void borderWithSpace() {
+        bd.borderWithSpace();
+        String actual = "\n======================\n";
+        String expected = bd.borderWithSpace();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void yourBeetle() {
+        bd.yourBeetleTitleLine();
+        String actual = "YOUR BEETLE";
+        String expected = bd.yourBeetleTitleLine();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void opponentsBeetle() {
+        bd.opponentsBeetleTitleLine();
+        String actual = "OPPONENTS BEETLE";
+        String expected = bd.opponentsBeetleTitleLine();
+
+        Assert.assertEquals(expected, actual);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/io/zipcoder/casino/BeetleServiceTest.java b/src/test/java/io/zipcoder/casino/BeetleServiceTest.java
new file mode 100644
index 000000000..8000ed119
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/BeetleServiceTest.java
@@ -0,0 +1,197 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BeetleServiceTest {
+    BeetleService service = new BeetleService();
+    BeetleDisplay display = new BeetleDisplay();
+
+    @Test
+    public void playerBeetleTest() {
+        //given
+        Player player1 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 4);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 5);
+        // and
+        String[][] expected = new String[][]{{" ","0"," "},
+                {" ","|"," "},
+                {" ","|"," "},
+                {" "," ","\\"}};
+        String[][] actual = (display.drawPlayerBeetle(service.getUsersBeetle()));
+        //assert
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void opponentBeetleTest() {
+        //given
+        Player player1 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player1);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 4);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 5);
+        // and
+        String[][] expected = new String[][]{{" ","0"," "},
+                {" ","|"," "},
+                {" ","|"," "},
+                {" "," ","\\"}};
+        String[][] actual = (display.drawPlayerBeetle(service.getOpponentsBeetle()));
+        //assert
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void completeBeetleTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 3);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 4);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 5);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 6);
+
+        Assert.assertEquals(service.getCompleteBeetle(),service.getUsersBeetle());
+
+    }
+
+    @Test
+    public void getUserRollsTest() {
+        Player human = new Player("human", 50.00);
+        Beetle beetle = new Beetle(human);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+
+        Integer expected = 2;
+        Integer actual = service.getUsersRolls().size();
+
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void tieStateTrueTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 1);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 2);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 3);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 4);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 5);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 6);
+
+        Assert.assertTrue(beetle.tieStateDoesNotExist(service.getUsersBeetle(), service.getOpponentsBeetle()));
+
+    }
+
+    @Test
+    public void tieStateFalseTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 3);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 4);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 5);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 6);
+
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 1);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 2);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 3);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 4);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 5);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 6);
+
+        Assert.assertFalse(beetle.tieStateDoesNotExist(service.getUsersBeetle(), service.getOpponentsBeetle()));
+
+    }
+
+
+    @Test
+    public void winningStateTrueTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 3);
+
+
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 1);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 2);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 3);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 4);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 5);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 6);
+
+        Assert.assertTrue(beetle.winningStateDoesNotExist(service.getUsersBeetle()));
+
+    }
+
+    @Test
+    public void winningStateFalseTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 3);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 4);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 5);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 6);
+
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 1);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 2);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 3);
+
+
+        Assert.assertFalse(beetle.winningStateDoesNotExist(service.getUsersBeetle()));
+
+    }
+
+    @Test
+    public void losingStateTrueTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 3);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 4);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 5);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 6);
+
+
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 4);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 5);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 6);
+
+        Assert.assertTrue(beetle.losingStateDoesNotExist(service.getOpponentsBeetle()));
+
+    }
+
+    @Test
+    public void losingStateFalseTest() {
+        Player player2 = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 1);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 2);
+        beetle.analyzeRoll(service.getUsersRolls(), service.getUsersBeetle(), 3);
+
+
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 1);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 2);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 3);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 4);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 5);
+        beetle.analyzeRoll(service.getOpponentsRolls(), service.getOpponentsBeetle(), 6);
+
+        Assert.assertFalse(beetle.losingStateDoesNotExist(service.getOpponentsBeetle()));
+
+    }
+
+
+}
diff --git a/src/test/java/io/zipcoder/casino/BeetleTest.java b/src/test/java/io/zipcoder/casino/BeetleTest.java
new file mode 100644
index 000000000..b1d256c27
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/BeetleTest.java
@@ -0,0 +1,155 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BeetleTest {
+
+BeetleDisplay display = new BeetleDisplay();
+
+    @Test
+    public void acceptUserBetTest() {
+        Player robot = new Player("robot", 100.00);
+        Beetle beetle = new Beetle(robot);
+
+        beetle.acceptBetFromUser(50.00);
+
+        Double actual = beetle.getPurse();
+        Double expected = 50.0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void openingBetTest() {
+        Player hubot = new Player("hubot", 100.00);
+        Beetle beetle = new Beetle(hubot);
+        beetle.tableMinimumDeposit();
+
+        Double expected = 2.0;
+        Double actual = beetle.getPurse();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void opponentBetTest() {
+        Player hubot = new Player("hubot", 100.00);
+        Beetle beetle = new Beetle(hubot);
+
+        Double expected = beetle.opponentBet(10.00);
+
+        Assert.assertTrue(expected >=5 && expected <= 15);
+
+    }
+
+    @Test (expected = NullPointerException.class)
+    public void opponentBetTest2() {
+        Player hubot = new Player("hubot", 100.00);
+        Beetle beetle = new Beetle(hubot);
+
+        Double expected = beetle.opponentBet(null);
+
+        Assert.assertTrue(expected >=5 && expected <= 15);
+
+    }
+
+    @Test
+    public void calculateRewardTest() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.tableMinimumDeposit();
+        beetle.acceptBetFromUser(50.0);
+
+        Double actual = beetle.calculateReward();
+        Double expected = 1.0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void calculateRewardTest2() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.tableMinimumDeposit();
+        beetle.acceptBetFromUser(14.00);
+
+        Double actual = beetle.calculateReward();
+        Double expected = 15.00;
+
+        Assert.assertNotEquals(expected, actual);
+    }
+
+    @Test (expected = NullPointerException.class)
+    public void calculateRewardTest3() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.tableMinimumDeposit();
+        beetle.acceptBetFromUser(null);
+
+        Double actual = beetle.calculateReward();
+        Double expected = 1.00;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void calculateLossTest() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.tableMinimumDeposit();
+        beetle.acceptBetFromUser(50.0);
+
+        Double actual = beetle.calculateLoss();
+        Double expected = 51.0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void calculateLossTest2() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.tableMinimumDeposit();
+        beetle.acceptBetFromUser(50.0);
+
+        Double actual = beetle.calculateLoss();
+        Double expected = 50.0;
+
+        Assert.assertNotEquals(expected, actual);
+    }
+
+    @Test (expected = NullPointerException.class)
+    public void calculateLossTest3() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.tableMinimumDeposit();
+        beetle.acceptBetFromUser(null);
+
+        Double actual = beetle.calculateLoss();
+        Double expected = 51.0;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void getPurseTest() {
+        Player player = new Player("player", 100.00);
+        Beetle beetle = new Beetle(player);
+
+        beetle.setPurse(43.96666667);
+
+        Double actual = beetle.getPurse();
+        Double expected = 43.97;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+
+}
diff --git a/src/test/java/io/zipcoder/casino/CasinoTest.java b/src/test/java/io/zipcoder/casino/CasinoTest.java
index e92865236..627be16f2 100644
--- a/src/test/java/io/zipcoder/casino/CasinoTest.java
+++ b/src/test/java/io/zipcoder/casino/CasinoTest.java
@@ -2,4 +2,7 @@
 
 
 public class CasinoTest {
+
+    // git push test
+
 }
diff --git a/src/test/java/io/zipcoder/casino/DisplayTest.java b/src/test/java/io/zipcoder/casino/DisplayTest.java
new file mode 100644
index 000000000..a83559138
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/DisplayTest.java
@@ -0,0 +1,13 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+public class DisplayTest {
+
+    @Test
+    public void testPrintStartScreen() {
+        Display disp = new Display();
+        disp.printWelcomeMessage();
+    }
+
+}
diff --git a/src/test/java/io/zipcoder/casino/GoFishTest.java b/src/test/java/io/zipcoder/casino/GoFishTest.java
new file mode 100644
index 000000000..6aaf34a80
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/GoFishTest.java
@@ -0,0 +1,275 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class GoFishTest {
+
+    GoFish go;
+    Player p;
+
+    @Before
+    public void setUp() {
+        p = new Player("Theresa", 500.00);
+        go = new GoFish(p);
+    }
+
+    @Test
+    public void testCreateNewDeck() {
+        // Given
+        int numberOfCards = 5;
+        String expectedAtIdx0 = "Ace of Clubs";
+        String expectedAtIdx1 = "2 of Clubs";
+        String expectedAtIdx13 = "Ace of Diamonds";
+        String expectedAtIdx28 = "3 of Hearts";
+        String expectedAtIdx51 = "King of Spades";
+
+        // When
+        go.createNewDeck();
+        ArrayList<String> actualDeck = go.getDeck();
+        String actualAtIdx0 = actualDeck.get(0);
+        String actualAtIdx1 = actualDeck.get(1);
+        String actualAtIdx13 = actualDeck.get(13);
+        String actualAtIdx28 = actualDeck.get(28);
+        String actualAtIdx51 = actualDeck.get(51);
+
+        // Then
+        Assert.assertEquals(52, actualDeck.size());
+        Assert.assertEquals(expectedAtIdx0,  actualAtIdx0);
+        Assert.assertEquals(expectedAtIdx1,  actualAtIdx1);
+        Assert.assertEquals(expectedAtIdx13,  actualAtIdx13);
+        Assert.assertEquals(expectedAtIdx28,  actualAtIdx28);
+        Assert.assertEquals(expectedAtIdx51,  actualAtIdx51);
+    }
+
+    @Test
+    public void testShuffleCards() {
+        // Given
+        go.createNewDeck();
+        ArrayList<String> unshuffledDeck = new ArrayList<String>(go.getDeck());
+
+        // When
+        go.shuffleCards();
+        ArrayList<String> shuffledDeck = go.getDeck();
+
+        // Then
+        Assert.assertNotEquals(unshuffledDeck, shuffledDeck);
+    }
+
+    @Test
+    public void testDealCards() {
+        // Given
+        go.createNewDeck();
+        ArrayList<String> actualDeck = go.getDeck();
+
+        // When
+        go.dealCards(5);
+        ArrayList<String> actualPerson1 = go.getPlayersHand();
+        ArrayList<String> actualPerson2 = go.getDealersHand();
+
+        // Then
+        Assert.assertEquals(5, actualPerson1.size());
+        Assert.assertEquals(5, actualPerson2.size());
+        Assert.assertEquals(42, actualDeck.size());
+    }
+
+    @Test
+    public void testGetRankOnCard() {
+        // Given
+        String given = "2 of Diamonds";
+        String expected = "2";
+
+        String givenCase2 = "Ace of Hearts";
+        String expectedCase2 = "Ace";
+
+        String givenCase3 = "10 of Clubs";
+        String expectedCase3 = "10";
+
+        // When
+        String actual = go.getRankOnCard(given);
+        String actualCase2 = go.getRankOnCard(givenCase2);
+        String actualCase3 = go.getRankOnCard(givenCase3);
+
+        // Then
+        Assert.assertEquals(expected, actual);
+        Assert.assertEquals(expectedCase2, actualCase2);
+        Assert.assertEquals(expectedCase3, actualCase3);
+    }
+
+    @Test
+    public void testGetValueOnCard() {
+        // Given
+        int expectedRank = 10;
+        int expectedRank2 = 9;
+        String inputRank = "Ace";
+        String inputRank2 = "9";
+
+        // When
+        int actualRank = go.getValueOfCard(inputRank);
+        int actualRank2 = go.getValueOfCard(inputRank2);
+
+        Assert.assertEquals(expectedRank, actualRank);
+        Assert.assertEquals(expectedRank2, actualRank2);
+    }
+
+    /*@Test
+    public void testDisplayPlayersHand() {
+        // Given
+        ArrayList<String> playersHand = new ArrayList<String>(Arrays.asList("2 of Diamonds", "Queen of Hearts", "3 of Spades", "4 of Clubs", "7 of Hearts"));
+        go.setPlayersHand(playersHand);
+        String expected = "2 of Diamonds\n3 of Spades\n4 of Clubs\n7 of Hearts\nQueen of Hearts\n";
+
+        // When
+        String actual = go.displayPlayersHand(go.getPlayersHand());
+
+        // Then
+        Assert.assertEquals(expected, String.valueOf(actual));
+    }*/
+
+    @Test
+    public void TestGetValueOfCard() {
+        String given = "Ace of Hearts";
+        String given1 = "2 of Clubs";
+        String given2 = "7 of Diamonds";
+        String given3 = "King of Diamonds";
+
+        System.out.println(go.getValueOfCard(go.getRankOnCard(given)));
+        System.out.println(go.getValueOfCard(go.getRankOnCard(given1)));
+        System.out.println(go.getValueOfCard(go.getRankOnCard(given2)));
+        System.out.println(go.getValueOfCard(go.getRankOnCard(given3)));
+
+    }
+
+    @Test
+    public void testGetRankToAskFor_Computer() {
+        // Given
+        go.setDealersHand(new ArrayList<String>(Arrays.asList("Ace of Hearts", "2 of Spades", "6 of Diamonds")));
+
+        // When
+        String actual = go.getRankToAskFor_Computer();
+
+        // Then
+        Assert.assertTrue(actual.equals("Ace") || actual.equals("2") || actual.equals("6"));
+    }
+
+   /* @Test
+    public void testCheckIfRankInPlayersHand() {
+        // Given
+        go.setPlayersHand(new ArrayList<String>(Arrays.asList("King of Diamonds", "4 of Spades")));
+
+        // When
+        go.setRankRequested("King");
+        boolean actual = go.checkIfRankInHand(go.getPlayersHand());
+        go.setRankRequested("4");
+        boolean actual2 = go.checkIfRankInHand(go.getPlayersHand());
+
+        // Then
+        Assert.assertTrue(actual);
+        Assert.assertTrue(actual2);
+    }
+
+    @Test
+    public void testTakeCardFromOtherPlayer() {
+        // Given
+        go.setPlayersHand(new ArrayList<String>(Arrays.asList("2 of Clubs")));
+        go.setDealersHand(new ArrayList<String>(Arrays.asList("Ace of Diamonds")));
+
+        // When
+        go.takeCardFromOtherPlayer(go.getPlayersHand(), go.getDealersHand(), "Ace");
+
+        // Then
+        ArrayList<String> expectedPlayer = new ArrayList<String>(Arrays.asList("2 of Clubs", "Ace of Diamonds"));
+        ArrayList<String> expectedDealer = new ArrayList<String>();
+
+        ArrayList<String> actualPlayer = go.getPlayersHand();
+        ArrayList<String> actualDealer = go.getDealersHand();
+
+        Assert.assertEquals(expectedPlayer, actualPlayer);
+        Assert.assertEquals(expectedDealer, actualDealer);
+    }
+
+    @Test
+    public void testDrawCardFromDeck() {
+        // Given
+        int expectedPlayerHand = 6;
+        int expectedDeckSize = 41;
+        go.setupGame(5);
+
+        // When
+        go.drawCardFromDeck(go.getPlayersHand());
+        int actualPlayerHand = go.getPlayersHand().size();
+        int actualDeckSize = go.getDeck().size();
+
+        // Then
+        Assert.assertEquals(expectedPlayerHand, actualPlayerHand);
+        Assert.assertEquals(expectedDeckSize, actualDeckSize);
+    }
+
+    @Test
+    public void testCheckPairInHand() {
+        // Given
+        go.setPlayersHand(new ArrayList<String>(Arrays.asList("King of Hearts", "King of Diamonds", "Queen of Spades")));
+
+        // When
+        String pair = go.checkPairInHand(go.getPlayersHand());
+
+        // Then
+        Assert.assertEquals("King", pair);
+    }
+
+    @Test
+    public void testRemovePairFromHand() {
+        // Given
+        go.setPlayersHand(new ArrayList<String>(Arrays.asList("King of Hearts", "King of Diamonds", "2 of Clubs", "Queen of Spades", "2 of Spades")));
+
+        // When
+        String actual = go.removePairFromHand(go.getPlayersHand());
+
+        // Then
+        Assert.assertEquals("2King", actual);
+    }
+
+    @Test
+    public void checkGameOverTrue() {
+        // Given
+        ArrayList<String> actualDeck = new ArrayList<String>();
+        go.setDeck(actualDeck);
+
+        // When
+        boolean actual = go.checkGameOver();
+
+        // Then
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void checkGameOverFalse() {
+        // Given
+        ArrayList<String> actualDeck = new ArrayList<String>(Arrays.asList("Jack of Clubs"));
+        go.setDeck(actualDeck);
+
+        // When
+        boolean actual = go.checkGameOver();
+
+        // Then
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void testCheckWinner() {
+        // Given
+        go.setPairCounts(10, 3);
+        String expected = "Player";
+
+        // When
+        String actual = go.checkForWinner();
+
+        // Then
+        Assert.assertEquals(expected, actual);
+    }
+*/
+}
diff --git a/src/test/java/io/zipcoder/casino/PlayerTest.java b/src/test/java/io/zipcoder/casino/PlayerTest.java
new file mode 100644
index 000000000..3cf290992
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/PlayerTest.java
@@ -0,0 +1,124 @@
+package io.zipcoder.casino;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PlayerTest {
+
+    @Test
+    public void PlayerConstructorTest() {
+        //Given
+        Player player1 = new Player("player1", 100.00);
+        String actual = player1.getName();
+
+        //When
+        String expected = "player1";
+
+        //Assert
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void PlayerGetAccountBalanceTest() {
+        //Given
+        Player player2 = new Player("player1", 500.00);
+        Double actual = player2.getWallet();
+        //When
+        Double expected = 500.00;
+
+        //Assert
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void PlayerSetAccountBalanceTest() {
+        //Given
+        Player player3 = new Player("player1", 500.00);
+        player3.setWallet(100.00);
+        Double actual = player3.getWallet();
+        //When
+        Double expected = 600.00;
+
+        //Assert
+        Assert.assertEquals(expected,actual);
+    }
+    @Test
+    public void PlayerMakeBetTest() {
+        //given
+        Player player4 = new Player("player1", 50.00);
+        Double expected = player4.makeBet(5.0);
+
+        //when
+        Double actual = 5.0;
+        //assert
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void PlayerMakeBetTest2() {
+        //given
+        Player player5 = new Player("player1", 50.00);
+        player5.makeBet(5.0);
+        Double expected = player5.getWallet();
+
+        //when
+        Double actual = 45.0;
+        //assert
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void PlayerMakeBetTest3() {
+        Player player6 = new Player("player1", 50.00);
+        player6.makeBet(5.0);
+        Double expected = player6.getCurrentBet();
+
+        //when
+        Double actual = 5.0;
+        //assert
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void PlayerMakeBetTest4() {
+        Player player7 = new Player("player1", 50.00);
+        player7.makeBet(5.0);
+        player7.makeBet(2.0);
+        player7.makeBet(2.0);
+        Double expected = player7.getCurrentBet();
+
+        //when
+        Double actual = 9.0;
+        //assert
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void PlayerMakeBetTest5() {
+        Player player7 = new Player("player1", 50.00);
+        player7.makeBet(5.0);
+        player7.makeBet(2.0);
+        player7.makeBet(2.0);
+        Double expected = player7.getWallet();
+
+        //when
+        Double actual = 41.0;
+        //assert
+        Assert.assertEquals(expected,actual);
+    }
+    @Test
+    public void MakeDepositTest() {
+        Player player8 = new Player("player1", 50.00);
+        player8.makeDeposit(50.00);
+
+        Double expected  = 100.00;
+        Double actual = player8.getWallet();
+
+        Assert.assertEquals(expected, actual);
+
+    }
+}
diff --git a/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java
new file mode 100644
index 000000000..66a458b03
--- /dev/null
+++ b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java
@@ -0,0 +1,6 @@
+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+public class PlayerWarehouseTest {
+}