Merge branch 'dev' into deck

merge

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

@@ -6,14 +6,21 @@ public class Casino {
     Player aPlayer;
     Table aTable;
 
-    public void setaPlayer(){
-        String name= aConsole.getStringInput("What is your name?");
-        int chips= aConsole.getIntInput("How many chips do you want?");
-        aPlayer = new Player(name, chips);
+    public void setaPlayer() {
+        String name = aConsole.getStringInput("What is your name?");
+        name = name.substring(0, 1).toUpperCase() + name.substring(1);
+        int age = aConsole.getIntInput("What is your age?");
+        int chips = 0;
+        if (age > 20) {
+            chips = aConsole.getIntInput("How many chips would you like to purchase?");
+        } else {
+            aConsole.println("You are not old enough to gamble, so we won't be able to let you purchase any chips.");
+        }
+        aPlayer = new Player(name, chips, age);
     }
 
-    public void run(){
-        aTable= new Table(aPlayer);
+    public void run() {
+        aTable = new Table(aPlayer);
         aTable.startGame();
     }
 }

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

@@ -1,35 +1,36 @@
 package io.zipcoder.casino.Leviathan;
+
 import java.util.Scanner;
 
 public class Console {
 
-    public  void print(String output, Object... args) {
+    public void print(String output, Object... args) {
         System.out.printf(output, args);
     }
 
-    public  void println(String output, Object... args) {
+    public void println(String output, Object... args) {
         print(output + "\n", args);
     }
 
-    public  String getStringInput(String prompt) {
+    public String getStringInput(String prompt) {
         Scanner scanner = new Scanner(System.in);
         println(prompt);
         String userInput = scanner.nextLine();
         String userInput2 = userInput.toLowerCase();
+        if (userInput2.equals("leave")) {
+            System.out.print("You abandon your chips and sprint out of the casino.");
+            System.exit(0);
+        }
         return userInput2;
     }
 
 
-    /*public static Integer getIntegerInput(String prompt) {
-    return null;
-    }*/
-
-    public  Integer getIntInput(String prompt) {
-        Scanner scannerB = new Scanner(System.in);
+    public Integer getIntInput(String prompt) {
         int b = 0;
-        boolean good =false;
+        boolean good = false;
         println(prompt);
-        while(good == false) {
+        while (good == false) {
+            Scanner scannerB = new Scanner(System.in);
             if (scannerB.hasNextInt()) {
                 b = scannerB.nextInt();
                 good = true;
@@ -41,5 +42,4 @@ public class Console {
     }
 
 
-
 }

src/main/java/io/zipcoder/casino/Leviathan/Games/GameUtilities/Dice.java

@@ -7,26 +7,25 @@ public class Dice {
     public Dice(int numberOfDice) {
 
 
-     dice = new Die[numberOfDice];
-     for (int i = 0; i < dice.length; i++){
-         dice[i] = new Die();
-     }
-}
+        dice = new Die[numberOfDice];
+        for (int i = 0; i < dice.length; i++) {
+            dice[i] = new Die();
+        }
+    }
 
-    public Die[] getDice(){
+    public Die[] getDice() {
         return dice;
     }
 
     public Die[] rollAll() {
 
 
-        for (int i = 0; i < dice.length; i++){
-             dice[i].rollADice();
+        for (int i = 0; i < dice.length; i++) {
+            dice[i].rollADice();
 
         }
         return dice;
     }
 
 
-
 }

src/main/java/io/zipcoder/casino/Leviathan/Games/GameUtilities/Die.java

@@ -3,16 +3,16 @@ package io.zipcoder.casino.Leviathan.Games.GameUtilities;
 public class Die {
     int value;
 
-    public void setValue(){
+    public void setValue() {
     }
 
-    public int getValue(){
+    public int getValue() {
         return value;
 
     }
 
-    public  void rollADice() {
-        int rolled = (int)(Math.random()* 6)+ 1;
+    public void rollADice() {
+        int rolled = (int) (Math.random() * 6) + 1;
         value = rolled;
     }
 

src/main/java/io/zipcoder/casino/Leviathan/Games/HigherCards.java

@@ -29,25 +29,29 @@ public class  HigherCards extends CardGame implements Gambling{
              Card acard = deck.draw();
              Rank rank = acard.getRank();
              int player = rank.getValue();
+             String playervalueString=rank.toString();
              Suit suit = acard.getSuit();
              String suitString = suit.toString();
 
-             aConsole.println("Your suit is :");
+             aConsole.println("You got :%s of %s",playervalueString,suitString);
+             /*aConsole.println("Your suit is :");
              aConsole.print(suitString);
              aConsole.println("\nYour rank is :");
              String rankValue = rank.toString();
-             aConsole.println(rankValue);
+             aConsole.println(rankValue);*/
 
              Card acard2 = deck.draw();
              Rank rank2 = acard2.getRank();
+             String playervalueString2=rank2.toString();
              Suit suit2 = acard2.getSuit();
              String suitString2 = suit2.toString();
              int croupier = rank2.getValue();
-             aConsole.println("\n\nHouse suit is :");
+             aConsole.println("House got :%s of %s",playervalueString2,suitString2);
+             /*aConsole.println("\n\nHouse suit is :");
              aConsole.print(suitString2);
              aConsole.println("\nHouse rank is :");
              String rankValue2 = rank2.toString();
-             aConsole.println(rankValue2);
+             aConsole.println(rankValue2);*/
 
              int totalChips = aPlayer.getTotalChips();
              int newTotalChips = findWinner(player, croupier, wageAmount, totalChips);

src/main/java/io/zipcoder/casino/Leviathan/Games/HigherDice.java

@@ -1,7 +1,9 @@
 package io.zipcoder.casino.Leviathan.Games;
+
+import io.zipcoder.casino.Leviathan.Console;
 import io.zipcoder.casino.Leviathan.Games.GameUtilities.Die;
-import io.zipcoder.casino.Leviathan.Interfaces.*;
-import io.zipcoder.casino.Leviathan.*;
+import io.zipcoder.casino.Leviathan.Interfaces.Gambling;
+import io.zipcoder.casino.Leviathan.Player;
 
 
 public class HigherDice extends DiceGame implements Gambling {
@@ -11,6 +13,7 @@ public class HigherDice extends DiceGame implements Gambling {
     Die aDie = new Die();
     boolean playAgain = true;
 
+
     public HigherDice(Player aPlayer) {
         this.aPlayer = aPlayer;
     }
@@ -19,48 +22,52 @@ public class HigherDice extends DiceGame implements Gambling {
     public void playGame() {
         aConsole.print("Welcome to HigherDice!\nWe will both roll a die, and the higher number wins the wager.\nThe House wins on ties\n");
 
-        while(playAgain == true){
-
-        bet = wageMoney();
-        aConsole.getStringInput("Please roll your die");
-        aDie.rollADice();
-        int player = aDie.getValue();
-        aConsole.println("You rolled a " + player);
-        aDie.rollADice();
-        int croupier = aDie.getValue();
-        aConsole.println("The House rolled a " + croupier);
-        findWinner(player, croupier, bet);
-
-
-        if((aPlayer.getTotalChips() == 0) || aConsole.getStringInput("Would you like to play again?").equalsIgnoreCase("no")){
-            playAgain= false;
-        }
+        while (playAgain == true) {
+
+            bet = wageMoney();
+            aConsole.getStringInput("Please roll your die");
+            aDie.rollADice();
+            int player = aDie.getValue();
+            aConsole.println("You rolled a " + player);
+            aDie.rollADice();
+            int croupier = aDie.getValue();
+            aConsole.println("The House rolled a " + croupier);
+            findWinner(player, croupier, bet);
+
+
+            if ((aPlayer.getTotalChips() == 0)) {
+                aConsole.println("You are out of chips. You may no longer play");
+                playAgain = false;
+            } else if (aConsole.getStringInput("Would you like to play again?").equalsIgnoreCase("no")) {
+                playAgain = false;
+            }
         }
     }
 
-    public int findWinner(int player, int croupier, int wageAmount) {
+    public void findWinner(int player, int croupier, int wageAmount) {
 
         if (player > croupier) {
-
             aPlayer.setTotalChips(aPlayer.getTotalChips() + wageAmount);
-            aConsole.println("You win! Your current chip total is: "+ aPlayer.getTotalChips());
-
+            int[] change = {aPlayer.getTally()[0] + 1, aPlayer.getTally()[1]};
+            aPlayer.setTally(change);
+            aConsole.println("You win! Your current chip total is: " + aPlayer.getTotalChips());
+            aConsole.println("Your current Win/Loss Ratio is " + aPlayer.getTally()[0] + "-" + aPlayer.getTally()[1] + "\n");
         } else {
-
             aPlayer.setTotalChips(aPlayer.getTotalChips() - wageAmount);
-            aConsole.println("You lose! Your current chip total is: "+ aPlayer.getTotalChips());
-        }
+            int[] change = {aPlayer.getTally()[0], aPlayer.getTally()[1] + 1};
+            aPlayer.setTally(change);
+            aConsole.println("You lose! Your current chip total is: " + aPlayer.getTotalChips());
+            aConsole.println("Your current Win/Loss Ratio is " + aPlayer.getTally()[0] + "-" + aPlayer.getTally()[1] + "\n");
 
-        return aPlayer.getTotalChips();
+        }
     }
 
     public int wageMoney() {
 
         do {
             bet = aConsole.getIntInput("How much would you like to bet? You can only bet what you currently have.\n" +
-                    "Current chips= " + aPlayer.getTotalChips());
-
-        }while(bet > aPlayer.getTotalChips());
+                    "Current chips= " + aPlayer.getTotalChips() + "\n");
+        } while (bet > aPlayer.getTotalChips() && bet < 0);
 
         return bet;
     }

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

@@ -7,51 +7,110 @@ import java.util.*;
 public class Yahtzee extends DiceGame {
 
     Player aPlayer;
-    Dice diceRoller = new Dice(5);
+    Dice diceRoller;
     Die[] dice;
-    Console console = new Console();
-    Map<YahtzeeField, Integer> scoreSheet = new HashMap<YahtzeeField, Integer>();
+    Console console;
+    Map<YahtzeeField, Integer> scoreSheet;
 
 
     public Yahtzee(Player aPlayer) {
         this.aPlayer = aPlayer;
+        diceRoller = new Dice(5);
+        scoreSheet = new LinkedHashMap<YahtzeeField, Integer>();
         dice = diceRoller.rollAll();
     }
 
     public static void main(String[] args) {
-        Player aPlayer = new Player("eric", 20);
+        Player aPlayer = new Player("eric", 20, 18);
         Yahtzee yahtzee = new Yahtzee(aPlayer);
         yahtzee.playGame();
     }
 
+    //==================================================================================
+    // PLAY GAME METHOD
+    //==================================================================================
+
     public void playGame() {
-        rollDice();
 
-        String rollAgainString = userInputRollAgain();
-        boolean rollAgain = userInputRollAgainBoolean(rollAgainString);
+        createBlankScoreSheet();
+        printScoreSheet();
+
+        boolean scoreSheetFull = checkScoreSheetForCompletion();
+
+        while (!scoreSheetFull) {
+            rollDice();
+
+            rollAgainLoop();
+
+            YahtzeeField fieldChoice = chooseYahtzeeField();
+            int score = scoreDice(fieldChoice);
+            updateScoreSheet(fieldChoice, score);
+        }
 
-        rollAgainLoop(rollAgain);
+    }
+
+    //==================================================================================
+    // SCORE SHEET METHODS
+    //==================================================================================
+
+    /*
+    Create blank score sheet
+     */
+    public void createBlankScoreSheet(){
+        for (YahtzeeField field : YahtzeeField.values()){
+            scoreSheet.put(field, null);
+        }
+    }
 
-        YahtzeeField fieldChoice = chooseYahtzeeField();
-        scoreDice(fieldChoice);
+    /*
+    Check score sheet for completion
+     */
+    public boolean checkScoreSheetForCompletion(){
 
+        for(Map.Entry<YahtzeeField, Integer> entry : scoreSheet.entrySet()){
+            Integer value = entry.getValue();
+            if (value == null){
+                return false;
+            }
+        }
 
-        //roll remaining dice (2)
-        //If use roll, select a field
-        //See current dice
-        //Use roll or roll again?
-        //If roll again, select which dice to keep
-        //roll remaining dice (3)
-        //If use roll, select a field
-        //See current dice
-        //Select a field
+        return true;
+    }
 
-        //other things you might want to do..
-        //See fields and scoring formula
-        //see current score sheet
-        //quit game
+    /*
+    Print score sheet
+     */
+    public void printScoreSheet(){
+        console.println("Scoresheet: " + scoreSheet.toString());
     }
 
+    //==================================================================================
+    // SCORING ROLL METHODS
+    //==================================================================================
+
+    /*
+    See fields and formula for score
+     */
+
+    public YahtzeeField chooseYahtzeeField() {
+        String userInput = aConsole.getStringInput
+                ("Which field do you want to score?").toUpperCase();
+        return YahtzeeField.ACES;
+    }
+
+    public int scoreDice(YahtzeeField yahtzeeField) {
+        //take in field and dice array and give a score
+        return -1;
+    }
+
+    public void updateScoreSheet(YahtzeeField yahtzeeField, int score) {
+        //Take in field and score and update sheet
+    }
+
+    //==================================================================================
+    // ROLLING DICE METHODS
+    //==================================================================================
+
     /*
     Roll dice
      */
@@ -97,16 +156,23 @@ public class Yahtzee extends DiceGame {
     /*
     Allow the user to roll again up to 2 more times
      */
-    public void rollAgainLoop(boolean rollAgain) {
+    public void rollAgainLoop() {
+
+        String rollAgainString = userInputRollAgain();
+        boolean rollAgain = userInputRollAgainBoolean(rollAgainString);
 
         int rollCounter = 1;
-        while (rollAgain && rollCounter <= 3) {
+        while (rollCounter <= 3 && rollAgain) {
             //select the dice to keep
             Integer[] diceToRollAgain = userInputChooseDice();
             //roll remaining dice
             rollSelectedDiceAgain(diceToRollAgain);
             printDice();
             rollCounter++;
+            if (rollCounter >=3){break;}
+
+            rollAgainString = userInputRollAgain();
+            rollAgain = userInputRollAgainBoolean(rollAgainString);
         }
     }
 
@@ -140,22 +206,4 @@ public class Yahtzee extends DiceGame {
 
 
 
-    public YahtzeeField chooseYahtzeeField() {
-        String userInput = aConsole.getStringInput
-                ("Which field do you want to score?").toUpperCase();
-        return YahtzeeField.ACES;
-    }
-
-    public void scoreDice(YahtzeeField yahtzeeField) {
-        //take in field and dice array and give a score
-    }
-
-    public void updateScoreSheet(YahtzeeField yahtzeeField, int score) {
-        //Take in field and score and update sheet
-    }
-
-    public void displayScoreSheet() {
-        //print score sheet
-    }
-
 }

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

@@ -3,27 +3,47 @@ package io.zipcoder.casino.Leviathan;
 public class Player {
     String name;
     Integer totalChips;
+    int[] tally = {0, 0};
+    int age;
 
-    public Player(String name, Integer totalChips){
+    public Player(String name, Integer totalChips, int age) {
         this.name = name;
         this.totalChips = totalChips;
+        this.age = age;
 
     }
 
-    public void setName(String name){
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String name) {
         this.name = name;
     }
 
-    public String getName(){
-        return this.name;
+    public Integer getTotalChips() {
+        return this.totalChips;
     }
 
-    public void setTotalChips(Integer totalChips){
+    public void setTotalChips(Integer totalChips) {
         this.totalChips = totalChips;
     }
 
-    public Integer getTotalChips(){
-        return this.totalChips;
+    public Integer getAge() {
+        return this.age;
     }
 
+    public void setAge(Integer age) {
+        this.age = age;
+    }
+
+    public int[] getTally() {
+        return this.tally;
+    }
+
+    public void setTally(int[] tally) {
+        this.tally = tally;
+    }
+
+
 }

src/main/java/io/zipcoder/casino/Leviathan/Table.java

@@ -1,6 +1,10 @@
 package io.zipcoder.casino.Leviathan;
-import io.zipcoder.casino.Leviathan.Interfaces.*;
-import io.zipcoder.casino.Leviathan.Games.*;
+
+import io.zipcoder.casino.Leviathan.Games.BlackJack;
+import io.zipcoder.casino.Leviathan.Games.HigherCards;
+import io.zipcoder.casino.Leviathan.Games.HigherDice;
+import io.zipcoder.casino.Leviathan.Games.Yahtzee;
+import io.zipcoder.casino.Leviathan.Interfaces.Game;
 
 
 public class Table {
@@ -14,35 +18,61 @@ public class Table {
     }
 
     public void startGame() {
-        Boolean result = false;
-        aConsole.println("Welcome to Casino");
-        aConsole.println("Choose the game");
-        aConsole.println("1.Higher Dice\n2.Higher Card\n3.Black Jack\n4.Yahtzee\n\n");
-
-        int choice = aConsole.getIntInput("Enter your choice");
-        if (choice == 1)//Higher Dice
-        {
-            HigherDice higherDice = new HigherDice(aPlayer);
-            higherDice.playGame();
-        } else if (choice == 2)//Higher Cards
-        {
-            HigherCards higherCards = new HigherCards(aPlayer);
-            higherCards.playGame();
-        } else if (choice == 3) {
-            BlackJack blackJack=new BlackJack(aPlayer);
-            blackJack.playGame();
-        } else if (choice == 4) {
-            Yahtzee yahtzee = new Yahtzee(aPlayer);
-            yahtzee.playGame();
-        }
-        if (result.equals(true)) {
-            aConsole.println("Congrats! You Won");
-            aConsole.println("Your current available Chips");
-            String availableChips = aPlayer.getTotalChips().toString();
-            aConsole.println(availableChips);
-        } else {
-            aConsole.println("You Lose");
+        boolean play = true;
+        boolean played = false;
+        aConsole.println("Welcome to The Leviathan Casino " + aPlayer.getName() + "!");
 
+        while (play == true) {
+            if (played == true) {
+                aConsole.println("Welcome back to the selection table " + aPlayer.getName());
+                aConsole.println("Your current chip total is " + aPlayer.getTotalChips());
+            }
+            int choice = 0;
+            aConsole.println("Choose a game to play:");
+            if (aPlayer.getTotalChips() > 0) {
+                aConsole.println("1.Higher Dice\n2.Higher Card\n3.Black Jack\n4.Yahtzee\n5.Buy more Chips\n6.Cash Out\n\n");
+                choice = aConsole.getIntInput("Enter your choice");
+            } else {
+                while (choice < 4) {
+                    aConsole.println("It looks like you don't have any chips. You'll need chips to play any gambling games.");
+                    aConsole.println("4.Yahtzee\n5.Buy more Chips\n6.Cash Out\n\n");
+                    choice = aConsole.getIntInput("Enter your choice");
+                }
+            }
+            if (choice == 1)//Higher Dice
+            {
+                aGame = new HigherDice(aPlayer);
+                aGame.playGame();
+                played = true;
+            } else if (choice == 2)//Higher Cards
+            {
+                aGame = new HigherCards(aPlayer);
+                aGame.playGame();
+                played = true;
+            } else if (choice == 3) //BlackJack
+            {
+                aGame = new BlackJack(aPlayer);
+                aGame.playGame();
+                played = true;
+                aConsole.println("You Lose");
+            } else if (choice == 4) //Yahtzee
+            {
+                aGame = new Yahtzee(aPlayer);
+                aGame.playGame();
+                played = true;
+            } else if (choice == 5) // Chips
+            {
+                aPlayer.setTotalChips(aPlayer.getTotalChips() + aConsole.getIntInput("How many more chips would you like?"));
+                aConsole.println("Great! Here you go! Good Luck!");
+            } else if (choice == 6) // Cash Out
+            {
+                play = false;
+                aConsole.println("Thank you for coming to the Leviathan Casino " + aPlayer.getName());
+                aConsole.println("You've cashed out " + aPlayer.getTotalChips() + " chips");
+                aConsole.println("Please come again!");
+            } else {
+                aConsole.println("That is not an option " + aPlayer.getName() + "... Do better");
+            }
         }
 
     }

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

@@ -1,11 +1,8 @@
 package io.zipcoder.casino;
 
-
-        import io.zipcoder.casino.Leviathan.Games.GameUtilities.Card;
-        import org.junit.Before;
-        import org.junit.Test;
-
-        import static org.junit.Assert.assertEquals;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
 
 public class BlackJackTest {
 

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

@@ -10,7 +10,7 @@ public class HigherCardsTest {
     @Test
     public void testFindAWinner()
     {
-        Player aplayer =new Player("Aleena",2000);
+        Player aplayer =new Player("Aleena",2000, 21);
         HigherCards higherCards=new HigherCards(aplayer);
 
         int expected=2500;

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

@@ -5,13 +5,12 @@ import org.junit.Before;
 import org.junit.Test;
 import io.zipcoder.casino.Leviathan.Games.*;
 import io.zipcoder.casino.Leviathan.*;
-import io.zipcoder.casino.Leviathan.Games.GameUtilities.*;
 
 /**
  * The test class HigherDiceTest.
  */
 public class HigherDiceTest {
-    Player aPlayer = new Player("Chad", 500);
+    Player aPlayer = new Player("Chad", 2000, 27);
     HigherDice test = new HigherDice(aPlayer);
     /**
      * Default constructor for test class DiceTest
@@ -33,10 +32,10 @@ public class HigherDiceTest {
     @Test
     public void findWinnerTest(){
         //Given
-
+        test.findWinner(10,2,500);
         //When
         int expected=2500;
-        int actual=test.findWinner(10,2,500);
+        int actual=aPlayer.getTotalChips();
 
 
         //Result

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

@@ -0,0 +1,56 @@
+package io.zipcoder.casino;
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import io.zipcoder.casino.Leviathan.*;
+
+    /**
+     * The test class HigherDiceTest.
+     */
+    public class TableTest {
+        Player aPlayer = new Player("Chad", 500, 27);
+        Table table = new Table(aPlayer);
+        /**
+         * Default constructor for test class DiceTest
+         */
+        public TableTest()
+        {
+        }
+
+        /**
+         * Sets up the test fixture.
+         *
+         * Called before every test case method.
+         */
+        @Before
+        public void setUp()
+        {
+        }
+
+        /**@Test
+        public void findWinnerTest(){
+            //Given
+
+            //When
+            int expected=2500;
+            int actual=test.findWinner(10,2,500);
+
+
+            //Result
+            assertEquals(actual,expected);
+
+        }*/
+
+        /**
+         * Tears down the test fixture.
+         *
+         * Called after every test case method.
+         */
+        @After
+        public void tearDown()
+        {
+        }
+    }
+

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

@@ -16,7 +16,7 @@ public class YahtzeeTest {
     Console console = new Console();
 
     public YahtzeeTest(){
-        this.aPlayer = new Player("eric", 20);
+        this.aPlayer = new Player("eric", 20, 18);
         this.yahtzee = new Yahtzee(aPlayer);
     }