resolved conflicts afer meging war and working

pom.xml

                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
-                    <source>7</source>
-                    <target>7</target>
+                    <source>8</source>
+                    <target>8</target>
                 </configuration>
             </plugin>
         </plugins>

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

         this.suit = suit;
     }
 
-    public CardValue getCardValue()
+    public int getCardValue()
     {
-        return cardValue;
+        return cardValue.getCardValue();
     }
 
     public void setCardValue(CardValue cardValue)

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

     private int maxBet;
     private int handSize;
     private int ante;
-    private Player playersTurn;
+    private CardPlayer playersTurn;
     private Player winner = null;
+    private Player loser = null;
     private ArrayList<CardPlayer> players = new ArrayList<CardPlayer>();
-    private ArrayList<Card> deck = new ArrayList<>();
+    private Deck deck = new Deck();
 
 
     CardGame(int minBet, int maxBet, int ante){
         card.setVisibility(true);
     }
 
-    public ArrayList<Card> getDeck() {
+    public Deck getDeck() {
         return deck;
     }
 
         }
     }
 
-    public void setDeck(ArrayList<Card> deck) {
+    public void setDeck(Deck deck) {
         this.deck = deck;
     }
 
     public int getHandSize() {
         return handSize;
     }
+
+    public CardPlayer getPlayersTurn() {
+        return playersTurn;
+    }
+
+    public void setPlayersTurn(CardPlayer playersTurn) {
+        this.playersTurn = playersTurn;
+    }
+
+    public void addNpc(){
+        addPlayers(new NPC("Opponant", getAnte()));
+    }
+
+    public void chooseStatingPlayer(){
+        //loop through the players
+        for(int i = 0; i < getPlayers().size(); i ++){
+            //if one is not an NPC
+            if(!(getPlayers().get(i).getPlayer() instanceof NPC)){
+                //set this player to have the current turn
+                setPlayersTurn(getPlayers().get(i));
+                break;
+            }
+        }
+    }
+
+    public void chooseNextTurn(){
+        if(playersTurn != null)
+        {
+            //if it is the end of the turn circle
+            if((players.indexOf(playersTurn) + 1) == players.size()){
+                //start again at the starting player
+                playersTurn = players.get(0);
+                //System.out.println("it is now " + playersTurn.getPlayer().getName() + "'s turn");
+
+            //if it is not the end of the turn circle
+            } else {
+                playersTurn = players.get(players.indexOf(playersTurn) + 1);
+                //System.out.println("it is now " + playersTurn.getPlayer().getName() + "'s turn");
+            }
+        }
+    }
+
+    public void printTurn(){
+        System.out.println("it is now " + playersTurn.getPlayer().getName() + "'s turn");
+    }
+
+    public Player getLoser() {
+        return loser;
+    }
+
+    public void setLoser(Player loser) {
+        this.loser = loser;
+    }
 }

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

     private Player player;
     private ArrayList<Card> hand = new ArrayList<>();
     private ArrayList<Card> discard = new ArrayList<>();
+    private Card playedCard = null;
+
 
     public CardPlayer(Player player){
         this.player = player;
 
         return null;
     }
+
+    public Card getPlayedCard() {
+        return playedCard;
+    }
+
+    public void setPlayedCard(Card playedCard) {
+        this.playedCard = playedCard;
+    }
+
+    public void addDiscard(ArrayList<Card> cards) {
+        this.discard.addAll(cards);
+    }
+    public ArrayList<Card> getDiscard() {
+        return discard;
+    }
+    public void setDiscard(ArrayList<Card> discard) {
+        this.discard = discard;
+    }
 }

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

 package io.zipcoder.casino;
+import java.util.ArrayList;
 import java.util.InputMismatchException;
 import java.util.Scanner;
 
 public class Console {
     private Scanner scanner = new Scanner(System.in);
-    private String[] gameLib = {"yahtzee", "war", "three card stud"};
+    private ArrayList<String> gameLib = new ArrayList<>();
     private Game game = null;
     private Player player;
     private boolean running = true;
 
-    Console(){}
+    Console(){
+        gameLib.add("yahtzee");
+        gameLib.add("war");
+        gameLib.add("three card stud");
+    }
 
     public void createAccount()
     {
         command = command.toLowerCase().trim();
         return command;
     }
+
+    public String continueAskGame(){
+        String command = "";
+
+        System.out.println("Please choose a game to play!");
+        command = getCommand();
+
+        if(gameLib.indexOf(command) == -1)
+        {
+            while(gameLib.indexOf(command) == -1)
+            {
+                Printer.noMatchingGameName(gameLib);
+                command = getCommand();
+            }
+        }
+        return command;
+    }
+
 }

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

 import java.util.ArrayList;
 import java.util.Collections;
 
-public class Deck {
-    ArrayList<Card> deck;
+public class Deck extends ArrayList<Card>{
 
     /**
      * Deck constructor will create an array of all 52 @Card 's
     }
 
     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);
+                this.add(card);
             }
         }
-        Collections.shuffle(deck);
+        Collections.shuffle(this);
     }
 
     /**
      * @return
      */
     public Card getCard(int index){
-        return this.deck.get(index);
+        return this.get(index);
     }
 
     /**
      * @return
      */
     public Card pullCard(){
-        Card tempCard = this.deck.remove(0);
+        Card tempCard = this.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

 
 public class Dice {
 
-
     private int value;
 
     public void roll(){

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

+package io.zipcoder.casino;
+
+public class NPC extends Player {
+
+    NPC(String name, int initialBalance) {
+        super(name, initialBalance);
+    }
+}

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

 package io.zipcoder.casino;
 
+import java.util.ArrayList;
+
 public class Printer {
 
-    public static void noMatchingGameName(String[] gameNames){
+    public static void noMatchingGameName(ArrayList<String> gameNames){
 
         String games = "";
 
-        for(int i = 0; i < gameNames.length; i ++){
-            games += gameNames[i] + " ";
+        for(int i = 0; i < gameNames.size(); i ++){
+            games += gameNames.get(i) + " ";
         }
         games = games.trim();
 

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

 
     }
 
-
     public void determineWinner(){
 
     }
     }
 
 
+    public void Ante(int anteAmount) {
+
+    }
+
+
     /**
      * Below 3 Implemented from Game
      */

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

 package io.zipcoder.casino;
 
-import java.util.ArrayList;
-import java.util.HashMap;
+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 {
 
     private ArrayList<Card> tableCards = new ArrayList<Card>();
+    private ArrayList<CardPlayer> warMembers = new ArrayList<CardPlayer>();
+    private Scanner scanner = new Scanner(System.in);
+    private boolean war = false;
 
     War(int minBet, int maxBet, int ante) {
         super(minBet, maxBet, ante);
     /**
      * Specific to war methods
      */
-    public void playCard(){
-        //take a card from the hand
-        //add it to the tablecard face up
+    public void playCard(boolean cardFace){
+        //if the player has cards in their hand
+        if(super.getPlayersTurn().getHand().size() > 0) {
+            //pull out a card to play
+            Card card = super.getPlayersTurn().getHand().get(0);
+            //play the card face up, on the table
+            card.setVisibility(cardFace);
+            tableCards.add(card);
+            //store the last played card in the players wrapper class
+            super.getPlayersTurn().setPlayedCard(card);
+            //remove this card from their hand
+            super.getPlayersTurn().getHand().remove(card);
+            //print the card that was played
+            if(cardFace == true) {
+                System.out.println(super.getPlayersTurn().getPlayer().getName() + " has played " + card.getName() + " and has " + super.getPlayersTurn().getHand().size() + " cards left.");
+            } else {
+                System.out.println(super.getPlayersTurn().getPlayer().getName() + " has played a card face down.");
+            }
+        //if the player has not cards in their hand but has cards in their discard, pickup their discard and play a card
+        } else if(super.getPlayersTurn().getHand().size() == 0 && super.getPlayersTurn().getDiscard().size() > 0) {
+            System.out.println(super.getPlayersTurn().getPlayer().getName() + " ran out of cards and picked up their discard pile.");
+            super.getPlayersTurn().getHand().addAll(super.getPlayersTurn().getDiscard());
+            super.getPlayersTurn().setDiscard(new ArrayList<Card>());
+            playCard(true);
+        //if the person has no cards in their hand, and no cards in discard they lose.
+        } else if(super.getPlayersTurn().getHand().size() == 0 && super.getPlayersTurn().getDiscard().size() == 0){
+            super.setLoser(super.getPlayersTurn().getPlayer());
+            System.out.println(super.getPlayersTurn().getPlayer().getName() + " has lost the match!");
+        }
     }
 
-    public void warMethod(){
-        //take three cards from your hand face down
-        //play one card face up
+    public CardPlayer warMethod(){
+        System.out.println("War!");
+
+        int max = 0;
+        CardPlayer winner = null;
+
+        //each player plays 3 cards
+        for(int i = 0; i < warMembers.size(); i ++){
+            for(int m = 0; m < 2; m ++){
+                playCard(false);
+            }
+            playCard(true);
+            super.chooseNextTurn();
+        }
+
+        //find the player with the highest value
+        winner = determineWinner(warMembers);
+        warMembers = new ArrayList<>();
+        return winner;
     }
 
-    public void determineWinner(Card player1card, Card player2card){
+    public CardPlayer determineWinner(ArrayList<CardPlayer> playerList){
+
+        int max = 0;
+        CardPlayer winner = null;
+        boolean war = false;
+
+        //loop through and get the max card value
+        for(int i = 0; i < playerList.size(); i ++){
+            CardPlayer player = playerList.get(i);
+            //if the players card is greater than the current max
+            if(player.getPlayedCard().getCardValue() > max)
+            {
+                //set their value as max
+                max = player.getPlayedCard().getCardValue();
+                //make them the winner
+                winner = player;
+                //set war to false
+                war = false;
+            }  else if (player.getPlayedCard().getCardValue() == max){
+                warMembers.add(player);
+                war = true;
+            }
+        }
 
+        if(war)
+        {
+            warMembers.add(winner);
+            winner = warMethod();
+            return winner;
+        } else if(!war)
+        {
+            System.out.println("The winner is " + winner.getPlayer().getName());
+            return winner;
+        }
+        return null;
     }
 
     /**
         super.changeTablePot(betAmount);
     }
 
+
     public void payout() {
-        if(super.getWinner() != null){
+        if(super.getWinner() != null)
+        {
             super.getWinner().changeBalance(super.getTablePot());
         }
     }
         for(int i = 0; i < super.getPlayers().size(); i ++)
         {
             CardPlayer player = super.getPlayers().get(i);
-            player.getPlayer().changeBalance(-super.getAnte());
+            player.getPlayer().changeBalance(super.getAnte() * -1);
         }
     }
 
 
     }
 
+
     public void startGame() {
-        Deck deck = new Deck();
+        System.out.println("Welcome to war!");
+        super.chooseStatingPlayer();
         payAnte();
         deal();
+        startRound();
     }
 
     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
+        while(super.getLoser() == null) {
+            System.out.println("Type play to play the top card from your pile.");
+            String input = scanner.next();
+            input = input.toLowerCase().trim();
+            if (input.equals("play")) {
+                //each player
+                for (CardPlayer player : super.getPlayers()) {
+                    //plays a card, then
+                    playCard(true);
+                    //the turn updates to be the next players.
+                    super.chooseNextTurn();
+                }
+                //determine the winner once all players play a card
+                CardPlayer winner = determineWinner(super.getPlayers());
+                System.out.println(winner.getPlayer().getName() + " has been rewarded " + tableCards.size() + " cards.");
+                //add all the table cards to the players discard
+                winner.addDiscard(tableCards);
+                //clear the table cards pile
+                tableCards = new ArrayList<Card>();
+                //if the user does not type play
+            } else {
+                //display a message
+                System.out.println("Sorry, I don't understand that command.");
+            }
+        }
     }
 
     public void deal() {
                 super.getDeck().remove(card);
             }
         }
+        System.out.println(super.getPlayersTurn().getPlayer().getName() + " has: " + super.getPlayersTurn().getHand().size() + " cards.");
     }
 }

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

         console.chooseGame();
     }
 
-}
+}