draws is a Pile

cleanup

src/CardGame.java

@@ -3,78 +3,61 @@ import java.util.ArrayList;
 public class CardGame {
     public Player[] players;
     Pile pot = new Pile();
-    Card[] draws;
+    Pile draws = new Pile();
+    int numberOfPlayers;
 
     /**
-     * @param numberOfCards
+     * @param numberOfCards Total number of cards
-     * @param numberOfPlayers
+     * @param numberOfPlayers Total number of players
      */
     public CardGame(int numberOfCards, int numberOfPlayers) {
-        Pile deck = createDeck(numberOfCards);
+        Pile deck = Pile.createDeck(numberOfCards);
-        deck.shuffle();
+        createPlayersWithCards(numberOfPlayers, deck);
+        this.numberOfPlayers = numberOfPlayers;
+    }
+
+    private void createPlayersWithCards(int numberOfPlayers, Pile deck) {
         this.players = new Player[numberOfPlayers];
-        draws = new Card[numberOfPlayers];
         int cardsPerPlayer = deck.size() / numberOfPlayers;
         for (int i = 0; i < numberOfPlayers; i++) {
             players[i] = new Player(String.valueOf(i), deck.getCardsForPlayer(cardsPerPlayer));
         }
     }
 
-    public Pile createDeck(int numberOfCards) {
-        Pile deck = new Pile();
-        for (int number = 1; number <= numberOfCards; number++) {
-            for (Card.Suit suit: Card.Suit.values()) {
-                deck.add(new Card(number, suit));
-            }
-        }
-        return deck;
-    }
-
     public void play() {
         while (noWinner()) {
-            for (int i = 0; i < draws.length; i++) {
+            draws.clear();
-                if (players[i].cardsCount() > 0) {
+            for (int i = 0; i < numberOfPlayers; i++) {
-                    System.out.printf("Player %d (%d cards): ", i, players[i].cardsCount());
+                System.out.printf("Player %d (%d cards): ", i, players[i].cardsCount());
-                    draws[i] = players[i].draw();
+                Card card = players[i].draw();
-                    System.out.printf("%d - %s\n", draws[i].number, draws[i].suit);
+                draws.add(card);
-                    pot.add(draws[i]);
+                System.out.printf("%d - %s%n", card.number, card.suit);
-                } else {
-                    System.out.printf("Player %d broke!", i);
-                }
             }
-            processWinner(draws);
+            processWinner();
         }
     }
 
-    private void processWinner(Card[] drawn) {
+    private void processWinner() {
         int maxIndex = 0;
-        Card max = drawn[maxIndex];
+        Card max = draws.get(maxIndex);
-        for (int i = 1; i < drawn.length; i++) {
+        for (int i = 1; i < numberOfPlayers; i++) {
-            if (max.number < drawn[i].number) {
+            if (max.number < draws.get(i).number) {
                 maxIndex = i;
-                max = drawn[maxIndex];
+                max = draws.get(maxIndex);
             }
         }
-        if (uniqueMaximum(drawn, max, maxIndex)) {
+        pot.addAll(draws);
-            System.out.printf("Player %d wins this round\n\n", maxIndex);
+        if (draws.uniqueMaximum(max, maxIndex)) {
+            System.out.printf("Player %d wins this round%n%n", maxIndex);
             players[maxIndex].discardPile.addAll(pot);
             pot.clear();
         } else {
-            System.out.printf("No winner in this round\n\n");
+            System.out.println("No winner in this round%n");
         }
     }
 
-    private boolean uniqueMaximum(Card[] draws, Card max, int maxIndex) {
-        for (int i = 0; i < draws.length; i++) {
-            if (maxIndex != i && max.number == draws[i].number) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     private boolean noWinner() {
-        ArrayList<Player> activePlayers = new ArrayList<Player>();
+        ArrayList<Player> activePlayers = new ArrayList<>();
         for (int i = 0; i < players.length; i++) {
             if (players[i].cardsCount() > 0) {
                 activePlayers.add(players[i]);

src/CardGameTest.java

@@ -5,6 +5,7 @@ import static org.junit.jupiter.api.Assertions.*;
 
 class CardGameTest {
     CardGame cardGame;
+
     @org.junit.jupiter.api.Test
 
     @BeforeEach

src/Main.java

@@ -1,3 +1,6 @@
+/**
+ * Card Game
+ */
 public class Main {
     public static void main(String[] args) {
         System.out.println("Card Game");

src/NoMoreCardsException.java

@@ -1,2 +0,0 @@
-public class NoMoreCardsException extends RuntimeException {
-}

src/Pile.java

@@ -3,9 +3,15 @@ import java.util.Collections;
 import java.util.Random;
 
 public class Pile extends ArrayList<Card> {
-    public void addAll(Card[] cards) {
+    public static Pile createDeck(int numberOfCards) {
-        for(Card card: cards)
+        Pile deck = new Pile();
-            add(card);
+        for (int number = 1; number <= numberOfCards; number++) {
+            for (Card.Suit suit : Card.Suit.values()) {
+                deck.add(new Card(number, suit));
+            }
+        }
+        deck.shuffle();
+        return deck;
     }
 
     public Pile getCardsForPlayer(int number) {
@@ -21,12 +27,19 @@ public class Pile extends ArrayList<Card> {
      * Fisher-Yates shuffle()
      * https://stackoverflow.com/questions/1519736/random-shuffling-of-an-array
      */
-    public void shuffle()
+    public void shuffle() {
-    {
         Random random = new Random();
-        for (int i = this.size() - 1; i > 0; i--)
+        for (int i = this.size() - 1; i > 0; i--) {
-        {
             Collections.swap(this, i, random.nextInt(i + 1));
         }
     }
+
+    public boolean uniqueMaximum(Card max, int maxIndex) {
+        for (int i = 0; i < this.size(); i++) {
+            if (maxIndex != i && max.number == this.get(i).number) {
+                return false;
+            }
+        }
+        return true;
+    }
 }

src/Player.java

@@ -1,7 +1,3 @@
-import java.util.Random;
-
-import static java.util.Collections.shuffle;
-
 public class Player {
     String name;
     Pile drawPile;
@@ -13,29 +9,15 @@ public class Player {
         this.discardPile = new Pile();
     }
 
-    public Pile getDrawPile() {
+    public Card draw() {
-        return drawPile;
+        if (drawPile.isEmpty()) {
-    }
-
-    public Pile getDiscardPile() {
-        return discardPile;
-    }
-
-    public Card draw() throws NoMoreCardsException {
-        if (getDrawPile().isEmpty()) {
-            if (getDiscardPile().isEmpty()) {
-                throw new NoMoreCardsException();
-            }
             discardPile.shuffle();
             drawPile.addAll(discardPile);
             discardPile.clear();
         }
-        if (drawPile.size() > 0) {
+        Card draw = drawPile.get(0);
-            Card draw = drawPile.get(0);
+        drawPile.remove(0);
-            drawPile.remove(0);
+        return draw;
-            return draw;
-        }
-        return null;
     }
 
     public int cardsCount() {