Merge branch 'master' of laurengreen/ZCW-OOP-Casino into master

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

@@ -13,4 +13,5 @@ public class Dice {
     {
         return value;
     }
+
 }

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

@@ -10,4 +10,18 @@ public class DicePlayer {
     public DicePlayer(Player player){
         this.player = player;
     }
+
+    public ScoreSheet getScoreSheet() {
+        return scoreSheet;
+    }
+
+    public Dice[] getCup() {
+        return cup;
+    }
+
+    public void printCup() {
+        for(Dice d : cup) {
+            System.out.print(d.getValue() + " ");
+        }
+    }
 }

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

@@ -2,31 +2,202 @@
 
 package io.zipcoder.casino;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 
 public class ScoreSheet {
-    private Map<String, Integer> scores = new HashMap<>();
 
-    ScoreSheet(){}
+    private enum ROW{
+        ACES, TWOS, THREES, FOURS, FIVES, SIXES, THREEOFAKIND, FOUROFAKIND, FULLHOUSE, SMALLSTRAIGHT, LARGESTRAIGHT, YAHTZEE, CHANCE;
+    }
+    private Map<ROW, Integer> scores = new EnumMap<>(ROW.class);
+
+    ScoreSheet(){
+
+    }
+
+    public int getTotalScore() {
+
+        int topTotalScore = 0;
+        int bottomTotalScore = 0;
+        int index = 0;
+        for(ROW r : ROW.values()) {
+            while (index < 6) {
+                topTotalScore += scores.get(r);
+                index++;
+            }
+            if (topTotalScore >= 63) {
+                topTotalScore += 35;
+            }
+            while (index >= 6) {
+                bottomTotalScore += scores.get(r);
+                index++;
+            }
+        }
+        return topTotalScore + bottomTotalScore;
+        }
+
+    public void printScoreCard(){
+        for(ROW r : ROW.values()) {
+            System.out.println(r + ": " + scores.get(r));
+        }
 
-    public int getScore() {
-        return 0;
     }
 
-    public void setScore(int score) {
+    public void setRow(ROW row, Dice[] cup){
+
+        ArrayList<Integer> numbers = new ArrayList<>();
+        for(Dice d : cup) {
+            numbers.add(d.getValue());
+        }
+        Collections.sort(numbers);
+
+        switch(row) {
+            case ACES:
+                scores.put(ROW.ACES, scoreNumbers(numbers, 1));
+                break;
+            case TWOS:
+                scores.put(ROW.TWOS, scoreNumbers(numbers, 2));
+                break;
+            case THREES:
+                scores.put(ROW.THREES, scoreNumbers(numbers, 3));
+                break;
+            case FOURS:
+                scores.put(ROW.FOURS, scoreNumbers(numbers, 4));
+                break;
+            case FIVES:
+                scores.put(ROW.FIVES, scoreNumbers(numbers, 5));
+                break;
+            case SIXES:
+                scores.put(ROW.SIXES, scoreNumbers(numbers, 6));
+                break;
+            case THREEOFAKIND:
+                if(checkOfaKind(numbers, 3)) {
+                scores.put(ROW.THREEOFAKIND, scoreTotalDice(numbers));
+                } else {
+                    scores.put(ROW.THREEOFAKIND, 0); 
+                }
+                break;
+            case FOUROFAKIND:
+                if(checkOfaKind(numbers, 4)) {
+                    scores.put(ROW.FOUROFAKIND, scoreTotalDice(numbers));
+                } else {
+                    scores.put(ROW.FOUROFAKIND, 0);
+                }
+                break;
+            case FULLHOUSE:
+                if(checkOfaKind(numbers,5) || checkFullHouse(numbers)) {
+                    scores.put(ROW.FULLHOUSE, 25);
+                } else {
+                    scores.put(ROW.FULLHOUSE, 0);
+                }
+                break;
+            case SMALLSTRAIGHT:
+                if(checkSmallStraight(numbers)) {
+                    scores.put(ROW.SMALLSTRAIGHT, 30);
+                } else {
+                    scores.put(ROW.SMALLSTRAIGHT, 0);
+                }
+                break;
+            case LARGESTRAIGHT:
+                if(checkLargeStraight(numbers)) {
+                    scores.put(ROW.LARGESTRAIGHT, 40);
+                } else {
+                    scores.put(ROW.LARGESTRAIGHT, 0);
+                }
+                break;
+            case YAHTZEE:
+                if(checkOfaKind(numbers, 5)) {
+                    scores.put(ROW.YAHTZEE, 50);
+                } else {
+                    scores.put(ROW.YAHTZEE, 0);
+                }
+                break;
+            case CHANCE:
+                scores.put(ROW.CHANCE, scoreTotalDice(numbers));
+                break;
+        }
 
     }
 
-    public void printScore(){
+    public boolean checkFullHouse(ArrayList<Integer> numbers) {
+
+        boolean check2 = checkOfaKind(numbers, 2);
+        boolean check3 = checkOfaKind(numbers, 3);
+
+        return (check2 && check3);
+    }
+
+    public boolean checkSmallStraight(ArrayList<Integer> numbers) {
+
+        for(int i = 0; i < numbers.size() - 1; i++) {
+            if(numbers.get(i) == numbers.get(i+1)) {
+                numbers.remove(i);
+            }
+        }
+
+        while(numbers.size() > 4) {
+            if (numbers.get(0) + 1 != numbers.get(1)) {
+                numbers.remove(0);
+            } else {
+                numbers.remove(4);
+            }
+        }
+        if(numbers.size() < 4) return false;
+
+        boolean check = false;
+        if(numbers.toString().equals("[1, 2, 3, 4]") ||
+                numbers.toString().equals("[2, 3, 4, 5]") ||
+                numbers.toString().equals("[3, 4, 5, 6]")) {
+            check = true;
+        } else {
+            check = false;
+        }
+        return check;
+    }
+
+    public boolean checkLargeStraight(ArrayList<Integer> numbers) {
+
+        boolean check = false;
+        for(int i = 0; i < numbers.size() - 1; i++) {
+            if((numbers.get(i) + 1) == numbers.get(i + 1)) {
+                check = true;
+            } else {
+                check = false;
+            }
+        }
+        return check;
+    }
+
+    public boolean checkOfaKind(ArrayList<Integer> numbers, int numb) {
+
+        int[] counts = new int[6];
+
+        for (int i = 0; i < numbers.size(); i++)
+            counts[numbers.get(i) - 1]++;
 
+        for (int i: counts) {
+            if (i == numb) return true;
+        }
+        return false;
     }
 
-    public void setRow(String setRow){
+    public int scoreNumbers(ArrayList<Integer> numbers, int numb){
 
+        int count = 0;
+        for(Integer i : numbers) {
+            if(i == numb) {
+                count++;
+            }
+        }
+        return count * numb;
     }
 
-    public void calculateScore(String row, int value){
+    public int scoreTotalDice(ArrayList<Integer> numbers) {
 
+        int score = 0;
+        for(Integer i : numbers) {
+            score += i;
+        }
+        return score;
     }
 }

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

@@ -1,11 +1,17 @@
 package io.zipcoder.casino;
 
 public class Yahtzee extends DiceGame implements Game{
+
     private Dice[] cup;
+    DicePlayer dicePlayer;
 
+    public Yahtzee(Player player) {
+        this.dicePlayer = new DicePlayer(player);
+    }
 
     public void compareScore(DicePlayer player1, DicePlayer player2){
 
+        player1.getScoreSheet().getTotalScore();
     }
 
     public void reRoll(){
@@ -23,11 +29,25 @@ public class Yahtzee extends DiceGame implements Game{
 
     }
 
-    public void StartGame() {
+    public void StartGame(DicePlayer dicePlayer) {
+        Dice dice1 = new Dice();
+        Dice dice2 = new Dice();
+        Dice dice3 = new Dice();
+        Dice dice4 = new Dice();
+        Dice dice5 = new Dice();
+
+        dicePlayer.getCup()[0] = dice1;
+        dicePlayer.getCup()[1] = dice2;
+        dicePlayer.getCup()[2] = dice3;
+        dicePlayer.getCup()[3] = dice4;
+        dicePlayer.getCup()[4] = dice5;
 
     }
 
     public void StartRound() {
-
+        for(Dice d : dicePlayer.getCup()) {
+            d.roll();
+        }
+        dicePlayer.printCup();
     }
 }

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

@@ -0,0 +1,283 @@
+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+public class ScoreSheetTest {
+
+    @Test
+    public void testCheckThreeOfAKindFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkOfaKind(test, 3));
+
+    }
+
+    @Test
+    public void testCheckThreeOfAKindTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkOfaKind(test, 3));
+
+    }
+
+    @Test
+    public void testCheckFourOfAKindFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkOfaKind(test, 4));
+
+    }
+
+    @Test
+    public void testCheckFourOfAKindTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(2);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkOfaKind(test, 4));
+
+    }
+
+    @Test
+    public void testCheckYahtzeeFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkOfaKind(test, 5));
+
+    }
+
+    @Test
+    public void testCheckYahtzeeTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(2);
+        test.add(2);
+        test.add(2);
+        test.add(2);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkOfaKind(test, 5));
+
+    }
+
+    @Test
+    public void testCheckFullHouseFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkFullHouse(test));
+
+    }
+
+    @Test
+    public void testCheckFullHouseTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkFullHouse(test));
+
+    }
+
+    @Test
+    public void testCheckLargeStraightFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkLargeStraight(test));
+
+    }
+
+    @Test
+    public void testCheckLargeStraightTrue() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(1);
+        test.add(5);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkLargeStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightFalse() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertFalse(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightTrue1() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(5);
+        test.add(3);
+        test.add(5);
+        test.add(2);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightTrue2() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(1);
+        test.add(3);
+        test.add(6);
+        test.add(2);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testCheckSmallStraightTrue3() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(1);
+        test.add(3);
+        test.add(5);
+        test.add(6);
+        test.add(4);
+        Collections.sort(test);
+
+        //Then
+        Assert.assertTrue(scoreSheet.checkSmallStraight(test));
+
+    }
+
+    @Test
+    public void testScoreNumbers() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        int expected = 6;
+
+        //When
+        int actual = scoreSheet.scoreNumbers(test, 2);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testScoreTotalDice() {
+        //Given
+        ScoreSheet scoreSheet = new ScoreSheet();
+        ArrayList<Integer> test = new ArrayList<>();
+        test.add(2);
+        test.add(3);
+        test.add(2);
+        test.add(2);
+        test.add(3);
+        int expected = 12;
+
+        //When
+        int actual = scoreSheet.scoreTotalDice(test);
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+    }
+
+}