settled conflicts with stud

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

@@ -81,6 +81,10 @@ public abstract class CardGame {
         return handSize;
     }
 
+    public void setHandSize(int handSize) {
+        this.handSize = handSize;
+    }
+
     public CardPlayer getPlayersTurn() {
         return playersTurn;
     }

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

@@ -17,6 +17,10 @@ public class CardPlayer {
         return hand;
     }
 
+    public void setHand(ArrayList<Card> hand) {
+        this.hand = hand;
+    }
+
     public Player getPlayer() {
         return player;
     }

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

@@ -7,14 +7,16 @@ public class Console {
     private Scanner scanner = new Scanner(System.in);
     private ArrayList<String> gameLib = new ArrayList<>();
     private Game game = null;
-    private Player player;
+    private ArrayList<Player> players = new ArrayList<>();
     private boolean running = true;
 
+
     Console(){
         gameLib.add("yahtzee");
         gameLib.add("war");
         gameLib.add("stud");
         gameLib.add("quit");
+
     }
 
     public void createAccount()
@@ -25,9 +27,14 @@ public class Console {
         System.out.println("How much money are you bringing to the table?");
         int balance = getIntFromUser();
 
-        player = new Player(name, balance);
+        Player player = new Player(name, balance);
+        players.add(player);
     }
 
+    /**
+     * Currently required to make Stud a 2 player game, could later refactor to declare 'player' in createAccount method and pass to PlayerArray
+     */
+
     public void chooseGame()
     {
         while(running) {
@@ -39,21 +46,21 @@ public class Console {
                 case "war":
                     int[] warMinMax = getMinMax();
                     Game war = new War(warMinMax[0], warMinMax[1], 10);
-                    ((War) war).addPlayers(player);
+                    ((War) war).addPlayers(players.get(0));
                     ((War) war).addNpc();
                     war.startGame();
                     break;
 
-                case "three card stud":
+                case "stud":
                     int[] studMinMax = getMinMax();
                     Game stud = new Stud(studMinMax[0], studMinMax[1], 10);
-                    ((Stud) stud).addPlayers(player);
-                    ((Stud) stud).addNpc();
+                    ((Stud) stud).addPlayers(players.get(0));
+                    addStudPlayers(stud);
                     stud.startGame();
                     break;
 
                 case "yahtzee":
-                    Game yahtzee = new Yahtzee(player);
+                    Game yahtzee = new Yahtzee(players.get(0));
                     yahtzee.startGame();
                     break;
 
@@ -134,4 +141,29 @@ public class Console {
         }
         return command;
     }
+
+    public int getStudPlayers() {
+        int numOfStudPlayers = 0;
+
+        while (numOfStudPlayers <= 1) {
+
+            System.out.println("How many players are there?");
+            try {
+                numOfStudPlayers = scanner.nextInt();
+            } catch (InputMismatchException e) {
+                System.out.println("Please enter a number");
+            }
+        }
+
+        return numOfStudPlayers;
+    }
+
+    public void addStudPlayers(Game game){
+        int numPlayers = getStudPlayers();
+
+        for(int i = 1; i < numPlayers; i ++) {
+            createAccount();
+            ((Stud) game).addPlayers(players.get(i));
+        }
+    }
 }

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

@@ -1,6 +1,7 @@
 package io.zipcoder.casino;
 
 public interface Gamble {
+
      void bet(int betAmount);
      void payout();
 }

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

@@ -27,4 +27,12 @@ public class Printer {
     public static void unacceptableMinBet(){
         System.out.println("Your bet must be above $0");
     }
+
+    public static void studHandsDealt(){
+        System.out.println("Each player Dealt 3 cards");
+    }
+
+    public static void showCard(Player player, Card card){
+        System.out.println(player.getName() + " shows a " + card.getName());
+    }
 }

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

@@ -1,53 +1,270 @@
 package io.zipcoder.casino;
+import java.util.Scanner;
 
 public class Stud extends CardGame implements Gamble, Game {
+    Scanner scanner = new Scanner(System.in);
+    Console console;
+    // private int roundCount = 0;
+
     public Stud(int minBet, int maxBet, int ante) {
         super(minBet, maxBet, ante);
     }
+    
+    public void playCard(Player player, Card card) {
+        card.setVisibility(true);               //CARD isVISIBLE
+        Printer.showCard(player, card);         //PRINT card name to CONSOLE
+    }
 
-    public void deal() {
+
+    public void fold(){
 
     }
 
-    public void determineWinner(){
+    /**
+     * Determine what player wins by looping through player array and then
+     * passing each hand to the 'handValue' method
+     */
+    public CardPlayer determineWinner(){
+    int max = 0;
+    CardPlayer winner = null;
 
+    for(int i = 0; i < getPlayers().size(); i ++){
+        CardPlayer player = getPlayers().get(i);
+        int playerHandValue = handValue(player); // 'handValue' method sets 'max' value of this hand
+        if(playerHandValue > max){
+            max = playerHandValue;
+            winner = player;
+        }
+    }
+    System.out.println("The winner is " + winner.getPlayer().getName());
+    System.out.println(winner.getPlayer().getName() + "\'s hand was: " + winner.getHand().get(0).getName() + " - " + winner.getHand().get(1).getName() + " - " + winner.getHand().get(2).getName() );
+    return winner;
     }
 
-    public void fold(){
+    /**
+     * Method will return a int value, larger value means strong hand to determine the winning player
+     * @param player
+     * @return
+     */
+    public int handValue(CardPlayer player){
+        int handValue = 0;
+        int card1 = player.getHand().get(0).getCardValue();
+        int card2 = player.getHand().get(1).getCardValue();
+        int card3 = player.getHand().get(2).getCardValue();
 
+        //Three of a Kind
+        if (card1 == card2 && card1 == card3){
+            handValue = card1 * 1000000;
+        //Two pair
+        }
+        else if (card1 == card2){
+            handValue = (card1 * 10000) + card3;
+        }
+        else if (card1 == card3){
+            handValue = (card1 * 10000) + card2;
+        }
+        else if (card2 == card3){
+            handValue = (card2 * 10000) + card1;
+        //High Card
+        } else {
+            // Card1 is Highest
+            if (card1 > card2 && card1 > card3 && card2 > card3) {
+                handValue = (card1 * 100) + (card2 * 10) + card3;
+            }
+            else if (card1 > card2 && card1 > card3 && card3 > card2) {
+                handValue = (card1 * 100) + (card3 * 10) + card2;
+            }
+            // Card2 is Highest
+            else if (card2 > card1 && card2 > card3 && card1 > card3) {
+                handValue = (card2 * 100) + (card1 * 10) + card3;
+            }
+            else if (card2 > card1 && card2 > card3 && card3 > card1) {
+                handValue = (card2 * 100) + (card3 * 10) + card1;
+            }
+            // Card3 is Highest
+            else if (card3 > card1 && card3 > card2 && card1 > card3) {
+                handValue = (card3 * 100) + (card1 * 10) + card3;
+            }
+            else if (card3 > card1 && card3 > card2 && card3 > card1) {
+                handValue = (card3 * 100) + (card3 * 10) + card1;
+            }
+            else {
+                handValue = 0;
+            }
+        }
+        return handValue;
     }
 
-    /**
-     * Below 3 Implemented from Gamble
-     * @param betAmount
+
+
+
+
+
+
+    /*
+
+        create a bet method which asks the first player how much to bet
+        loops through other plays to see how they would like to react to this.
+
+        fold, call, raise, check
+
      */
+
+
+
+
+
+
     public void bet(int betAmount) {
+        super.changeTablePot(betAmount);
+        //player.changeBalance(betAmount * -1);
+    }
+
+
+
 
+
+
+
+
+
+
+
+
+
+
+
+
+    public void payout(){
+        if(super.getWinner() != null){
+            super.getWinner().changeBalance(super.getTablePot());
+        }
+        System.out.println(getWinner().getName() + " won: " + super.getTablePot());
     }
 
-    public void payout() {
+    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 Quit() {
+        System.out.println("Play again? Y : or any key to quit.");
+        String answer = scanner.next();
+        if (answer.equals("Y")){
+            startGame();
+        } else {
+            console = new Console();
+        }
     }
 
 
-    public void Ante(int anteAmount) {
+    public void startGame() {
+        // Deck deck = new Deck();     //CREATE deck for game
+        setHandSize(3);             //SET Hand Size for game(3)
+        payAnte();                  //PAY ante (all players)
+        deal();                     //DEALS cards/ hands to each player
+        startRound();               //METHOD called
 
     }
 
-
     /**
-     * Below 3 Implemented from Game
+     * Game played in this method by calling the 'gameRound' methods
      */
+    public void startRound() {
+        System.out.println("Welcome to Three Card Stud!");
+        //for (int i = 0; i < getHandSize() - 1; i++){    //Each player turns a card in hand to face up
+        gameRound1();
+        gameRound2();
+        //}
+        lastGameRound();
+        determineWinner();
+        // Payout();
+    }
 
-    public void quit() {
 
+    /**
+     * Plays through rounds that includes flipping cards face up and then betting or folding
+     */
+    public void gameRound1(){
+        for (int j = 0; j < getPlayers().size(); j++) {
+            CardPlayer player = super.getPlayers().get(j);                       //GET a player
+            playCard(player.getPlayer(), player.getHand().get(0));      //SHOW-PRINT players first CARD
+            //roundCount++;
+        }
+        for (int x = 0; x < getPlayers().size(); x++) {                          //Betting round or fold
+            CardPlayer player = super.getPlayers().get(x);
+            int bet;
+            //ask player to bet and pass amount to Bet(betAmount
+            System.out.println("Enter a bet, if 0 is entered you fold");
+//TRY- CATCH OR WHILE/IF statement
+            bet = Integer.parseInt(scanner.next());
+            if (bet == 0){
+                System.out.println(player.getPlayer().getName() + " folds.");
+                //if fold, player is removed from game
+                //if only 1 player game ends
+            } else {
+                bet(bet);
+                System.out.println(player.getPlayer().getName() + " bets: " + bet);
+            }
+        }
     }
 
-    public void startGame() {
+    public void quit() {}
 
+    /**
+     * Plays through rounds that includes flipping cards face up and then betting or folding
+     */
+    public void gameRound2(){
+        for (int j = 0; j < getPlayers().size(); j++) {
+            CardPlayer player = super.getPlayers().get(j);                       //GET a player
+            playCard(player.getPlayer(), player.getHand().get(1));      //SHOW-PRINT players first CARD
+            //roundCount++;
+        }
+        for (int x = 0; x < getPlayers().size(); x++) {                          //Betting round or fold
+            CardPlayer player = super.getPlayers().get(x);
+            int bet;
+            //ask player to bet and pass amount to Bet(betAmount
+            System.out.println("Enter a bet, if 0 is entered you fold");
+//TRY- CATCH OR WHILE/IF statement
+            bet = Integer.parseInt(scanner.next());
+            if (bet == 0){
+                System.out.println(player.getPlayer().getName() + " folds.");
+                //if fold, player is removed from game
+                //if only 1 player game ends
+            } else {
+                bet(bet);
+                System.out.println(player.getPlayer().getName() + " bets: " + bet);
+            }
+        }
+    }
+
+    /**
+     * PreCondition: Betting rounds already played
+     * Plays through round that include flipping last card face up
+     * PostCondtion: tablePot is now at max value
+     * DetermineWinner() expected to be called after this method
+     */
+    public void lastGameRound(){
+        for (int j = 0; j < getPlayers().size(); j++) {
+            CardPlayer player = super.getPlayers().get(j);              //GET a player
+            playCard(player.getPlayer(), player.getHand().get(2));      //SHOW-PRINT players first CARD
+        }
     }
 
-    public void startRound() {
 
+    /**
+     * Deal each player(and dealer) 3 face down cards in turn
+     */
+    public void deal() {
+        for(int i = 0; i < getHandSize(); i ++){                        //OUTER loop - run 3 times as there are 3 cards per hand
+            for (int j = 0; j < getPlayers().size(); j++) {             //INNER loop through each player
+                Card card = super.getDeck().pullCard();                     //PULL card from deck (removed from deck)
+                CardPlayer player = super.getPlayers().get(j);              //GET a player
+                player.getHand().add(card);                                 //ADD card to player hand
+            }
+        }
     }
 }

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

@@ -97,7 +97,6 @@ public class War extends CardGame implements Gamble, Game {
                 war = true;
             }
         }
-
         if(war)
         {
             warMembers.add(winner);
@@ -195,6 +194,9 @@ public class War extends CardGame implements Gamble, Game {
                 super.getDeck().remove(card);
             }
         }
-        System.out.println(super.getPlayersTurn().getPlayer().getName() + " has: " + super.getPlayersTurn().getHand().size() + " cards.");
+
+        System.out.println(super.getPlayersTurn().getPlayer().getName() +
+                "has: " + super.getPlayersTurn().getHand().size() + " cards.");
+
     }
 }