yaaay

src/main/java/io/zipcoder/casino/CardGame/BlackJack/BlackJack.java

 import io.zipcoder.casino.CardGame.Card;
 import io.zipcoder.casino.CardGame.CardGame;
 import io.zipcoder.casino.CardGame.Deck;
+import io.zipcoder.casino.CardGame.Face;
 import io.zipcoder.casino.Interfaces.Gamble;
 import io.zipcoder.casino.Player;
 
 
 public class BlackJack extends CardGame implements Gamble {
 
-    private ArrayList<BlackJackPlayer> blackJackPlayers;
-    private int minBet;
-    private ArrayList<Card> wastepile;
-    private ArrayList<Card> dealerHand;
-    private Deck deck;
-    private boolean justDealt;
-    private int numOfTurns;
+    private ArrayList<BlackJackPlayer> blackJackPlayers = new ArrayList<>();
+    private final int minBet = 50;
+    private ArrayList<Card> wastepile = new ArrayList<>();
+    private Deck deck = new Deck();
+    private boolean justDealt = false;
+    private int numOfTurns = 0;
+    private BlackJackPlayer dealer = new BlackJackPlayer(new Dealer());
+
 
     public BlackJack(Player player) {
         BlackJackPlayer blackJackPlayer = new BlackJackPlayer(player);
-        this.blackJackPlayers = new ArrayList<BlackJackPlayer>();
+        blackJackPlayers.add(dealer);
         this.blackJackPlayers.add(blackJackPlayer);
-        this.minBet = 100;
-        this.wastepile = new ArrayList<Card>();
-        this.dealerHand = new ArrayList<Card>();
-        this.deck = new Deck();
-        this.justDealt = false;
-        this.numOfTurns = 0;
     }
 
-    // basically draw testestestetstsetsetstest
-    public void hit(BlackJackPlayer blackJackPlayer) {
+    public void hit(BlackJackPlayer player) {
         setJustDealt(false);
-        Card playerCard1 = deck.draw();
-        blackJackPlayer.addToHand(playerCard1);
-        System.out.println(blackJackPlayer.getPlayerHand().toString());
-    }
+        Card card = deck.draw();
+        player.addToHand(card);
 
-    public void flip() {
-        // shoulder technically be card.setCovered(false); or something like that
-        boolean covered = false;
+        if (countPlayerHand(player).get(0) > 21 || (countPlayerHand(player).size() == 2 && countPlayerHand(player).get(1) > 21)) {
+            System.out.println("Your Current Hand: \n" + formatHand(player.getPlayerHand()) + "\nHand Value: " + formatHandValue(countPlayerHand(player)) + "\nToo high, you lose!");
+        } else {
+            System.out.println("Your Current Hand: \n" + formatHand(player.getPlayerHand()) + "\nHand Value: " + formatHandValue(countPlayerHand(player)));
+        }
     }
 
-    public void split() {
+//    public void flip() {
+//        // shoulder technically be card.setCovered(false); or something like that
+//        boolean covered = false;
+//    }
+
+    public void split(BlackJackPlayer player) {
+
+        System.out.println(player.getPlayerHand() + "\n");
+
+        Card movingCard = player.getPlayerHand().get(1);
+
+        if (justDealt && player.getPlayerHand().get(0).getFace() == player.getPlayerHand().get(1).getFace()) {
+            ArrayList<Card> newHand = player.createNewHand();
+            newHand.add(movingCard);
+            player.getPlayerHand().remove(movingCard);
+        }
+
+        System.out.println(player.getPlayerHand() + " " + player.getSecondHand());
         setJustDealt(false);
+
         // must be the same card value
     }
 
         // (end turn?) what does "take a turn" actually initiate
     }
 
-    public int countHand(BlackJackPlayer blackJackPlayer) {
-        int handSum = 0;
+    public int calculate_AceIsOne(BlackJackPlayer player) {
+        ArrayList<Card> playerHand = player.getPlayerHand();
+        int aceIsOne = 0;
+
+        for (int i = 0; i < player.getPlayerHand().size(); i++) {
+            if (playerHand.get(i).getFace() == Face.ACE) {
+                aceIsOne += playerHand.get(i).getFace().getPrimaryValue();
+            } else {
+                aceIsOne += playerHand.get(i).getFace().getSecondaryValue();
+            }
+        }
+
+        return aceIsOne;
+    }
+
+    public int calculate_Standard(BlackJackPlayer player) {
+        ArrayList<Card> playerHand = player.getPlayerHand();
+        int aceIsEleven = 0;
 
-        for (int i = 0; i < blackJackPlayer.getPlayerHand().size(); i++) {
-            handSum += (blackJackPlayer.getPlayerHand().get(i).getFace().getSecondaryValue());
+        for (int i = 0; i < player.getPlayerHand().size(); i++) {
+            aceIsEleven += playerHand.get(i).getFace().getSecondaryValue();
         }
+
+        return aceIsEleven;
+    }
+
+    public ArrayList<Integer> countPlayerHand(BlackJackPlayer player) {
+        ArrayList<Integer> handSum = new ArrayList<>();
+        Integer aceIsOne;
+        Integer aceIsEleven;
+        Integer noAce;
+
+        if (player.hasAce() && calculate_Standard(player) > 21) {
+            player.setHandValue(calculate_AceIsOne(player));
+            aceIsOne = player.getHandValue();
+            handSum.add(aceIsOne);
+
+        } else if (player.hasAce() && calculate_Standard(player) < 21) {
+            player.setHandValue(calculate_AceIsOne(player));
+            aceIsOne = player.getHandValue();
+            handSum.add(aceIsOne);
+
+            player.setHandValue(calculate_Standard(player));
+            aceIsEleven = player.getHandValue();
+            handSum.add(aceIsEleven);
+
+        } else {
+            player.setHandValue(calculate_Standard(player));
+            noAce = player.getHandValue();
+            handSum.add(noAce);
+        }
+
         return handSum;
     }
 
-    public void deal(BlackJackPlayer blackJackPlayer) {
-        // BlackJackPlayer player1 = blackJackPlayers.get(playerIndex);
-        // blackJackPlayers.add(blackJackPlayer);
-        // should we move this to start instead? we would also need to deal for each player if multiple
+    public void deal() {
         deck.shuffle();
-        Card playerCard1 = deck.draw();
-        blackJackPlayer.addToHand(playerCard1);
 
-        Card dealerCard1 = deck.draw();
-        dealerHand.add(dealerCard1);
-        System.out.println("Mystery Card");
-
-        Card playerCard2 = deck.draw();
-        blackJackPlayer.addToHand(playerCard2);
+        for (int i = 0; i < 2; i++) {
+            for (BlackJackPlayer player : this.blackJackPlayers) {
+                Card card = deck.draw();
+                player.addToHand(card);
+            }
+        }
 
-        Card dealerCard2 = deck.draw();
-        dealerHand.add(dealerCard2);
-        System.out.println(dealerCard2);
+        System.out.println("Your Current Hand: \n" + formatHand(this.blackJackPlayers.get(1).getPlayerHand()) + "\nHand Value: " + formatHandValue(countPlayerHand(this.blackJackPlayers.get(1))) + "\n");
+        System.out.println("Dealer's Current Hand: \nMYSTERY-CARD || " + formatHand(dealer.getDealerHand()) + "\nHand Value: ??" + "\n");
 
         setJustDealt(true);
     }
         return blackJackPlayers.get(index);
     }
 
+    public BlackJackPlayer getDealer() {
+        return dealer;
+    }
+
     public void start() {
         Scanner reader = new Scanner(System.in);
         System.out.println("Enter an initial bet: ");
     public void setJustDealt(boolean justDealt) {
         this.justDealt = justDealt;
     }
+
+    public String formatHand(ArrayList<Card> array) {
+        String stringHand = "";
+
+        String uglyArray = array.toString();
+
+        for (int i = 0; i < uglyArray.length(); i++) {
+            if (uglyArray.charAt(i) != ' ' && uglyArray.charAt(i) != '[' && uglyArray.charAt(i) != ']' && uglyArray.charAt(i) != ',') {
+                stringHand += uglyArray.charAt(i);
+            } else if (uglyArray.charAt(i) == ' ') {
+                stringHand += " || ";
+            }
+        }
+
+        return stringHand;
+    }
+
+    public String formatHandValue(ArrayList<Integer> array) {
+        String stringHandValue = "";
+
+        String uglyArray = array.toString();
+
+        for (int i = 0; i < uglyArray.length(); i++) {
+            if (uglyArray.charAt(i) != ' ' && uglyArray.charAt(i) != '[' && uglyArray.charAt(i) != ']' && uglyArray.charAt(i) != ',') {
+                stringHandValue += uglyArray.charAt(i);
+            } else if (uglyArray.charAt(i) == ' ') {
+                stringHandValue += " or ";
+            }
+        }
+
+        return stringHandValue;
+    }
+
 }

src/main/java/io/zipcoder/casino/CardGame/BlackJack/BlackJackPlayer.java

 package io.zipcoder.casino.CardGame.BlackJack;
 
 import io.zipcoder.casino.CardGame.Card;
+import io.zipcoder.casino.CardGame.Face;
 import io.zipcoder.casino.Player;
 
 import java.util.ArrayList;
     private Player player;
 
     private int initialBet;
-    private int handValue;
-    private ArrayList<Card> playerHand;
-    private int betPot;
+    private int handValue = 0;
+    private ArrayList<Card> playerHand = new ArrayList<>();
+    private ArrayList<Card> newHand;
+    private int betPot = 0;
 
     public BlackJackPlayer(Player player) {
         this.player = player;
-        this.handValue = 0;
-        this.playerHand = new ArrayList<Card>();
-        this.betPot = 0;
     }
 
     public void addToHand(Card card){
-        playerHand.add(card);
+        this.playerHand.add(card);
+    }
+
+    public boolean hasAce() {
+        ArrayList<Face> onlyFaces = new ArrayList<>();
+        for (Card card : playerHand) {
+            onlyFaces.add(card.getFace());
+        }
+        return onlyFaces.contains(Face.ACE);
     }
 
     public ArrayList<Card> getPlayerHand() {
-        return playerHand;
+        return this.playerHand;
+    }
+
+    public ArrayList<Card> createNewHand() {
+        newHand = new ArrayList<>();
+        return this.newHand;
+    }
+
+    public ArrayList<Card> getSecondHand() {
+        return this.newHand;
+    }
+
+    public ArrayList<Card> getDealerHand() {
+        ArrayList<Card> dealerHandRemoveMystery = new ArrayList<>();
+
+        for (int i = 1; i < this.playerHand.size(); i++) {
+           dealerHandRemoveMystery.add(this.playerHand.get(i));
+        }
+
+        return dealerHandRemoveMystery;
     }
 
     public Player getPlayer() {
-        return player;
+        return this.player;
     }
 
     public int getInitialBet() {
-        return initialBet;
+        return this.initialBet;
     }
 
     public void addToBetPot(int amount) {
     }
 
     public int getBetPot() {
-        return betPot;
+        return this.betPot;
     }
 
     public void setInitialBet(int amount){
         this.initialBet = amount;
     }
 
+    public int getHandValue() {
+        return this.handValue;
+    }
+
+    public void setHandValue(int value) {
+        this.handValue = value;
+    }
+
 }

src/main/java/io/zipcoder/casino/CardGame/BlackJack/Dealer.java

+package io.zipcoder.casino.CardGame.BlackJack;
+
+import io.zipcoder.casino.Player;
+
+public class Dealer extends Player {
+
+    public Dealer() { }
+
+}

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

     public void setName(String name) {
         this.name = name;
     }
+
+
+
+
+    public Player() { }
+
+
+
 }

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

 import io.zipcoder.casino.CardGame.BlackJack.BlackJackPlayer;
 import io.zipcoder.casino.CardGame.Card;
 import io.zipcoder.casino.CardGame.Deck;
+import io.zipcoder.casino.CardGame.Face;
+import io.zipcoder.casino.CardGame.Suit;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 
 public class BlackJackTest {
     Deck deck = new Deck();
     Player player = new Player("Jack Black");
     BlackJack blackJack = new BlackJack(player);
-    BlackJackPlayer testPlayer = blackJack.getPlayer(0);
+    BlackJackPlayer testPlayer = blackJack.getPlayer(1);
     ArrayList<Card> testHand = testPlayer.getPlayerHand();
 
     @Test
-    public void testDeal() {
-        blackJack.deal(testPlayer);
+    public void testHit() {
+        blackJack.deal();
+        blackJack.hit(testPlayer);
+
+        int expected = 3;
+        int actual = testHand.size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testSplit() {
+        blackJack.setJustDealt(true);
+        Card seven1 = new Card(Suit.HEARTS, Face.SEVEN);
+        Card seven2 = new Card(Suit.SPADES, Face.SEVEN);
+
+        testHand.add(seven1);
+        testHand.add(seven2);
+
+        blackJack.split(testPlayer);
+
+        Face expected = testPlayer.getPlayerHand().get(0).getFace();
+        Face actual = testPlayer.getSecondHand().get(0).getFace();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testDeal_player() {
+        blackJack.deal();
 
         int expected = 2;
         int actual = testHand.size();
     }
 
     @Test
-    public void testCountHand() {
-        testPlayer.addToHand(deck.draw());
-        testPlayer.addToHand(deck.draw());
+    public void testDeal_dealer() {
+        blackJack.deal();
+
+        int expected = 2;
+        int actual = blackJack.getDealer().getPlayerHand().size();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testCountPlayerHand_HasAce_OneOrEleven() {
+        Card ace = new Card(Suit.HEARTS, Face.ACE);
+        Card two = new Card(Suit.HEARTS, Face.TWO);
+        Card six = new Card(Suit.HEARTS, Face.SIX);
+
+        testHand.add(ace);
+        testHand.add(two);
+        testHand.add(six);
+
+        int total_aceEqualsOne = 9;
+        int total_aceEqualsEleven = 19;
+
+        ArrayList<Integer> expected = new ArrayList<>();
+        expected.add(total_aceEqualsOne);
+        expected.add(total_aceEqualsEleven);
+        ArrayList<Integer>  actual = blackJack.countPlayerHand(testPlayer);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testCountPlayerHand_HasAce_CantBeEleven() {
+        Card ace = new Card(Suit.HEARTS, Face.ACE);
+        Card king = deck.draw();
+        Card queen = deck.draw();
 
-        System.out.println(testHand);
+        testHand.add(ace);
+        testHand.add(king);
+        testHand.add(queen);
 
-        int expected = 25;
-        int actual = blackJack.countHand(testPlayer);
+        int total_aceEqualsOne = 21;      // int total_aceEqualsEleven = 31;
+
+        ArrayList<Integer> expected = new ArrayList<>();
+        expected.add(total_aceEqualsOne);
+        ArrayList<Integer>  actual = blackJack.countPlayerHand(testPlayer);
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testCountPlayerHand_NoAce() {
+        Card king = deck.draw();
+        Card two = new Card(Suit.HEARTS, Face.TWO);
+        Card six = new Card(Suit.HEARTS, Face.SIX);
+
+        testHand.add(king);
+        testHand.add(two);
+        testHand.add(six);
+
+        int total = 18;
+
+        ArrayList<Integer> expected = new ArrayList<>();
+        expected.add(total);
+        ArrayList<Integer>  actual = blackJack.countPlayerHand(testPlayer);
 
         Assert.assertEquals(expected, actual);
     }
     @Test
     public void testJustDealt() {
         blackJack.setJustDealt(false);
-        System.out.println(blackJack.getJustDealt());
+
+        boolean expected = false;
+        boolean actual = blackJack.getJustDealt();
+
+        Assert.assertEquals(expected, actual);
     }
 
     @Test
-    public void testDoubleDown(){
+    public void testDoubleDown() {
         blackJack.setJustDealt(true);
         testPlayer.setInitialBet(blackJack.betAmount(50, testPlayer));
         blackJack.doubleDown(testPlayer);
         Assert.assertEquals(expected, actual);
     }
 
+    @Test
+    public void testPlayerHasAce_True() {
+        Card ace = new Card(Suit.HEARTS, Face.ACE);
+
+        testHand.add(ace);
+        testHand.add(deck.draw());
+        testHand.add(deck.draw());
+
+        boolean expected = true;
+        boolean actual = testPlayer.hasAce();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testPlayerHasAce_False() {
+        testHand.add(deck.draw());
+        testHand.add(deck.draw());
+        testHand.add(deck.draw());
+
+        boolean expected = false;
+        boolean actual = testPlayer.hasAce();
+
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
 }