[🚀 사이클2 - 미션 (블랙잭 베팅)] 에버 미션 제출합니다.

README.md

@@ -10,33 +10,41 @@
    [예외처리] 쉼표 외의 다른 문자를 구분자로 한 경우 IllegalArgumentException 예외를 발생시킨다.
 
    [예외처리] 입력값이 공백일 경우 IllegalArgumentException 예외를 발생시킨다.
+
+**2. [입력] 게임에 참여한 사람의 배팅 금액을 입력 받는다.**
+
+   [예외처리] 입력값이 공백일 경우 IllegalArgumentException 예외를 발생시킨다.
 
-**2. [중간 과정] 딜러와 사용자에게 카드를 2장씩 나누어준다.**
+   [예외처리] 입력값이 숫자가 아닐 경우 IllegalArgumentException 예외를 발생시킨다.
+
+   [예외처리] 입력값이 0 이하일 경우 IllegalArgumentException 예외를 발생시킨다.
+
+**3. [중간 과정] 딜러와 사용자에게 카드를 2장씩 나누어준다.**
 
    [카드 조건] 덱은 1개만 사용한다.(A ~ K : 13 * 4 = 52장)
 
-**3. [중간 과정] 딜러와 사용자의 최초 카드 합계를 구하며, 블랙잭 여부를 판단한다.**
+**4. [중간 과정] 딜러와 사용자의 최초 카드 합계를 구하며, 블랙잭 여부를 판단한다.**
 
    [ACE 조건] ACE가 11이어도 21이 넘지 않는 경우에는 11, 넘는 경우에는 1로 계산한다.
 
-**4. [출력] 카드 현황을 출력한다.**
+**5. [출력] 카드 현황을 출력한다.**
 
    [출력 조건] 딜러는 첫 번째 카드만 출력한다.
 
-**5. [입력] 사용자별로 카드 추가 지급 여부를 입력 받는다.**
+**6. [입력] 사용자별로 카드 추가 지급 여부를 입력 받는다.**
 
    [예외처리] y, n 외의 다른 문자일 경우 IllegalArgumentException 예외를 발생시킨다.
 
    [입력 조건] 모든 사용자가 추가 지급을 완료할 때까지 반복한다.
 
    [지급 조건] 사용자가 y를 입력하고, 사용자의 현재 카드 합계가 21미만일 경우에 카드를 지급한다.
 
-**6. [출력] 사용자별로 지급 현황을 출력한다.**
+**7. [출력] 사용자별로 지급 현황을 출력한다.**
 
-**7. [출력] 딜러의 카드 합계가 17 이상이 일 될 때까지 추가 지급 현황을 출력한다.**
+**8. [출력] 딜러의 카드 합계가 17 이상이 일 될 때까지 추가 지급 현황을 출력한다.**
 
-**8. [출력] 사용자별 카드 현황 및 결과를 출력한다.**
+**9. [출력] 사용자별 카드 현황 및 결과를 출력한다.**
 
-**9. [중간 과정] 최종 승패 여부를 계산한다.**
-    
-**10. [출력] 최종 승패를 출력한다.**
+**10. [중간 과정] 최종 승패 및 수익을 계산한다.**
+
+**11. [출력] 참여자별 최종 수익을 출력한다.**

src/main/java/blackjack/Application.java

@@ -6,7 +6,7 @@
 public class Application {
 
     public static void main(String[] args) {
-        BlackjackController blackjackController = new BlackjackController(new CardProvider());
+        BlackjackController blackjackController = new BlackjackController(new BlackjackGame(new CardProvider()));
         blackjackController.run();
     }
 }

src/main/java/blackjack/BlackjackGame.java

@@ -0,0 +1,91 @@
+package blackjack;
+
+import static blackjack.util.ExceptionHandler.retryUntilSuccess;
+
+import blackjack.model.bet.BetAmount;
+import blackjack.model.bet.BetAmounts;
+import blackjack.model.card.CardProvider;
+import blackjack.model.command.HitCommand;
+import blackjack.model.gameresult.ProfitResult;
+import blackjack.model.user.User;
+import blackjack.model.user.Users;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class BlackjackGame {
+
+    private final CardProvider cardProvider;
+
+    public BlackjackGame(CardProvider cardProvider) {
+        this.cardProvider = cardProvider;
+    }
+
+    public Users createUsers(Supplier<String> readUsername) {
+        String input = readUsername.get();
+        return new Users(input);
+    }
+
+    public BetAmounts createBetAmount(Function<User, String> readBetAmount, Users users) {
+        Map<User, BetAmount> betAmounts = new HashMap<>();
+        for (User user : users.getPlayers()) {
+            String input = readBetAmount.apply(user);
+            BetAmount betAmount = new BetAmount(input);
+            betAmounts.put(user, betAmount);
+        }
+        return new BetAmounts(betAmounts);
+    }
+
+    public void drawInitCards(Users users) {
+        cardProvider.drawInitCards(users);
+    }
+
+    public void hitPlayers(Users users, Function<User, String> readHitCommand,
+                           Consumer<User> printPlayerCards, Runnable printCantHit) {
+        for (User player : users.getPlayers()) {
+            hitPlayer(player, readHitCommand, printPlayerCards, printCantHit);
+        }
+    }
+
+    public void hitDealer(Users users, Runnable printDealerHit) {
+        User dealer = users.getDealer();
+        while (dealer.isHitAvailable()) {
+            cardProvider.drawOneCard(dealer);
+            printDealerHit.run();
+        }
+        dealer.stay();
+    }
+
+    public ProfitResult judgeWinner(Users users, BetAmounts betAmounts) {
+        return users.judgeWinner(betAmounts);
+    }
+
+    public void end(Runnable closeScanner) {
+        closeScanner.run();
+    }
+
+    private void hitPlayer(User player, Function<User, String> readHitCommand, Consumer<User> printPlayerCards,
+                           Runnable printCantHit) {
+        while (retryUntilSuccess(() -> checkY(player, readHitCommand)) && isHitAvailable(player, printCantHit)) {
+            cardProvider.drawOneCard(player);
+            printPlayerCards.accept(player);
+        }
+        player.stay();
+    }
+
+    private boolean checkY(User player, Function<User, String> readHitCommand) {
+        String input = readHitCommand.apply(player);
+        HitCommand hitCommand = new HitCommand(input);
+        return hitCommand.isY();
+    }
+
+    private boolean isHitAvailable(User player, Runnable printCantHit) {
+        if (player.isHitAvailable()) {
+            return true;
+        }
+        printCantHit.run();
+        return false;
+    }
+}

src/main/java/blackjack/controller/BlackjackController.java

@@ -2,86 +2,56 @@
 
 import static blackjack.util.ExceptionHandler.retryUntilSuccess;
 
-import blackjack.model.card.HitCommand;
-import blackjack.model.card.CardProvider;
-import blackjack.model.user.Dealer;
-import blackjack.model.user.Player;
-import blackjack.model.gameresult.PlayersGameResult;
+import blackjack.BlackjackGame;
+import blackjack.model.bet.BetAmounts;
+import blackjack.model.gameresult.ProfitResult;
 import blackjack.model.user.Users;
 import blackjack.view.InputView;
 import blackjack.view.OutputView;
-import java.util.List;
 
 
 public class BlackjackController {
 
-    private final CardProvider cardProvider;
+    private final BlackjackGame blackjackGame;
 
-    public BlackjackController(CardProvider cardProvider) {
-        this.cardProvider = cardProvider;
+    public BlackjackController(BlackjackGame blackjackGame) {
+        this.blackjackGame = blackjackGame;
     }
 
     public void run() {
-        Users users = retryUntilSuccess(this::createUsers);
+        Users users = retryUntilSuccess(() -> blackjackGame.createUsers(InputView::readPlayerName));
 
-        provideInitCardsAndPrint(users);
+        BetAmounts betAmounts = retryUntilSuccess(
+                () -> blackjackGame.createBetAmount(InputView::readBetAmount, users));
+
+        drawInitCardsAndPrint(users);
 
         hit(users);
 
         printHandStatus(users);
 
-        printGameResult(users);
-
-        InputView.closeScanner();
-    }
+        printProfitResult(users, betAmounts);
 
-    private Users createUsers() {
-        String input = InputView.readPlayerName();
-        return new Users(input);
+        blackjackGame.end(InputView::closeScanner);
     }
 
-    private void provideInitCardsAndPrint(Users users) {
-        cardProvider.provideInitCards(users);
+    private void drawInitCardsAndPrint(Users users) {
+        blackjackGame.drawInitCards(users);
         OutputView.printInitCards(users);
     }
 
     private void hit(Users users) {
-        List<Player> players = users.getPlayers();
-        Dealer dealer = users.getDealer();
-
-        for (Player player : players) {
-            while (retryUntilSuccess(() -> checkY(player)) && checkAddCard(player)) {
-                cardProvider.provideOneCard(player);
-                OutputView.printPlayerCards(player);
-            }
-        }
-
-        while (dealer.isHitAvailable()) {
-            cardProvider.provideOneCard(dealer);
-            OutputView.printDealerHit();
-        }
+        blackjackGame.hitPlayers(users, InputView::readHitCommand, OutputView::printPlayerCards,
+                OutputView::printCantHit);
+        blackjackGame.hitDealer(users, OutputView::printDealerHit);
     }
 
     private void printHandStatus(Users users) {
         OutputView.printHandStatus(users);
     }
 
-    private void printGameResult(Users users) {
-        PlayersGameResult playersGameResult = users.determineWinner();
-        OutputView.printGameResult(playersGameResult, users);
-    }
-
-    private boolean checkY(Player player) {
-        String input = InputView.readCardAdd(player).trim();
-        HitCommand hitCommand = new HitCommand(input);
-        return hitCommand.isY();
-    }
-
-    private boolean checkAddCard(Player player) {
-        if (player.isHitAvailable()) {
-            return true;
-        }
-        OutputView.printCantHit();
-        return false;
+    private void printProfitResult(Users users, BetAmounts betAmounts) {
+        ProfitResult profitResult = blackjackGame.judgeWinner(users, betAmounts);
+        OutputView.printGameResult(profitResult, users);
     }
 }

src/main/java/blackjack/model/bet/BetAmount.java

@@ -0,0 +1,41 @@
+package blackjack.model.bet;
+
+public class BetAmount {
+
+    static final String ERROR_EMPTY_INPUT = "입력값은 공백일 수 없습니다.";
+    static final String ERROR_BET_AMOUNT_NOT_INTEGER = "배팅 금액은 숫자 형태로 입력해야 합니다 : %s";
+    static final String ERROR_BET_AMOUNT_NOT_POSITIVE = "배팅 금액은 1원 이상이어야 합니다 : %d";
+
+    private final int amount;
+
+    public BetAmount(String input) {
+        validateEmpty(input);
+        int amount = convertToInt(input);
+        validatePositive(amount);
+        this.amount = amount;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    private void validateEmpty(String input) {
+        if (input.isBlank()) {
+            throw new IllegalArgumentException(ERROR_EMPTY_INPUT);
+        }
+    }
+
+    private int convertToInt(String input) {
+        try {
+            return Integer.parseInt(input);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ERROR_BET_AMOUNT_NOT_INTEGER.formatted(input));
+        }
+    }
+
+    private void validatePositive(int amount) {
+        if (amount <= 0) {
+            throw new IllegalArgumentException(ERROR_BET_AMOUNT_NOT_POSITIVE.formatted(amount));
+        }
+    }
+}

src/main/java/blackjack/model/bet/BetAmounts.java

@@ -0,0 +1,17 @@
+package blackjack.model.bet;
+
+import blackjack.model.user.User;
+import java.util.Map;
+
+public class BetAmounts {
+
+    private final Map<User, BetAmount> betAmounts;
+
+    public BetAmounts(Map<User, BetAmount> betAmounts) {
+        this.betAmounts = Map.copyOf(betAmounts);
+    }
+
+    public BetAmount findByUser(User user) {
+        return betAmounts.get(user);
+    }
+}

src/main/java/blackjack/model/card/CardProvider.java

@@ -1,52 +1,51 @@
 package blackjack.model.card;
 
-import static blackjack.model.constant.Constant.INIT_CARDS_END_IDX;
-import static blackjack.model.constant.Constant.INIT_CARDS_START_IDX;
-
-import blackjack.model.user.Dealer;
-import blackjack.model.user.Player;
 import blackjack.model.user.User;
 import blackjack.model.user.Users;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
+import java.util.stream.Collectors;
 
 public class CardProvider {
 
+    private static final int INIT_CARDS_START_IDX = 0;
+    private static final int INIT_CARDS_END_IDX = 2;
+
     private final Queue<Card> deck = new LinkedList<>();
 
     public CardProvider() {
         initDeck();
     }
 
     private void initDeck() {
-        List<Card> cards = new ArrayList<>();
-        for (Rank rank : Rank.values()) {
-            for (Suit suit : Suit.values()) {
-                cards.add(new Card(rank, suit));
-            }
-        }
+        List<Card> cards = Arrays.stream(Rank.values())
+                .flatMap(rank -> Arrays.stream(Suit.values())
+                        .map(suit -> new Card(rank, suit)))
+                .collect(Collectors.toCollection(ArrayList::new));
         Collections.shuffle(cards);
         this.deck.addAll(cards);
     }
 
-    public void provideInitCards(Users users) {
-        List<Player> players = users.getPlayers();
-        Dealer dealer = users.getDealer();
-        for (int i = INIT_CARDS_START_IDX; i < INIT_CARDS_END_IDX; i++) {
-            for (Player player : players) {
-                provideOneCard(player);
-            }
-            provideOneCard(dealer);
+    public void drawInitCards(Users users) {
+        for (User user : users.getUsers()) {
+            drawTwoCard(user);
         }
     }
 
-    public void provideOneCard(User user) {
+    public void drawOneCard(User user) {
         if (deck.peek() == null) {
             initDeck();
         }
-        user.addCard(deck.poll());
+        user.draw(deck.poll());
+    }
+
+    private void drawTwoCard(User user) {
+        for (int i = INIT_CARDS_START_IDX; i < INIT_CARDS_END_IDX; i++) {
+            drawOneCard(user);
+        }
     }
 }