merge

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

         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;
     }
         return suit;
     }
 
-    public void setSuit(Suit suit)
-    {
-        this.suit = suit;
-    }
-
     public int getCardValue()
     {
         return cardValue.getCardValue();
     }
 
-    public void setCardValue(CardValue cardValue)
-    {
-        this.cardValue = cardValue;
-    }
-
     public enum CardValue
     {
         TWO(2),
         Suit (String suitValue)
         {
             this.suitValue = suitValue;
-        }
-
-        public String getSuitValue(){
-            return suitValue;
-        }
-
-    }
+        }}
 }

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

 public abstract class CardGame {
 
     private int tablePot;
-    private int minBet;
-    private int maxBet;
     private int handSize;
     private int ante;
     private CardPlayer playersTurn;
         this.ante = ante;
     }
 
-    //use hand size to determine dealing
-    // public abstract void deal();
-    // public abstract void deal(ArrayList<CardPlayer> players); // NEEDED FOR STUD
-
-    public void shuffle(){
-
-        //shuffle the card stack
-
-    }
-
     public Deck getDeck() {
         return deck;
     }
         }
     }
 
-
     public int getAnte(){
         return ante;
     }
         addPlayers(new NPC("Opponant", getAnte()));
     }
 
-    public void chooseStatingPlayer(){
+    public void chooseStartingPlayer(){
         //loop through the players
         for(int i = 0; i < getPlayers().size(); i ++){
             //if one is not an NPC

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

                         Printer.printMessage("Invalid bet amount entered, min bet for slot is $1 and max $100 ");
                         break;
                     }
-                    Game slot= new SlotMachine(slotBet1);
+                    Game slot= new SlotMachine(slotBet1, player);
                     game = slot;
                     slot.startGame();
                     ((SlotMachine) slot).slotResult();

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

     String word2="";
     String word3="";
     double totalBet=0;
+    Player player;
+
+    public SlotMachine(int betAmount, Player player) {
 
-    public SlotMachine(int betAmount) {
         this.betAmount = betAmount;
+        this.player = player;
     }
 
     @Override
     public void bet(int betAmount) {
 
         this.betAmount= betAmount;
+        player.changeBalance(-betAmount);
+
     }
 
     public void payout(){
+        getPlayer().changeBalance(payoutAmt);
         Printer.printMessage("Your payout amount for slot machine is: $" + payoutAmt + "\n");
+
     }
 
     @Override
         }
         Printer.printMessage("Your slot is in progress" + "\n");
 
-        try {
-            Thread.sleep(3000);
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-
-
-        outputword = "";
+        startRound();
+    }
 
+    public void generateWords() {
         Random rand = new Random();
 
         generateWords(rand);
                 word3 = word;
             }
         }
+
+        outputword= "[ " + word1+ " ]" + "   " + "[ " + word2 + " ]" + "   "+ "[ " + word3 + " ]" + "\n" ;
+
     }
 
     public void slotResult()
     {
-            outputword= "[ " + word1+ " ]" + "   " + "[ " + word2 + " ]" + "   "+ "[ " + word3 + " ]" + "\n" ;
-
             if(((!word1.equals(word2)) )&& ((!word1.equals(word3))) && ((!word2.equals(word3)))){
 
                 outputword= outputword + "\n"+" You have won $0";
-                payoutAmt=0;
+                setPayoutAmt(0);
             }
             else if( (word1.equals(word2) && (!word1.equals(word3))) || ((word1.equals(word3)) && (!word1.equals(word2))) || ((word2.equals(word3)) && (!word2.equals(word1)))){
 
                 outputword= outputword + "\n" +" You have won $" + (betAmount*2);
-                payoutAmt=betAmount*2;
+                setPayoutAmt(betAmount*2);
             }
 
 
-            else if(word1.equals(word2) && word1.equals(word3)  /*&& ((word2.equals(word1)) && (word2.equals(word3))) && ( (word3.equals(word1)) && (word3.equals(word2)))*/){
+            else if(word1.equals(word2) && word1.equals(word3)) {
                 outputword= outputword + "\n" + "You have won $" + (betAmount*3);
-                payoutAmt=betAmount*3;
+                setPayoutAmt(betAmount*3);
             }
 
             Printer.printMessage(( outputword + "\n" ));
 
     @Override
     public void startRound() {
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
 
+        generateWords();
     }
+
     public int getPayoutAmt() {
 
         return payoutAmt;
     }
+
+    public void setPayoutAmt(int payoutAmt) {
+        this.payoutAmt = payoutAmt;
+    }
+
     public void setWord1(String word1) {
 
         this.word1 = word1;
     public void setWord3(String word3) {
         this.word3 = word3;
     }
+
+    public String getOutputword() {
+        return outputword;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
 }
 

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

 package io.zipcoder.casino;
 
 import java.util.ArrayList;
+import java.util.Scanner;
 
 public class Stud extends CardGame implements Game {
     Console console = new Console();
         Printer.printMessage(player.getName() + " shows a " + card.getName());         //PRINT card name to CONSOLE
     }
 
-
     public boolean getIsDealt(){
         return isDealt;
     }
 
-
     /**
      * Determine what player wins by looping through player array and then
      * passing each hand to the 'handValue' method
     public void payAnte(ArrayList<CardPlayer> players) {
         for(int i = 0; i < super.getPlayers().size(); i ++)
         {
-            players.get(i).getPlayer().changeBalance(-super.getAnte());
+            //players.get(i).getPlayer().changeBalance(-super.getAnte());
+            CardPlayer player = super.getPlayers().get(i);
+            player.getPlayer().changeBalance(-super.getAnte());
         }
     }
 
     public void startGame() {
-        setHandSize(3);             //SET Hand Size for game(3)
-        payAnte(this.getPlayers());                  //PAY ante (all players)
-        deal(this.getPlayers());                     //DEALS cards/ hands to each player
-        startRound();               //METHOD called
+        setHandSize(3);                 //SET Hand Size for game(3)
+        payAnte(this.getPlayers());     //PAY ante (all players)
+        deal(this.getPlayers());        //DEALS cards/ hands to each player
+        startRound();                   //METHOD called
 
     }
 
      * Deal each player(and dealer) 3 face down cards in turn
      */
     public void deal(ArrayList<CardPlayer> players) {
-        for(int i = 0; i < getHandSize(); i ++){                        //OUTER loop - run 3 times as there are 3 cards per hand
-            for (int j = 0; j < players.size(); j++) {             //INNER loop through each player
-                players.get(j).getHand().add(getDeck().pullCard());                                 //ADD card to player hand
+        for(int i = 0; i < getHandSize(); i ++){
+            for (int j = 0; j < players.size(); j++) {
+                players.get(j).getHand().add(getDeck().pullCard());
             }
         }
         isDealt = true;
         return isCardFlipped;
     }
 
-    public void quit() {}
-    // public void payout(){ }
+    public void setScanner(Scanner scanner){
+        this.console.setScanner(scanner);
+    }
 }
 

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

 package io.zipcoder.casino;
 
 import java.util.*;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.regex.Pattern;
-import java.util.concurrent.TimeUnit;
 
 public class War extends CardGame implements Gamble, Game {
 
         }
     }
 
+
     public void startGame(){
         Printer.printMessage("Welcome to War!");
-        super.chooseStatingPlayer();
+        super.chooseStartingPlayer();
         payAnte();
         deal();
         startRound();
     }
 
+
+
     public void startRound() {
         while(super.getLoser() == null) {
             String input = console.getCMDFromUser("Type 'FLIP' to play the card at the top of your pile");
                 Printer.printMessage(winner.getPlayer().getName() + " has been rewarded " + tableCards.size() + " cards.");
                 winner.addDiscard(tableCards);
                 tableCards = new ArrayList<Card>();
-            }else if(input.equals("quit")){
-                Printer.printMessage("Thanks for playing chump!");
-                console.getScanner().close();
             } else {
                 Printer.printMessage("Sorry, I don't understand that command.");
             }
         }
         Printer.printMessage(super.getPlayersTurn().getPlayer().getName() + "has: " + super.getPlayersTurn().getHand().size() + " cards.");
     }
+
+    public void setScanner(Scanner scanner) {
+        this.console.setScanner(scanner);
+    }
+
+    public ArrayList<CardPlayer> getWarMembers() {
+        return warMembers;
+    }
 }

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

 package io.zipcoder.casino;
 
 import java.util.ArrayList;
-import java.util.Scanner;
 
 public class Yahtzee extends DiceGame implements Game, Gamble {
 
                 int rollChoice = console.getIntFromUser("Would you like to:\n1. Roll all dice again.\n2. Roll some dice again.\n3. Stop rolling and score.\nNumber of Selection: ");
                 String diceToRoll = "";
                 if(rollChoice == 2) {
-                    diceToRoll = console.getLineFromUser("Which numbers would you like to reroll? List the numbers separated by spaces.");
+                    Console console2 = new Console();
+                    diceToRoll = console2.getLineFromUser("Which numbers would you like to reroll? List the numbers separated by spaces.");
                 }
                 rollOptions(rollChoice, diceToRoll); }
 

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

 package io.zipcoder.casino;
 
+import org.junit.Assert;
 import org.junit.Test;
 
-import javax.smartcardio.Card;
-
 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());
-//    }
+    @Test
+    public void testCreateCard(){
+        Card card = new Card(Card.CardValue.TWO, Card.Suit.CLUBS);
+        String expected = "TWO of CLUBS";
+        String actual = card.getName();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetSuit(){
+        Card card = new Card(Card.CardValue.THREE, Card.Suit.DIAMONDS);
+        Card.Suit expected = Card.Suit.DIAMONDS;
+        Card.Suit actual = card.getSuit();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testGetCardValue(){
+        Card card = new Card(Card.CardValue.ACE, Card.Suit.HEARTS);
+        int expected = 14;
+        int actual = card.getCardValue();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testVisibility(){
+        Card card = new Card(Card.CardValue.KING, Card.Suit.SPADES);
+        boolean before = card.isVisible();
+        card.setVisibility(true);
+        boolean after = card.isVisible();
+        Assert.assertNotEquals(before, after);
+    }
+
 }

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

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.Assert;
-
 import java.util.Random;
 
 
+
 public class SlotTest {
     private int betAmount = 10;
     private SlotMachine slotmachine = new SlotMachine(betAmount);
 
+    Player player = new Player("Bob", 400);
+
     @Test
     public void testSlotResult1(){
         String word1="MOUSE";
         String word2="MOUSE";
         String word3="MOUSE";
         //given
+        SlotMachine slotmachine = new SlotMachine(betAmount, player);
         slotmachine.setWord1(word1);
         slotmachine.setWord2(word2);
         slotmachine.setWord3(word3);
 
 
         //given
+        SlotMachine slotmachine = new SlotMachine(betAmount, player);
         slotmachine.setWord1(word1);
         slotmachine.setWord2(word2);
         slotmachine.setWord3(word3);
         String word3="CAT";
 
         //given
-        SlotMachine slotmachine = new SlotMachine(betAmount);
+        SlotMachine slotmachine = new SlotMachine(betAmount, player);
 
         slotmachine.setWord1(word1);
         slotmachine.setWord2(word2);
         slotmachine.slotResult();
         int payout=slotmachine.getPayoutAmt();
         Assert.assertEquals(0,payout);
+    }
+
+    @Test
+    public void testGenerateWords() {
+        //Given
+        SlotMachine game = new SlotMachine(100, player);
+        String before = game.getOutputword();
+
+        //When
+        game.generateWords();
+        String after = game.getOutputword();
+
+        //Then
+        Assert.assertNotEquals(before, after);
+
+
+    }
+
+    @Test
+    public void testBet() {
+        //Given
+        SlotMachine game = new SlotMachine(100, player);
+        int expected = 300;
+
+        //When
+        game.bet(100);
+        int actual = game.getPlayer().getCurrentBalance();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
+
+    }
+
+    @Test
+    public void testPayout() {
+        //Given
+        SlotMachine game = new SlotMachine(100, player);
+        int expected = 500;
+
+        //When
+        game.bet(100);
+        game.setPayoutAmt(200);
+        game.payout();
+        int actual = game.getPlayer().getCurrentBalance();
+
+        //Then
+        Assert.assertEquals(expected, actual);
+
 
     }
 
     }
 
     @Test
-    public void testGenerateWords(){
+    public void testGenerateWords2(){
         Random random = new Random(1);
 
 

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

         cardsTest1.add(cardSix); cardsTest1.add(cardFive); cardsTest1.add(cardFour);
         this.cardPlayer1.setHand(cardsTest1);
 
+
         ArrayList<Card> cardsTest2 = new ArrayList<>();
         Player player2 = new Player("Player2", 10);
         this.cardPlayer2 = new CardPlayer(player2);
         players.add(this.cardPlayer1);
         players.add(this.cardPlayer2);
 
+        stud.addPlayers(player1, player2);
+
     }
 
     @Test
         boolean expected = true;
         //THEN
         boolean actual = stud.getIsDealt();
-
         Assert.assertEquals(expected, actual);
     }
 
     @Test //Either payAnte or Test is broken, Ante is not deducted. Test set to pass
     public void payAnteTest(){
-        stud.payAnte(players);
-        //WHEN @Before
-        int expected = 10;
-        //THEN
-        int actual = players.get(0).getPlayer().getCurrentBalance();
-
-        Assert.assertEquals(expected, actual);
+       stud.payAnte(stud.getPlayers());
+       int expect = 0;
+       int actual = stud.getPlayers().get(0).getPlayer().getCurrentBalance();
+       Assert.assertEquals(expect, actual);
     }
 
     @Test
 
         Assert.assertEquals(expected, actual);
     }
+
+//    @Test
+//    public void testStartRound(){
+//
+//        String input = "flip \n";
+//        stud.deal(players);
+//        System.out.println(players.get(0).getHand().size());
+//
+//        //System.out.println(cardPlayer1.getHand().size());
+//
+//        stud.setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+//        try {
+//            stud.startRound();
+//        } catch (NoSuchElementException e) {
+//
+//        }
+//
+//
+//
+//
+//        //Assert.assertTrue(war.getPlayersTurn() instanceof CardPlayer);
+//    }
 }
 /*
     CODE FOR TRASH PANDAS

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

 import org.junit.Assert;
 import org.junit.Test;
 
+import java.io.ByteArrayInputStream;
+import java.util.ArrayList;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+
 public class WarTest {
 
     @Test
         War war = new War(10);
         Player player = new Player("Jon", 100);
         war.addPlayers(player);
-        war.chooseStatingPlayer();
+        war.chooseStartingPlayer();
         war.deal();
         war.getPlayers().get(0).setDiscard(deck);
 
         War war = new War(10);
         Player player = new Player("Jon", 100);
         war.addPlayers(player);
-        war.chooseStatingPlayer();
+        war.chooseStartingPlayer();
         war.playCard(false);
 
         Assert.assertEquals(war.getLoser(), player);
     }
 
+    @Test
+    public void warDealTest(){
+        War war = new War(10);
+        war.addPlayers(new Player("Jon", 100));
+        war.chooseStartingPlayer();
+        war.deal();
+
+        Assert.assertTrue(war.getPlayers().get(0).getHand().size() == 52);
+    }
+
+    @Test
+    public void warEachPlayerPlayCardTest(){
+        War war = new War(10);
+        war.addPlayers(new Player("Jon", 100), new Player("Jose", 200));
+
+        war.chooseStartingPlayer();
+        war.deal();
+        war.eachPlayerPlayCard();
+
+        int toalHand = 0;
+
+        for(CardPlayer player : war.getPlayers()){
+            toalHand += player.getHand().size();
+        }
+        Assert.assertTrue(toalHand == 50);
+    }
+
+    @Test
+    public void testWarStartGame(){
+        War war = new War(10);
+        Player player1 = new Player("Jose", 100);
+        Player player2 = new Player("Lauren", 200);
+        war.addPlayers(player1, player2);
+        war.chooseStartingPlayer();
+        war.deal();
+
+        String input = "flip \n";
+
+
+            war.setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+            try {
+                war.startGame();
+            } catch (NoSuchElementException e) {
+
+            }
+
+
+        Assert.assertTrue(war.getPlayersTurn() instanceof CardPlayer);
+    }
+
+    @Test
+    public void testWarQuit(){
+        War war = new War(10);
+        Player player1 = new Player("Jose", 100);
+        Player player2 = new Player("Lauren", 200);
+        war.addPlayers(player1, player2);
+        war.chooseStartingPlayer();
+        CardPlayer startPlayer = war.getPlayersTurn();
+        war.deal();
+
+        String input = "quit \n";
+
+
+        war.setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+        try {
+            war.startGame();
+        } catch (NoSuchElementException e) {
+
+        }
+
+
+       Assert.assertTrue(war.getPlayersTurn() == startPlayer);
+    }
+
+    @Test
+    public void testWarMethod(){
+        War war = new War(10);
+        Player player1 = new Player("Jose", 100);
+        Player player2 = new Player("Lauren", 200);
+        war.addPlayers(player1, player2);
+        war.chooseStartingPlayer();
+        CardPlayer startPlayer = war.getPlayersTurn();
+
+        ArrayList<Card> hand1 = new ArrayList<>();
+        hand1.add(new Card(Card.CardValue.FOUR, Card.Suit.HEARTS));
+        hand1.add(new Card(Card.CardValue.FOUR, Card.Suit.HEARTS));
+        hand1.add(new Card(Card.CardValue.THREE, Card.Suit.HEARTS));
+        hand1.add(new Card(Card.CardValue.TWO, Card.Suit.HEARTS));
+        hand1.add(new Card(Card.CardValue.ACE, Card.Suit.HEARTS));
+
+        ArrayList<Card> hand2 = new ArrayList<>();
+        hand2.add(new Card(Card.CardValue.FOUR, Card.Suit.HEARTS));
+        hand2.add(new Card(Card.CardValue.KING, Card.Suit.HEARTS));
+        hand2.add(new Card(Card.CardValue.JACK, Card.Suit.HEARTS));
+        hand2.add(new Card(Card.CardValue.QUEEN, Card.Suit.HEARTS));
+        hand2.add(new Card(Card.CardValue.KING, Card.Suit.HEARTS));
+
+        String input = "flip \n";
+
+        war.getPlayers().get(0).setHand(hand1);
+        war.getPlayers().get(1).setHand(hand2);
+
+        war.setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+        try {
+            war.startRound();
+        } catch (NoSuchElementException e) {
+
+        }
+
+        Assert.assertTrue(war.getPlayers().get(0).getHand().size() == 1);
+    }
+
 }