[2단계 - 블랙잭 베팅] 리브(김민주) 미션 제출합니다.

docs/README.md

@@ -84,22 +84,41 @@
 - [x] OutputView, InputView 정적 클래스 ❌
 
 ## 딜러가 덱 생성을 하고, 쥐고 있으면서 경기 진행
+
 - [x] 딜러와 플레이어 분리
-  - [x] 딜러에게 필요한 것
-    - [x] Deck
-    - [x] Hand
-  - [x] 딜러에게 필요한 역할
-    - [x] 덱 생성
-    - [x] 카드 분배
-  - [x] 플레이어에게 필요한 것
-    - [x] Name
-    - [x] Hand
+    - [x] 딜러에게 필요한 것
+        - [x] Deck
+        - [x] Hand
+    - [x] 딜러에게 필요한 역할
+        - [x] 덱 생성
+        - [x] 카드 분배
+    - [x] 플레이어에게 필요한 것
+        - [x] Name
+        - [x] Hand
 - [x] 딜러, 플레이어가 생성될 때 카드를 먼저 넘기고 시작하면 안된다.(딜러가 나누어주어야 하니까)
 
 ### ACE 점수 계산
 
 - [x] ACE가 0개일 때 0
 - [x] ACE가 두 개 이상
-  - [x] 한 개를 제외한 모든 ACE는 1점
-  - [x] 나머지 한 개 ACE
-    - [x] 다른 카드 점수 합 + (ACE 개수 - 1)이 10보다 크면 1점, 아니면 11점
+    - [x] 한 개를 제외한 모든 ACE는 1점
+    - [x] 나머지 한 개 ACE
+        - [x] 다른 카드 점수 합 + (ACE 개수 - 1)이 10보다 크면 1점, 아니면 11점
+
+---
+
+# 2단계 - 블랙잭 베팅
+
+- [x] 베팅 금액 전달 받기(Money)
+    - [x] 공백 ❌
+    - [x] 숫자 ❌
+    - [x] 음수 ❌
+    - [x] 베팅은 최소 1원부터 최대 1억까지 가능하다(파산 방지 🥹💰)
+- [x] 입력 받은 베팅 금액 관리(BetMoney) -> 각 플레이어와 금액 정보
+
+## 베팅 규칙
+
+- [x] 21을 초과할 경우 베팅 금액을 모두 잃게 된다
+- [x] 블랙잭 : 1.5배를 딜러에게 받는다
+- [x] 딜러, 플레이어 동시에 블랙잭 : 플레이어는 베팅한 금액을 돌려 받음
+- [x] 딜러가 버스트되기 전까지 `남아 있던` 플레이어들은 가지고 있는 패에 상관 없이 승리(돌려 받음)

src/main/java/blackjack/BlackJackGame.java

@@ -1,20 +1,23 @@
 package blackjack;
 
-import blackjack.dto.DealerResultCount;
 import blackjack.dto.NameCards;
 import blackjack.dto.NameCardsScore;
-import blackjack.dto.PlayerNameFinalResult;
+import blackjack.dto.ProfitStatement;
 import blackjack.model.deck.Deck;
+import blackjack.model.money.Bets;
+import blackjack.model.money.Profit;
 import blackjack.model.participant.Dealer;
 import blackjack.model.participant.Player;
 import blackjack.model.participant.Players;
 import blackjack.model.result.Referee;
-import blackjack.model.result.Rule;
+import blackjack.model.result.ResultCommand;
 import blackjack.view.InputView;
 import blackjack.view.OutputView;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class BlackJackGame {
@@ -29,16 +32,15 @@ public BlackJackGame(InputView inputView, OutputView outputView) {
     public void run() {
         final Dealer dealer = new Dealer(new Deck());
         final Players players = registerPlayers();
-        final Referee referee = new Referee(new Rule(dealer));
+        final Referee referee = new Referee(dealer);
+        final Bets bets = registerBets(players);
 
         registerInitialCards(dealer, players);
-        outputView.printDistributionSubject(players.getNames());
         printInitialCards(dealer, players);
 
-        playPlayersTurn(players, dealer);
-        playDealerTurn(dealer);
-
-        printFinalResult(dealer, players, referee);
+        playParticipantsTurn(players, dealer);
+        printFinalCardsAndScores(dealer, players);
+        printResultProfits(referee, players, bets);
     }
 
     private Players registerPlayers() {
@@ -51,9 +53,34 @@ private Players registerPlayers() {
         }
     }
 
+    private Bets registerBets(final Players players) {
+        final Bets bets = new Bets();
+        final Map<Player, Integer> playersBetMoney = readPlayersBetMoney(players);
+        for (Player player: playersBetMoney.keySet()) {
+            int money = playersBetMoney.get(player);
+            bets.addBet(player, money);
+        }
+        return bets;
+    }
+
+    private Map<Player, Integer> readPlayersBetMoney(final Players players) {
+        return players.stream()
+                .collect(Collectors.toMap(player -> player, player -> readBetMoney(player.getName())));
+    }
+
+    private int readBetMoney(final String name) {
+        try {
+            return inputView.readBetMoney(name);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readBetMoney(name);
+        }
+    }
+
     private void registerInitialCards(final Dealer dealer, final Players players) {
         dealer.receiveInitialCards(dealer.distributeInitialCard());
         players.receiveInitialCards(dealer::distributeInitialCard);
+        outputView.printDistributionSubject(players.getNames());
     }
 
     private void printInitialCards(final Dealer dealer, final Players players) {
@@ -72,6 +99,11 @@ private List<NameCards> createDealerPlayersNameCards(final Dealer dealer, final
                 .toList();
     }
 
+    private void playParticipantsTurn(final Players players, final Dealer dealer) {
+        playPlayersTurn(players, dealer);
+        playDealerTurn(dealer);
+    }
+
     private void playPlayersTurn(final Players players, final Dealer dealer) {
         players.playEachPlayerTurns(this::playPlayerTurn, dealer);
     }
@@ -100,17 +132,12 @@ private void distributeIfPlayerWant(final boolean isHit, final Player player, fi
     }
 
     private void playDealerTurn(final Dealer dealer) {
-        while (dealer.canHit()) {
+        while (dealer.shouldHit()) {
             outputView.printDealerHit();
             dealer.draw(dealer.distributeCard());
         }
     }
 
-    private void printFinalResult(final Dealer dealer, final Players players, final Referee referee) {
-        printFinalCardsAndScores(dealer, players);
-        printFinalResultCommand(referee, players);
-    }
-
     private void printFinalCardsAndScores(final Dealer dealer, final Players players) {
         outputView.println();
         NameCardsScore dealerNameCardsScore = new NameCardsScore(OutputView.DEALER_NAME, dealer.openCards(),
@@ -120,19 +147,21 @@ private void printFinalCardsAndScores(final Dealer dealer, final Players players
         outputView.printFinalCardsAndScore(playerNameCardsScore);
     }
 
-    private void printFinalResultCommand(final Referee referee, final Players players) {
-        printDealerFinalResultCount(referee, players);
-        List<PlayerNameFinalResult> playerNameFinalResults = players.stream()
-                .map(player -> PlayerNameFinalResult.from(player, referee.judgePlayerResult(player)))
-                .toList();
-        outputView.printFinalResults(playerNameFinalResults);
+    private void printResultProfits(final Referee referee, final Players players, final Bets bets) {
+        final Map<Player, ResultCommand> playerResultCommands = players.matchPlayerResultCommands(referee);
+        printDealerResultProfit(playerResultCommands, bets);
+        printPlayersResultProfit(playerResultCommands, bets);
     }
 
-    private void printDealerFinalResultCount(final Referee referee, final Players players) {
-        List<DealerResultCount> dealerResults = referee.judgeDealerResult(players)
-                .entrySet().stream()
-                .map(dealerResult -> new DealerResultCount(dealerResult.getKey(), dealerResult.getValue()))
-                .toList();
-        outputView.printDealerFinalResult(dealerResults);
+    private void printDealerResultProfit(final Map<Player, ResultCommand> playerResultCommands,
+                                         final Bets bets) {
+        final Profit dealerProfit = bets.calculateDealerProfit(playerResultCommands);
+        outputView.printDealerProfit(dealerProfit.getProfit());
+    }
+
+    private void printPlayersResultProfit(final Map<Player, ResultCommand> playerResultCommands, final Bets bets) {
+        final Map<Player, Profit> playerProfits = bets.calculatePlayersProfit(playerResultCommands);
+        final List<ProfitStatement> profitStatements = ProfitStatement.createNameProfits(playerProfits);
+        outputView.printPlayersProfit(profitStatements);
     }
 }

src/main/java/blackjack/dto/ProfitStatement.java

@@ -0,0 +1,19 @@
+package blackjack.dto;
+
+import blackjack.model.money.Profit;
+import blackjack.model.participant.Player;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public record ProfitStatement(String name, int profit) {
+
+    public static List<ProfitStatement> createNameProfits(final Map<Player, Profit> playerProfit) {
+        final List<ProfitStatement> profitStatements = new ArrayList<>();
+        for (Player player : playerProfit.keySet()) {
+            final int profit = playerProfit.get(player).getProfit();
+            profitStatements.add(new ProfitStatement(player.getName(), profit));
+        }
+        return profitStatements;
+    }
+}

src/main/java/blackjack/model/deck/Deck.java

@@ -11,6 +11,8 @@
 
 public class Deck {
     private static final int BLACKJACK_CARD_COUNT = 52;
+    static final String DECK_SIZE_IS_NOT_ENOUGH = "카드의 수가 52개가 아닙니다.";
+    static final String CAN_NOT_DRAWN_CARD = "카드가 부족합니다.";
 
     private final Deque<Card> deck;
 
@@ -24,7 +26,7 @@ private Deck(final Deque<Card> deck) {
 
     private void validateSize(final List<Card> deck) {
         if (deck.size() != BLACKJACK_CARD_COUNT) {
-            throw new IllegalStateException("카드의 수가 52개가 아닙니다.");
+            throw new IllegalStateException(DECK_SIZE_IS_NOT_ENOUGH);
         }
     }
 
@@ -46,11 +48,11 @@ private Deque<Card> shuffleDeck(final List<Card> originDeck) {
         return new ArrayDeque<>(originDeck);
     }
 
-    public Card distribute() {
+    public Card drawn() {
         try {
             return deck.removeFirst();
         } catch (NoSuchElementException e) {
-            throw new NoSuchElementException("카드가 부족합니다.");
+            throw new NoSuchElementException(CAN_NOT_DRAWN_CARD);
         }
     }
 }

src/main/java/blackjack/model/money/BetMoney.java

@@ -0,0 +1,47 @@
+package blackjack.model.money;
+
+import java.util.Objects;
+
+public class BetMoney {
+    private static final int MIN_BET_MONEY = 1;
+    private static final int MAX_BET_MONEY = 100_000_000;
+    public static final String OUT_OF_BET_MONEY_BOUND = "1원부터 1억원까지만 베팅 가능합니다.";
+
+    private final int betMoney;
+
+    public BetMoney(final int betMoney) {
+        validateBetMoneyInBound(betMoney);
+        this.betMoney = betMoney;
+    }
+
+    private void validateBetMoneyInBound(int betMoney) {
+        if (betMoney < MIN_BET_MONEY || betMoney > MAX_BET_MONEY) {
+            throw new IllegalArgumentException(OUT_OF_BET_MONEY_BOUND);
+        }
+    }
+
+    public int multiply(final double multiplier) {
+        return (int) (betMoney * multiplier);
+    }
+
+    public int getBetMoney() {
+        return betMoney;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        BetMoney betMoney1 = (BetMoney) o;
+        return betMoney == betMoney1.betMoney;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(betMoney);
+    }
+}

src/main/java/blackjack/model/money/Bets.java

@@ -0,0 +1,40 @@
+package blackjack.model.money;
+
+import blackjack.model.participant.Player;
+import blackjack.model.result.ResultCommand;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class Bets {
+    private final Map<Player, BetMoney> bets;
+
+    public Bets() {
+        this.bets = new LinkedHashMap<>();
+    }
+
+    public void addBet(final Player player, final int money) {
+        bets.put(player, new BetMoney(money));
+    }
+
+    public Map<Player, Profit> calculatePlayersProfit(final Map<Player, ResultCommand> result) {
+        final Map<Player, Profit> playersProfit = new LinkedHashMap<>();
+        for (Player player : result.keySet()) {
+            final double rate = result.get(player).getRate();
+            playersProfit.put(player, calculatePlayerProfit(rate, player));
+        }
+        return playersProfit;
+    }
+
+    private Profit calculatePlayerProfit(final double rate, final Player player) {
+        int profitMoney = bets.get(player).multiply(rate);
+        return new Profit(profitMoney);
+    }
+
+    public Profit calculateDealerProfit(final Map<Player, ResultCommand> result) {
+        final Map<Player, Profit> playersProfit = calculatePlayersProfit(result);
+        final int playerTotalProfit = playersProfit.values().stream()
+                .mapToInt(Profit::getProfit)
+                .sum();
+        return new Profit(playerTotalProfit * -1);
+    }
+}

src/main/java/blackjack/model/money/Profit.java

@@ -0,0 +1,32 @@
+package blackjack.model.money;
+
+import java.util.Objects;
+
+public class Profit {
+    private final int profit;
+
+    public Profit(int profit) {
+        this.profit = profit;
+    }
+
+    public int getProfit() {
+        return profit;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Profit profit1 = (Profit) o;
+        return profit == profit1.profit;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(profit);
+    }
+}