lalala

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

@@ -8,7 +8,6 @@ public class Die {
 
     public int getValue() {
         return value;
-
     }
 
     public void rollADice() {

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

@@ -8,16 +8,21 @@ import java.util.*;
 
 public class Yahtzee extends DiceGame {
 
-    Player aPlayer;
-    Dice diceRoller = new Dice(5);
-    Die[] dice = diceRoller.rollAll();
-    int[] diceValueCounts = new int[6];
-    Console aConsole = new Console();
-    boolean playAgain;
-    boolean scoreSheetFull = false;
-    Map<YahtzeeField, Integer> scoreSheet = new LinkedHashMap<YahtzeeField, Integer>();
-
+    //==================================================================================
+    // Fields
+    //==================================================================================
+    private Console aConsole = new Console();
+    private Player aPlayer;
+    private Map<YahtzeeField, Integer> scoreSheet = new LinkedHashMap<>();
+    private Dice diceRoller = new Dice(5);
+    private Die[] dice = diceRoller.rollAll();
+    private int[] diceValues = new int[5];
+    private int[] diceValueCounts = new int[6];
+    private boolean playAgain = true;
 
+    //==================================================================================
+    // Constructor
+    //==================================================================================
     public Yahtzee(Player aPlayer) {
         this.aPlayer = aPlayer;
     }
@@ -27,32 +32,23 @@ public class Yahtzee extends DiceGame {
     //==================================================================================
 
     public void playGame() {
-
         aConsole.println("Welcome to Yahtzee " + aPlayer.getName());
-
-        boolean playAgain = true;
         while (playAgain) {
-
             createBlankScoreSheet();
             printScoreSheet();
-
+            boolean scoreSheetFull = false;
             while (!scoreSheetFull) {
                 rollDice();
-                printDice(getDiceValues(this.dice));
-
+                printDice();
                 rollAgainLoop();
-
-                YahtzeeField fieldChoice = chooseYahtzeeField();
-                int score = scoreDice(fieldChoice);
-                updateScoreSheet(fieldChoice, score);
+                scoreRoll();
                 printScoreSheet();
                 scoreSheetFull = checkScoreSheetForCompletion();
             }
-
             int totalScore = getTotalScore();
             printEndOfGameMessage(totalScore);
+            playAgain = userInputYesNoToBoolean(aConsole.getStringInput("Do you want to play again?"));
         }
-
     }
 
     //==================================================================================
@@ -62,7 +58,7 @@ public class Yahtzee extends DiceGame {
     /*
     Create blank score sheet
      */
-    public void createBlankScoreSheet() {
+    private void createBlankScoreSheet() {
         for (YahtzeeField field : YahtzeeField.values()) {
             scoreSheet.put(field, null);
         }
@@ -71,7 +67,7 @@ public class Yahtzee extends DiceGame {
     /*
     Check score sheet for completion
      */
-    public boolean checkScoreSheetForCompletion() {
+    private boolean checkScoreSheetForCompletion() {
         for (Map.Entry<YahtzeeField, Integer> entry : scoreSheet.entrySet()) {
             Integer value = entry.getValue();
             if (value == null) {
@@ -84,17 +80,17 @@ public class Yahtzee extends DiceGame {
     /*
     Print score sheet
      */
-    public void printScoreSheet() {
+    private void printScoreSheet() {
         aConsole.println("Scoresheet: " + scoreSheet.toString());
     }
 
     /*
     Get total score
      */
-    public int getTotalScore() {
+    private int getTotalScore() {
         int sumOfUpperSection = getUpperSectionScore();
         int bonus = 0;
-        if (sumOfUpperSection >= 63){
+        if (sumOfUpperSection >= 63) {
             bonus = 35;
         }
         int sumOfLowerSection = getLowerSectionScore();
@@ -104,15 +100,15 @@ public class Yahtzee extends DiceGame {
     /*
     Get upper section score
      */
-    public int getUpperSectionScore(){
+    private int getUpperSectionScore() {
         int upperScore = 0;
         Iterator it = scoreSheet.entrySet().iterator();
-        while (it.hasNext()){
-            Map.Entry scoreEntry = (Map.Entry)it.next();
+        while (it.hasNext()) {
+            Map.Entry scoreEntry = (Map.Entry) it.next();
             if (scoreEntry.getKey() == YahtzeeField.ACES || scoreEntry.getKey() == YahtzeeField.TWOS ||
                     scoreEntry.getKey() == YahtzeeField.THREES || scoreEntry.getKey() == YahtzeeField.FOURS ||
-                    scoreEntry.getKey() == YahtzeeField.FIVES || scoreEntry.getKey() == YahtzeeField.SIXES){
-                upperScore += (int)(scoreEntry.getValue());
+                    scoreEntry.getKey() == YahtzeeField.FIVES || scoreEntry.getKey() == YahtzeeField.SIXES) {
+                upperScore += (int) (scoreEntry.getValue());
             }
         }
         return upperScore;
@@ -121,40 +117,49 @@ public class Yahtzee extends DiceGame {
     /*
     Get lower section score
      */
-    public int getLowerSectionScore(){
+    private int getLowerSectionScore() {
         int lowerScore = 0;
         Iterator it = scoreSheet.entrySet().iterator();
-        while (it.hasNext()){
-            Map.Entry scoreEntry = (Map.Entry)it.next();
+        while (it.hasNext()) {
+            Map.Entry scoreEntry = (Map.Entry) it.next();
             if (scoreEntry.getKey() == YahtzeeField.THREEOFAKIND || scoreEntry.getKey() == YahtzeeField.FOUROFAKIND ||
                     scoreEntry.getKey() == YahtzeeField.FULLHOUSE || scoreEntry.getKey() == YahtzeeField.SMSTRAIGHT ||
                     scoreEntry.getKey() == YahtzeeField.LGSTRAIGHT || scoreEntry.getKey() == YahtzeeField.YAHTZEE ||
-                    scoreEntry.getKey() == YahtzeeField.CHANCE){
-                lowerScore += (int)(scoreEntry.getValue());
+                    scoreEntry.getKey() == YahtzeeField.CHANCE) {
+                lowerScore += (int) (scoreEntry.getValue());
             }
         }
         return lowerScore;
     }
 
-     /*
-    Print end of game stats
-     */
-     public void printEndOfGameMessage(int totalScore){
-         aConsole.println("Game over!");
-         aConsole.println("Your total score is: " + totalScore);
-         if(aConsole.yesOrNo("Would you like to play again?").equalsIgnoreCase("no")){
-             playAgain= false;
-         }
-     }
+    /*
+   Print end of game stats
+    */
+    private void printEndOfGameMessage(int totalScore) {
+        aConsole.println("Game over!");
+        aConsole.println("Your total score is: " + totalScore);
+        if (aConsole.yesOrNo("Would you like to play again?").equalsIgnoreCase("no")) {
+            playAgain = false;
+        }
+    }
 
     //==================================================================================
     // SCORING ROLL METHODS
     //==================================================================================
 
     /*
+    Score roll
+     */
+    public void scoreRoll() {
+        YahtzeeField fieldChoice = chooseYahtzeeField();
+        int score = scoreDice(fieldChoice);
+        updateScoreSheet(fieldChoice, score);
+    }
+
+    /*
     See fields and formula for score
      */
-    public void printRules(){
+    public void printRules() {
         aConsole.println("Roll 5 dice up to 3 times and try to get the highest score");
     }
 
@@ -165,7 +170,7 @@ public class Yahtzee extends DiceGame {
         String userInput = aConsole.getStringInput("Which field do you want to score?").toUpperCase();
         boolean inputIsValid = isValidYahtzeeField(userInput);
 
-        while (!inputIsValid){
+        while (!inputIsValid) {
             aConsole.println("please enter valid & free yahtzee field.");
             userInput = aConsole.getStringInput("Which field do you want to score?").toUpperCase();
             inputIsValid = isValidYahtzeeField(userInput);
@@ -180,7 +185,7 @@ public class Yahtzee extends DiceGame {
     public boolean isValidYahtzeeField(String userInput) {
         for (YahtzeeField aYahtzeeField : YahtzeeField.values()) {
             if (aYahtzeeField.toString().equals(userInput)) {
-                if(scoreSheet.get(YahtzeeField.valueOf(userInput)) == null){
+                if (scoreSheet.get(YahtzeeField.valueOf(userInput)) == null) {
                     return true;
                 }
             }
@@ -191,10 +196,8 @@ public class Yahtzee extends DiceGame {
     /*
     Score dice
     */
-    public int scoreDice(YahtzeeField yahtzeeField) {
-
-        updateDiceValues();
-
+    private int scoreDice(YahtzeeField yahtzeeField) {
+        setDiceValueCounts();
         int score = 0;
         switch (yahtzeeField) {
             case ACES:
@@ -241,20 +244,10 @@ public class Yahtzee extends DiceGame {
     }
 
     /*
-    Get count of each value in dice
-    */
-    public void updateDiceValues(){
-        resetDiceValues();
-        for (Die d : dice){
-            diceValueCounts[d.getValue()-1]++;
-        }
-    }
-
-    /*
     Reset count of each value in dice
     */
-    public void resetDiceValues(){
-        for (int i=0; i < diceValueCounts.length; i++){
+    public void resetDiceValueCounts() {
+        for (int i = 0; i < diceValueCounts.length; i++) {
             diceValueCounts[i] = 0;
         }
     }
@@ -262,9 +255,9 @@ public class Yahtzee extends DiceGame {
     /*
     Check "of a kind" criteria is met
     */
-    public boolean ofAKindCriteria(int ofAKind){
-        for (int count : diceValueCounts){
-            if (count >= ofAKind){
+    public boolean ofAKindCriteria(int ofAKind) {
+        for (int count : diceValueCounts) {
+            if (count >= ofAKind) {
                 return true;
             }
         }
@@ -277,7 +270,7 @@ public class Yahtzee extends DiceGame {
     public int scoreOfAKind(boolean meetsOfAKindCriteria) {
         int score = 0;
         if (meetsOfAKindCriteria) {
-            for (Die d : dice){
+            for (Die d : dice) {
                 score += d.getValue();
             }
         }
@@ -287,9 +280,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score yahtzee
      */
-    public int scoreYahtzee(boolean meetsOfAKindCriteria){
+    private int scoreYahtzee(boolean meetsOfAKindCriteria) {
         int score = 0;
-        if (meetsOfAKindCriteria){
+        if (meetsOfAKindCriteria) {
             score = 50;
         }
         return score;
@@ -298,14 +291,14 @@ public class Yahtzee extends DiceGame {
     /*
     Check Full House criteria is met
     */
-    public boolean fullHouseCriteria(){
+    public boolean fullHouseCriteria() {
         int i = 0;
-        for (int count : diceValueCounts){
-            if (count >= 2){
+        for (int count : diceValueCounts) {
+            if (count >= 2) {
                 i++;
             }
         }
-        if(i==2){
+        if (i == 2) {
             return true;
         }
         return false;
@@ -314,9 +307,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score Full House
      */
-    public int scoreFullHouse(boolean meetsFullHouseCriteria){
+    public int scoreFullHouse(boolean meetsFullHouseCriteria) {
         int score = 0;
-        if (meetsFullHouseCriteria){
+        if (meetsFullHouseCriteria) {
             score = 25;
         }
         return score;
@@ -325,15 +318,15 @@ public class Yahtzee extends DiceGame {
     /*
     Check Small Straight criteria is met
     */
-    public boolean smStraighCriteria(){
+    public boolean smStraighCriteria() {
         boolean meetsCriteria = false;
         int i = 0;
-        for (int count : diceValueCounts){
-            if (count > 1){
+        for (int count : diceValueCounts) {
+            if (count > 1) {
                 i++;
             }
         }
-        if(i<=1){
+        if (i <= 1) {
             meetsCriteria = true;
         }
         return meetsCriteria;
@@ -342,9 +335,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score SM Straight
      */
-    public int scoreSmStraight(boolean meetsSmStraightCriteria){
+    private int scoreSmStraight(boolean meetsSmStraightCriteria) {
         int score = 0;
-        if (meetsSmStraightCriteria){
+        if (meetsSmStraightCriteria) {
             score = 30;
         }
         return score;
@@ -353,15 +346,15 @@ public class Yahtzee extends DiceGame {
     /*
     Check Large Straight criteria is met
     */
-    public boolean lgStraightCriteria(){
+    public boolean lgStraightCriteria() {
         boolean meetsCriteria = false;
         int i = 0;
-        for (int count : diceValueCounts){
-            if (count > 1){
+        for (int count : diceValueCounts) {
+            if (count > 1) {
                 i++;
             }
         }
-        if(i<1){
+        if (i < 1) {
             meetsCriteria = true;
         }
         return meetsCriteria;
@@ -370,9 +363,9 @@ public class Yahtzee extends DiceGame {
     /*
     Score LG Straight
      */
-    public int scoreLgStraight(boolean meetsLgStraightCriteria){
+    public int scoreLgStraight(boolean meetsLgStraightCriteria) {
         int score = 0;
-        if (meetsLgStraightCriteria){
+        if (meetsLgStraightCriteria) {
             score = 40;
         }
         return score;
@@ -382,7 +375,7 @@ public class Yahtzee extends DiceGame {
     Score dice "count" fields: aces, twos, threes, fours, fives, or sixes
     */
     public int scoreCountFields(int countField) {
-        return diceValueCounts[countField-1] * countField;
+        return diceValueCounts[countField - 1] * countField;
     }
 
     /*
@@ -397,14 +390,6 @@ public class Yahtzee extends DiceGame {
     //==================================================================================
 
     /*
-    Roll dice
-     */
-    public Die[] rollDice() {
-        dice = diceRoller.rollAll();
-        return dice;
-    }
-
-    /*
     Ask user if they want to roll again
      */
     public String userInputRollAgain() {
@@ -414,7 +399,7 @@ public class Yahtzee extends DiceGame {
     /*
     Convert user's choice to roll again to boolean
      */
-    public boolean userInputRollAgainBoolean(String userInputString) {
+    public boolean userInputYesNoToBoolean(String userInputString) {
         if (userInputString.equals("YES")) {
             return true;
         } else {
@@ -428,7 +413,7 @@ public class Yahtzee extends DiceGame {
     public void rollAgainLoop() {
 
         String rollAgainString = userInputRollAgain();
-        boolean rollAgain = userInputRollAgainBoolean(rollAgainString);
+        boolean rollAgain = userInputYesNoToBoolean(rollAgainString);
 
         int rollCounter = 1;
         while (rollAgain) {
@@ -437,14 +422,14 @@ public class Yahtzee extends DiceGame {
             Integer[] diceToRollAgain = turnUserInputRollAgainToArray(diceToRollAgainList);
             //roll remaining dice
             rollSelectedDiceAgain(diceToRollAgain);
-            printDice(getDiceValues(this.dice));
+            printDice();
             rollCounter++;
             if (rollCounter >= 3) {
                 break;
             }
 
             rollAgainString = userInputRollAgain();
-            rollAgain = userInputRollAgainBoolean(rollAgainString);
+            rollAgain = userInputYesNoToBoolean(rollAgainString);
         }
     }
 
@@ -458,7 +443,7 @@ public class Yahtzee extends DiceGame {
             String positionOfDiceToKeep = aConsole.getStringInput("Enter position of dice to roll again or enter to perform roll");
             if (positionOfDiceToKeep.equals("")) {
                 stillSelecting = false;
-            } else if (Integer.parseInt(positionOfDiceToKeep) > 0 || Integer.parseInt(positionOfDiceToKeep) < 6){
+            } else if (Integer.parseInt(positionOfDiceToKeep) > 0 || Integer.parseInt(positionOfDiceToKeep) < 6) {
                 diceToRollAgainList.add(Integer.parseInt(positionOfDiceToKeep));
                 stillSelecting = true;
                 aConsole.println("Enter a number between 1 and 5 or enter to roll");
@@ -474,7 +459,7 @@ public class Yahtzee extends DiceGame {
      */
     public Integer[] turnUserInputRollAgainToArray(List<Integer> diceToRollAgainList) {
         Integer[] diceToRollAgainArray = null;
-        diceToRollAgainArray = diceToRollAgainList.toArray(new Integer[diceToRollAgainList.size()]);
+        diceToRollAgainArray = diceToRollAgainList.toArray(new Integer[0]);
         return diceToRollAgainArray;
     }
 
@@ -490,20 +475,57 @@ public class Yahtzee extends DiceGame {
     /*
     Print dice
      */
-    public void printDice(int[] diceValues) {
+    public void printDice() {
         DrawYahtzeeDice diceDrawer = new DrawYahtzeeDice();
+        setDiceValues();
         aConsole.println(diceDrawer.drawYahtzeeDice(diceValues).toString());
         aConsole.println("    1           2           3           4           5    ");
     }
 
+    //==================================================================================
+    // Getters and Setters
+    //==================================================================================
+
     /*
-    Create dice values array
+    Set dice value (roll all dice)
      */
-    public int[] getDiceValues(Die[] dice){
-        int[] diceValues = new int[5];
+    public void rollDice() {
+        dice = diceRoller.rollAll();
+    }
+
+
+    /*
+    Set value count array
+    */
+    public void setDiceValueCounts() {
+        resetDiceValueCounts();
+        for (Die d : dice) {
+            diceValueCounts[d.getValue() - 1]++;
+        }
+    }
+
+    /*
+    Get value count array
+     */
+    public int[] getDiceValueCounts() {
+        return this.diceValueCounts;
+    }
+
+    /*
+    Set dice values array
+     */
+    public void setDiceValues() {
         for (int i = 0; i < dice.length; i++) {
             diceValues[i] = (dice[i].getValue());
         }
-        return diceValues;
+    }
+
+    /*
+    Get dice values array
+     */
+    public int[] getDiceValues() {
+        return this.diceValues;
     }
 }
+
+

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

@@ -19,22 +19,30 @@ public class YahtzeeTest {
     }
 
     @Test
+    public void getDiceValuesTest(){
+//        //Given
+//        Die testDie = new Die();
+//        testDie.rollADice();
+//        Die[] testDieArray = {testDie, testDie, testDie, testDie, testDie};
+//        int testDieValue = testDie.getValue();
+//        int[] expectedArray = {testDieValue, testDieValue, testDieValue, testDieValue, testDieValue};
+//        //Actual
+//        boolean actual = Arrays.equals(actualArray, expectedArray);
+//        //Expected
+//        boolean expected = true;
+//        //Test
+//        assertEquals(expected, actual);
+    }
+
+    @Test
     public void printDiceTest(){
-        //Given
-        int[] diceValuesTest = {1,2,3,4,5};
-        //Actual
-        yahtzee.printDice(diceValuesTest);
-        //Expected
-            //Print dice with values from 1-5;
-        //Test
-            //Check console display for dice values 1-5;
+        yahtzee.printDice();
     }
 
     @Test
     public void rollSelectedDiceAgainTest(){
-
         //Given
-        yahtzee.rollSelectedDiceAgain(1,3,5);
+        yahtzee.rollSelectedDiceAgain(1,2,3,4,5);
     }
 
     @Test
@@ -66,7 +74,7 @@ public class YahtzeeTest {
     @Test
     public void userInputRollAgainBooleanTest(){
         //Actual
-        boolean actual = yahtzee.userInputRollAgainBoolean("YES");
+        boolean actual = yahtzee.userInputYesNoToBoolean("YES");
         //Expected
         boolean expected = true;
         assertEquals(expected, actual);
@@ -93,19 +101,20 @@ public class YahtzeeTest {
     public void isYahtzeeFieldValidTest(){
         //Actual
         boolean actual = yahtzee.isValidYahtzeeField("ACES");
-        boolean actual2 = yahtzee.isValidYahtzeeField("ONES");
-        boolean actual3 = yahtzee.isValidYahtzeeField("TWOS");
-        boolean actual4 = yahtzee.isValidYahtzeeField("SEVENS");
         //Expected
         boolean expected = true;
-        boolean expected2 = false;
-        boolean expected3 = true;
-        boolean expected4 = false;
         //Test
         assertEquals(actual, expected);
-        assertEquals(actual2, expected2);
-        assertEquals(actual3, expected3);
-        assertEquals(actual4, expected4);
+    }
+
+    @Test
+    public void isYahtzeeFieldValidTest2(){
+        //Actual
+        boolean actual = yahtzee.isValidYahtzeeField("ONES");
+        //Expected
+        boolean expected = false;
+        //Test
+        assertEquals(actual, expected);
     }