[2단계 - 블랙잭 베팅] 리비(이근희) 미션 제출합니다.

README.md

@@ -38,6 +38,11 @@
     - [x] 카드덱에서 카드를 한 장 뽑아서 건네줄 수 있다.
     - [x] 카드덱에서 보유한 카드 개수보다 많이 뽑으면 예외가 발생한다.
     - [x] 참여자의 핸드에 초기 카드를 분배할 수 있다.
+    - [x] 플레이어는 10억까지 베팅할 수 있다.
+    - [x] 플레이어는 핸드를 완성시키는 단계에서 버스트 하면 금액을 모두 잃는다.
+    - [x] 처음 두 장의 카드 합이 21이 되는 블랙잭일 경우 베팅 금액의 1.5배를 추가로 얻는다. (소숫점 제거)
+    - [x] 플레이어가 블랙잭이고 딜러도 블랙잭이면 플레이어는 베팅 금액을 그대로 돌려받는다.
+    - [x] 플레이어가 딜러에게 승리하면 베팅 금액만큼을 추가로 얻는다.
 - [x] 출력
     - [x] 각 참여자의 카드 정보를 출력할 수 있다.
     - [x] 각 참여자의 카드 합을 출력할 수 있다.

src/main/java/blackjack/Application.java

@@ -7,8 +7,7 @@
 public class Application {
 
     public static void main(String[] args) {
-
-        InputView inputView = new InputView();
+        InputView inputView = new InputView(new InputMapper());
         OutputView outputView = new OutputView(new MessageResolver());
 
         BlackJackGame blackJackGame = new BlackJackGame(inputView, outputView);

src/main/java/blackjack/BlackJackGame.java

@@ -1,17 +1,13 @@
 package blackjack;
 
-import static blackjack.domain.DrawDecision.YES;
-
-import blackjack.domain.DrawDecision;
-import blackjack.domain.card.Card;
+import blackjack.domain.bet.PlayerBets;
 import blackjack.domain.card.CardDeck;
+import blackjack.domain.card.Hand;
 import blackjack.domain.player.Dealer;
-import blackjack.domain.player.Hand;
-import blackjack.domain.player.Participant;
 import blackjack.domain.player.Player;
 import blackjack.domain.player.PlayerName;
 import blackjack.domain.player.Players;
-import blackjack.domain.rule.Judge;
+import blackjack.domain.result.PlayerProfits;
 import blackjack.view.InputView;
 import blackjack.view.OutputView;
 import java.util.List;
@@ -29,73 +25,33 @@ public BlackJackGame(InputView inputView, OutputView outputView) {
     public void run() {
         CardDeck cardDeck = CardDeck.createShuffledDeck();
         Players players = initPlayers(cardDeck);
+        PlayerBets playerBets = inputView.readBetInformation(players);
         Dealer dealer = new Dealer(Hand.createHandFrom(cardDeck));
-        printPlayersInformation(players, dealer);
+        outputView.printParticipantInitialHand(dealer, players);
 
         completePlayersHand(players, cardDeck);
-        completeDealerHand(dealer, cardDeck);
-        outputView.printDealerPopCount(Dealer.HIT_THRESHOLD, dealer.countPop());
+        dealer.completeHand(cardDeck);
+        outputView.printCompletedHandsStatus(dealer, players);
 
-        printParticipantScore(dealer);
-        printPlayersScore(players);
-        printDealerGameResult(dealer, players);
-        printPlayersGameResult(players, dealer);
+        PlayerProfits playerProfits = playerBets.calculateProfitResult(dealer);
+        outputView.printProfitResults(playerProfits);
     }
 
     private Players initPlayers(CardDeck cardDeck) {
-        InputMapper inputMapper = new InputMapper();
-        List<PlayerName> playerNames = inputMapper.mapToPlayers(inputView.readNames());
-
+        List<PlayerName> playerNames = inputView.readNames();
         return new Players(playerNames.stream()
                 .map(playerName -> new Player(playerName, Hand.createHandFrom(cardDeck)))
                 .toList());
     }
 
-    private void printPlayersInformation(Players players, Dealer dealer) {
-        outputView.printHandOutEvent(players, 2);
-        outputView.printDealerInitialHand(dealer);
-        players.getPlayers().forEach(outputView::printPlayerHand);
-    }
-
     private void completePlayersHand(Players players, CardDeck cardDeck) {
         players.getPlayers().forEach(player -> completePlayerHand(player, cardDeck));
     }
 
     private void completePlayerHand(Player participant, CardDeck cardDeck) {
-        while (participant.canHit() && readHitDecision(participant) == YES) {
+        while (participant.canHit() && inputView.readDrawDecision(participant.getName()).isYes()) {
             participant.appendCard(cardDeck.popCard());
             outputView.printPlayerHand(participant);
         }
     }
-
-    private DrawDecision readHitDecision(Player participant) {
-        InputMapper inputMapper = new InputMapper();
-        return inputMapper.mapToDrawDecision(inputView.readDrawPlan(participant.getName()));
-    }
-
-    private void completeDealerHand(Dealer dealer, CardDeck cardDeck) {
-        while (dealer.canHit()) {
-            Card card = cardDeck.popCard();
-            dealer.appendCard(card);
-        }
-    }
-
-    private void printPlayersScore(Players players) {
-        players.getPlayers().forEach(this::printParticipantScore);
-    }
-
-    private void printParticipantScore(Participant participant) {
-        outputView.printParticipantScore(participant, participant.calculateHandScore());
-    }
-
-    private void printDealerGameResult(Dealer dealer, Players players) {
-        Judge judge = new Judge();
-        outputView.printDealerGameResult(judge.calculateDealerGameResult(dealer, players));
-    }
-
-    private void printPlayersGameResult(Players players, Dealer dealer) {
-        Judge judge = new Judge();
-        players.getPlayers()
-                .forEach(player -> outputView.printPlayerGameResult(player, judge.isPlayerWin(dealer, player)));
-    }
 }

src/main/java/blackjack/InputMapper.java

@@ -9,7 +9,7 @@ public class InputMapper {
 
     private static final String DELIMITER = ",";
 
-    public List<PlayerName> mapToPlayers(String target) {
+    public List<PlayerName> mapToPlayerNames(String target) {
         String[] split = target.split(DELIMITER);
         return Arrays.stream(split)
                 .map(PlayerName::new)

src/main/java/blackjack/domain/DrawDecision.java

@@ -19,4 +19,8 @@ public static DrawDecision from(String code) {
                 .findFirst()
                 .orElseThrow(() -> new IllegalArgumentException("[ERROR] " + YES.code + "또는 " + NO.code + "로 입력해주세요"));
     }
+
+    public boolean isYes() {
+        return this == YES;
+    }
 }

src/main/java/blackjack/domain/Score.java

@@ -0,0 +1,47 @@
+package blackjack.domain;
+
+import java.util.Objects;
+
+public class Score {
+
+    private static final int MAX_SCORE = 21;
+
+    private final int value;
+
+    public Score(int value) {
+        this.value = value;
+    }
+
+    public boolean isAbove(Score target) {
+        return this.value > target.value;
+    }
+
+    public boolean isMaxScore() {
+        return value == MAX_SCORE;
+    }
+
+    public boolean isBustScore() {
+        return value > MAX_SCORE;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Score score = (Score) o;
+        return value == score.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

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

@@ -0,0 +1,24 @@
+package blackjack.domain.bet;
+
+public class BetAmount {
+
+    private static final int MAX = 1_000_000_000;
+    private static final int MIN = 1_000;
+
+    private final int amount;
+
+    public BetAmount(int amount) {
+        validateRange(amount);
+        this.amount = amount;
+    }
+
+    public Profit calculateProfit(double leverage) {
+        return new Profit((int) (amount * leverage));
+    }
+
+    private void validateRange(int amount) {
+        if (amount < MIN || MAX < amount) {
+            throw new IllegalArgumentException("[ERROR] 베팅 금액은 " + MIN + "부터 " + MAX + "이하까지 가능합니다.");
+        }
+    }
+}

src/main/java/blackjack/domain/bet/PlayerBets.java

@@ -0,0 +1,30 @@
+package blackjack.domain.bet;
+
+import blackjack.domain.player.Dealer;
+import blackjack.domain.player.Player;
+import blackjack.domain.result.GameResult;
+import blackjack.domain.result.PlayerProfits;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class PlayerBets {
+
+    private final Map<Player, BetAmount> playerBets;
+
+    public PlayerBets(Map<Player, BetAmount> playerBets) {
+        this.playerBets = playerBets;
+    }
+
+    public PlayerProfits calculateProfitResult(Dealer dealer) {
+        return new PlayerProfits(playerBets.keySet().stream()
+                .collect(Collectors.toMap(
+                        player -> player,
+                        player -> calculatePlayerProfit(player, dealer))));
+    }
+
+    private Profit calculatePlayerProfit(Player player, Dealer dealer) {
+        GameResult gameResult = GameResult.judge(dealer, player);
+        BetAmount betAmount = playerBets.get(player);
+        return betAmount.calculateProfit(gameResult.getProfitLeverage());
+    }
+}

src/main/java/blackjack/domain/bet/Profit.java

@@ -0,0 +1,41 @@
+package blackjack.domain.bet;
+
+import java.util.Objects;
+
+public class Profit {
+
+    private final int value;
+
+    public Profit(int value) {
+        this.value = value;
+    }
+
+    public Profit add(Profit other) {
+        return new Profit(this.value + other.value);
+    }
+
+    public Profit inverse() {
+        return new Profit(-1 * value);
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Profit profit = (Profit) o;
+        return value == profit.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}

src/main/java/blackjack/domain/card/Card.java

@@ -16,6 +16,14 @@ public boolean isAce() {
         return cardNumber.isAce();
     }
 
+    public CardNumber getCardNumber() {
+        return cardNumber;
+    }
+
+    public CardShape getCardShape() {
+        return cardShape;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) {
@@ -32,12 +40,4 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(cardShape, cardNumber);
     }
-
-    public CardNumber getCardNumber() {
-        return cardNumber;
-    }
-
-    public CardShape getCardShape() {
-        return cardShape;
-    }
 }

src/main/java/blackjack/domain/card/CardDeck.java

@@ -2,18 +2,24 @@
 
 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;
 import java.util.stream.IntStream;
 
 public class CardDeck {
 
-    private final List<Card> cards;
+    private Queue<Card> cards;
 
-    CardDeck(List<Card> cards) {
+    CardDeck(Queue<Card> cards) {
         this.cards = cards;
     }
 
+    CardDeck(List<Card> cards) {
+        this((Queue<Card>) new LinkedList<>(cards));
+    }
+
     public static CardDeck createShuffledDeck() {
         List<Card> cards = Arrays.stream(CardShape.values())
                 .flatMap(shape -> Arrays.stream(CardNumber.values())
@@ -27,7 +33,7 @@ public Card popCard() {
         if (cards.isEmpty()) {
             throw new IllegalArgumentException("[ERROR] 남아있는 카드가 부족하여 카드를 뽑을 수 없습니다");
         }
-        return cards.remove(cards.size() - 1);
+        return cards.poll();
     }
 
     public List<Card> popCards(int count) {