Merge branch 'master' of https://git.zipcode.rocks/jonathan-hinds/ZCW-OOP-Casino

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

 package io.zipcoder.casino;
 
 public class Card {
-    private String suit;
+    private Suit suit;
+    private CardValue cardValue;
     private boolean isVisible;
-    private int value;
     private String name;
 
+    public Card (CardValue cardValue, Suit suit)
+    {
+        this.cardValue = cardValue;
+        this.suit = suit;
+        this.isVisible = false;
+        this.name = cardValue + " of " + suit;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public boolean isVisible() {
+        return isVisible;
+    }
+
+    public void setVisible(boolean visible) {
+        isVisible = visible;
+    }
+
     public void setVisibility(boolean visibility){
         isVisible = visibility;
     }
 
+    public Suit getSuit()
+    {
+        return suit;
+    }
+
+    public void setSuit(Suit suit)
+    {
+        this.suit = suit;
+    }
+
+    public CardValue getCardValue()
+    {
+        return cardValue;
+    }
+
+    public void setCardValue(CardValue cardValue)
+    {
+        this.cardValue = cardValue;
+    }
+
+    public enum CardValue
+    {
+        TWO(2),
+        THREE(3),
+        FOUR(4),
+        FIVE(5),
+        SIX(6),
+        SEVEN(7),
+        EIGHT(8),
+        NINE(9),
+        TEN(10),
+        JACK(11),
+        QUEEN(12),
+        KING(13),
+        ACE(14);
+
+        private int cardValue;
+
+        CardValue (int cardValue)
+        {
+            this.cardValue = cardValue;
+        }
+
+        public int getCardValue() {
+            return cardValue;
+        }
+    }
+
+    public enum Suit
+    {
+        HEARTS("HEARTS"),
+        SPADES("SPADES"),
+        CLUBS("CLUBS"),
+        DIAMONDS("DIAMONDS");
+
+        private String suitValue;
+
+        Suit (String suitValue)
+        {
+            this.suitValue = suitValue;
+        }
+
+        public String getSuitValue(){
+            return suitValue;
+        }
+
+    }
 }

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

 package io.zipcoder.casino;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.HashMap;
 
 public abstract class CardGame {
     private int minBet;
     private int maxBet;
     private int handSize;
+    private int ante;
     private Player playersTurn;
-    private Player[] players;
+    private ArrayList<CardPlayer> players;
+    private ArrayList<Card> deck = new ArrayList<>();
 
 
-    CardGame(int minBet, int maxBet){
+    CardGame(int minBet, int maxBet, int ante){
         this.minBet = minBet;
         this.maxBet = maxBet;
+        this.ante = ante;
     }
 
     //use hand size to determine dealing
 
     public void Shuffle(){
 
+        //shuffle the card stack
+
     }
 
     public void faceDown(Card card){
     public void faceUp(Card card){
         card.setVisibility(true);
     }
+
+    public ArrayList<Card> getDeck() {
+        return deck;
+    }
+
+    public ArrayList<CardPlayer> getPlayers() {
+        return players;
+    }
+
+    public void setDeck(ArrayList<Card> deck) {
+        this.deck = deck;
+    }
+
+    public int getAnte(){
+        return ante;
+    }
 }

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

     private Player player;
     private ArrayList<Card> hand = new ArrayList<>();
     private ArrayList<Card> discard = new ArrayList<>();
+
+    public ArrayList<Card> getHand(){
+        return hand;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
 }

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

 
 public class Console {
     private Game[] games;
+    private Player player;
 
     Console(){}
 
-    public void createAccount(){
-
+    public void createAccount()
+    {
+        /*
+            ask the player for their name.
+            ask the player for their starting balance
+            create the player.
+         */
     }
 
-    public void chooseGame(String gameName){
+    public void chooseGame(String gameName)
+    {
         /*
             ask the user for min max bet at the table
             ask the user which game they would like to play

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

 import java.util.Collections;
 
 public class Deck {
-    ArrayList<Card> cards = new ArrayList<Card>();
+    ArrayList<Card> deck;
+
+    /**
+     * Deck constructor will create an array of all 52 @Card 's
+     * Then, they are shuffled
+     */
+    public Deck(){
+        createDeck();
+    }
+
+    public void createDeck(){
+        this.deck = new ArrayList<>();
+
+        for (int i = 0; i < 13; i++){
+            Card.CardValue value = Card.CardValue.values()[i];
+
+            for (int j = 0; j < 4; j++){
+                Card card = new Card(value, Card.Suit.values()[j]);
+                this.deck.add(card);
+            }
+        }
+        Collections.shuffle(deck);
+    }
+
+    /**
+     * Will retrieve a card at requested index, but will NOT REMOVE
+     * Likely just for testing
+     * @param index
+     * @return
+     */
+    public Card getCard(int index){
+        return this.deck.get(index);
+    }
+
+    /**
+     * Will retrieve AND REMOVE card from ZERO INDEX
+     * @return
+     */
+    public Card pullCard(){
+        Card tempCard = this.deck.remove(0);
+        return tempCard;
+    }
+
+    /**
+     * Used to retrieve the array with instantiated deck shuffled
+     * Will RETURN DECK
+     * @return
+     */
+    public ArrayList<Card> getDeck() {
+        return this.deck;
+    }
 }

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

 package io.zipcoder.casino;
 
 public class Dice {
-    private int sides;
+
+
     private int value;
 
-    public void Roll(){
+    public void roll(){
+        value = (int) (Math.random()*6+1);
+    }
 
+    public int getValue()
+    {
+        return value;
     }
 
     public int getValue() {

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

     private Player player;
     Dice[] cup = new Dice[5];
     ScoreSheet scoreSheet = new ScoreSheet();
+
+    public DicePlayer(Player player){
+        this.player = player;
+    }
 }

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

 public interface Gamble {
      void Bet(int betAmount);
      int Payout(int payoutAmount);
-     void Ante(int anteAmount);
 }

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

 
     private ArrayList<Card> tableCards = new ArrayList<Card>();
 
-    War(int minBet, int maxBet) {
-        super(minBet, maxBet);
+    War(int minBet, int maxBet, int ante) {
+        super(minBet, maxBet, ante);
     }
 
-    public void Deal() {
-
-    }
 
     /**
      * Specific to war methods
      */
     public void playCard(){
-
+        //take a card from the hand
+        //add it to the tablecard face up
     }
 
     public void warMethod(){
-
+        //take three cards from your hand face down
+        //play one card face up
     }
 
-    public void determineWinner(){
+    public void determineWinner(Card player1card, Card player2card){
 
     }
 
      * Below 3 Implemented from Gamble
      */
     public void Bet(int betAmount) {
-
+        //add money to the pot
     }
 
     public int Payout(int payoutAmount) {
+
         return 0;
     }
 
-    public void Ante(int anteAmount) {
-
+    public void payAnte() {
+        for(int i = 0; i < super.getPlayers().size(); i ++)
+        {
+            CardPlayer player = super.getPlayers().get(i);
+            player.getPlayer().changeBalance(-super.getAnte());
+        }
     }
 
     /**
     }
 
     public void StartGame() {
-
+        Deck deck = new Deck();
+        payAnte();
+        Deal();
     }
 
     public void StartRound() {
+        //player plays a card faceup
+        //remove cards from player hand
+        //pc plays a card faceup
+        //remove cards from npc hand
+        //determinewinner
+        //add all table cards to winners discard facedown
+
+        //when player is out of cards
+        //shuffle players discard
+        //insert discard into hand facedown
+    }
 
+    public void Deal() {
+        //while there are cards in the deck
+        while(super.getDeck().size() != 0){
+            //for each player playing the game
+            for(int i = 0; i < super.getPlayers().size(); i ++)
+            {
+                //grab the card from the top (last added) to the deck
+                Card card = super.getDeck().get(super.getDeck().size() - 1);
+                //get the player whos hand we are adding the card to
+                CardPlayer player = super.getPlayers().get(i);
+                //add the card to their hand
+                player.getHand().add(card);
+            }
+        }
     }
 }

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

+package io.zipcoder.casino;
+
+import org.junit.Test;
+
+public class CardTest {
+
+    @Test
+    public void createCard(){
+        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
+        System.out.println(card.getName());
+    }
+
+    @Test
+    public void createCard2(){
+        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
+        Card card1 = new Card(Card.CardValue.QUEEN, Card.Suit.HEARTS);
+        System.out.println(card.getName());
+        System.out.println(card1.getName());
+    }
+}

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

+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DeckTest {
+
+    @Test
+    public void testDeck(){
+        //GIVEN
+        Deck deck = new Deck();
+        //WHEN
+        for (int i = 0; i < 52; i++){
+            System.out.println(deck.getCard(i).getName());
+        }
+
+        //THEN
+    }
+
+    @Test
+    public void pullCard(){
+        //GIVEN
+        Deck deck = new Deck();
+        //WHEN
+        String expected = deck.getCard(0).getName();
+        //THEN
+        Card testCard = deck.pullCard();
+        String actual = testCard.getName();
+        Assert.assertEquals(expected, actual);
+    }
+}

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

+package io.zipcoder.casino;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DiceTest {
+
+    @Test
+    public void getValueTest()
+    {
+        Dice dice = new Dice();
+        dice.roll();
+        int actual = dice.getValue();
+        boolean expected = true;
+        boolean x;
+        if (actual<=6 || actual>=1)
+        {
+            x = true;
+        }
+        else
+            {
+                x =false;
+            }
+
+        Assert.assertEquals(expected,x);
+    }
+}