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

README.md

@@ -1,51 +1,49 @@
 # java-blackjack
 
-# 블랙잭 미션 저장소
-
-# 블랙잭 미션 요구사항 정리
-
-# User Requirement
+## User Requirement
 
 - 플레이어의 이름을 입력한다.
 - 시스템은 딜러와 각 플레이어에게 카드를 두 장싹 분배한다.
 - 플레이어는 자신의 카드를 확인한 뒤, 카드를 추가로 받을지 결정한다.
 - 모든 플레이어의 차례가 끝나면 딜러가 규칙에 따라 카드를 추가로 받는다.
 - 딜러와 플레이어의 점수를 비교해서 21을 초과하지 않되, 21에 더 근접한 사람이 승리한다.
 
-# System Requirement
-- [X] 참가자는 딜러와 플레이어 모두를 의미한다.
+## System Requirement
+
+- [x] 참가자는 딜러와 플레이어 모두를 의미한다.
 
 #### 게임 환경 세팅
 
-- [X] 게임에 참여할 플레이어의 이름을 쉼표를 기준으로 분리하여 입력받는다.
-    - [X] 앞 뒤의 공백은 제거한다.
-    - [X] 입력이 비어있으면 예외를 발생시킨다.
-    - [X] 플레이어의 이름이 중복되는 경우 예외를 발생시킨다.
-    - [X] 구분자인 쉼표가 맨 앞에 있는 경우 이를 없애고 정상 입력으로 처리한다.
-    - [X] 구분자인 쉼표가 연속되어 나오는 경우 이를 없애고 정상 입력으로 처리한다.
-    - [X] 플레이어 수는 최대 5인으로 제한한다.
+- [x] 게임에 참여할 플레이어의 이름을 쉼표를 기준으로 분리하여 입력받는다.
+    - [x] 앞 뒤의 공백은 제거한다.
+    - [x] 입력이 비어있으면 예외를 발생시킨다.
+    - [x] 플레이어의 이름이 중복되는 경우 예외를 발생시킨다.
+    - [x] 구분자인 쉼표가 맨 앞에 있는 경우 이를 없애고 정상 입력으로 처리한다.
+    - [x] 구분자인 쉼표가 연속되어 나오는 경우 이를 없애고 정상 입력으로 처리한다.
+    - [x] 플레이어 수는 최대 5인으로 제한한다.
     - [x] 플레이어의 이름은 최대 5자로 제한한다.
-- [X] 중복되지 않은 52장의 카드 덱을 만든다.
-- [X] 카드 묶음을 랜덤하게 섞는다.
-- [X] 딜러와 각 플레이어에게 카드 두 장을 분배한다.
+- [x] 각 플레이어마다 베팅할 금액을 입력한다.
+- [x] 중복되지 않은 52장의 카드 덱을 만든다.
+- [x] 카드 묶음을 랜덤하게 섞는다.
+- [x] 딜러와 각 플레이어에게 카드 두 장을 분배한다.
 - [x] 나누어진 카드를 화면에 출력한다.
 
 #### 카드 점수 계산
 
-- [X] 2~10 사이의 숫자 카드는 해당 숫자만큼의 점수로 처리한다.
-- [X] J, Q, K 카드는 10점으로 처리한다.
-- [X] ACE 카드는 기본 11점으로 처리한다.
-- [X] 카드의 합이 21을 넘고 ACE 카드가 존재하는 경우, 카드의 합이 21을 넘지 않되 21에 가장 근접하도록 계산한다.
-- [X] 플레이어가 지니고 있는 카드의 점수를 합산하여 반환한다.
+- [x] 2~10 사이의 숫자 카드는 해당 숫자만큼의 점수로 처리한다.
+- [x] J, Q, K 카드는 10점으로 처리한다.
+- [x] ACE 카드는 기본 11점으로 처리한다.
+- [x] 카드의 합이 21을 넘고 ACE 카드가 존재하는 경우, 카드의 합이 21을 넘지 않되 21에 가장 근접하도록 계산한다.
+- [x] 플레이어가 지니고 있는 카드의 점수를 합산하여 반환한다.
 
 #### 플레이어 턴 진행
 
-- [X] 덱에 여분의 카드가 존재하지 않는 경우 예외를 발생시킨다.
-- [X] 덱에서 카드를 한 장 뽑는다.
+- [x] 덱에 여분의 카드가 존재하지 않는 경우 예외를 발생시킨다.
+- [x] 덱에서 카드를 한 장 뽑는다.
 - [x] 플레이어의 카드의 합이 21 미만인 경우 더 받을지 묻는다.
 - [x] 'y'를 입력하는 경우 덱에서 카드 한 장을 뽑아 플레이어에게 제공한다.
-- [x] 'n'를 입력하거나, 카드의 합이 21 이상이면 해당 플레이어의 차례를 종료한다.
-- [x] 'y'나 'n'이외의 다른 값이 입력되면 예외를 처리하고 다시 입력받는다.
+- [x] 'n'를 입력하거나, 카드의 합이 21을 초과하면 해당 플레이어의 차례를 종료한다.
+- [x] 'y'나 'n'이외의 다른 값이 입력되면 예외를 발생시킨다.
 
 #### 딜러 턴 진행
 
@@ -58,6 +56,16 @@
 - [x] 플레이어의 카드 점수의 합이 21을 초과했는지 계산한다.
 - [x] 딜러의 카드 점수의 합이 21을 초과했는지 계산한다.
 - [x] 딜러와 플레이어 중 카드 점수의 합이 21을 초과하지 않되, 21에 더 가까운 사람을 승자로 처리한다.
+    - [x] 플레이어가 승리하면, 플레이어는 자신이 베팅한 금액만큼 딜러에게 받는다.
+    - [x] 딜러가 승리하면, 플레이어는 자신이 베팅한 금액을 딜러에게 준다.
+- [x] 점수가 같은 경우 무승부로 처리한다.
+    - [x] 이 경우 플레이어는 베팅한 금액을 돌려받는다.
+- [x] 블랙잭은 처음 받은 두 장의 카드의 합이 21인 경우를 의미한다.
+    - [x] 플레이어는 블랙잭이고, 딜러는 블랙잭이 아니라면 플레이어는 승리한다. 이 경우에는 플레이어는 베팅한 금액의 1.5배를 딜러에게 받는다.
+    - [x] 딜러는 블랙잭이고, 플레이어는 블랙잭이 아니라면 플레이어는 패배한다.
+    - [x] 둘다 블랙잭인 경우, 무승부로 처리한다.
 - [x] 점수가 같은 경우 무승부로 처리한다.
+    - [x] 이 경우 플레이어는 베팅한 금액을 돌려받는다.
 - [x] 딜러와 각 플레이어의 최종 카드 목록과 점수를 출력한다.
-- [x] 최종 승패를 출력한다.
+- [x] 딜러와 플레이어가 모두 동시에 블랙잭인 경우 플레이어는 베팅한 금액을 돌려받는다.
+- [x] 최종 수익을 계산하여 출력한다.

src/main/java/controller/BlackjackGame.java

@@ -30,9 +30,15 @@ public BlackjackGame(InputView inputView, OutputView outputView) {
 
     public void run() {
         String names = inputView.getNames();
-        List<String> parsedName = InputParser.parseName(names);
+        List<String> parsedNames = InputParser.parseName(names);
+
+        Players players = new Players(parsedNames
+                .stream()
+                .map(Player::new).toList()
+        );
+
+        players.getPlayers().forEach(player -> player.bet(inputView.getBetAmount(player.name())));
 
-        Players players = new Players(parsedName);
         Dealer dealer = new Dealer(DEALER_NAME);
 
         CardShuffleStrategy cardShuffleStrategy = new RandomShuffleStrategy();
@@ -70,10 +76,17 @@ private void dealerTurn(Dealer dealer, Deck deck) {
 
     private void playerTurn(Player player, Deck deck) {
         while (player.canDraw()) {
-            if (inputView.getChoice(player.name()).equals("n")) {
+            String playerName = player.name();
+            String choice = inputView.getChoice(playerName);
+
+            if (choice.equals("n")) {
                 break;
             }
 
+            if (!choice.equals("y")) {
+                throw new IllegalArgumentException();
+            }
+
             player.receive(deck.draw());
             outputView.printParticipantCards(player);
         }
@@ -85,6 +98,6 @@ private void showGameResult(Players players, Dealer dealer) {
         participants.forEach(outputView::printFinalResult);
 
         GameResult gameResult = new GameResult(players, dealer);
-        outputView.printGameResult(gameResult, dealer);
+        outputView.printGameResult(gameResult, players, dealer);
     }
 }

src/main/java/domain/game/GameResult.java

@@ -1,45 +1,34 @@
 package domain.game;
 
 import domain.participant.Dealer;
+import domain.participant.Participant;
 import domain.participant.Player;
 import domain.participant.Players;
-import dto.DealerResultInfo;
-import dto.PlayerResultInfo;
+import dto.ParticipantResultInfo;
 
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
+import java.math.BigDecimal;
+import java.util.HashMap;
 import java.util.Map;
 
-import static java.util.Collections.frequency;
+import static domain.game.ProfitCalculator.calculatePlayerProfit;
 
 public class GameResult {
-    private final Map<Player, WinningStatus> playerWinningStatus = new LinkedHashMap<>();
+    private final Map<Participant, BigDecimal> participantsProfits = new HashMap<>();
 
     public GameResult(Players players, Dealer dealer) {
-        for (Player player : players.getPlayers()) {
-            playerWinningStatus.put(player, WinningStatus.of(player, dealer));
-        }
-    }
-
-    public List<PlayerResultInfo> getPlayersResult() {
-        List<PlayerResultInfo> result = new ArrayList<>();
+        BigDecimal playersProfitSum = BigDecimal.ZERO;
 
-        for (Map.Entry<Player, WinningStatus> entry : playerWinningStatus.entrySet()) {
-            String name = entry.getKey().name();
-            WinningStatus status = entry.getValue();
+        for (Player player : players.getPlayers()) {
+            BigDecimal profit = calculatePlayerProfit(player, dealer);
+            playersProfitSum = playersProfitSum.add(profit);
 
-            result.add(new PlayerResultInfo(name, status));
+            participantsProfits.put(player, profit);
         }
-
-        return result;
+        participantsProfits.put(dealer, playersProfitSum.negate());
     }
 
-    public DealerResultInfo getDealerResult() {
-        int winCount = frequency(playerWinningStatus.values(), WinningStatus.LOSE);
-        int tieCount = frequency(playerWinningStatus.values(), WinningStatus.TIE);
-        int loseCount = frequency(playerWinningStatus.values(), WinningStatus.WIN);
-
-        return new DealerResultInfo(winCount, tieCount, loseCount);
+    public ParticipantResultInfo participantResultInfo(Participant participant) {
+        return new ParticipantResultInfo(participant.name(), participantsProfits.get(participant));
     }
 }
+

src/main/java/domain/game/ProfitCalculator.java

@@ -0,0 +1,27 @@
+package domain.game;
+
+import domain.participant.Dealer;
+import domain.participant.Player;
+
+import java.math.BigDecimal;
+
+public class ProfitCalculator {
+    public static BigDecimal calculatePlayerProfit(Player player, Dealer dealer) {
+        WinningStatus winningStatus = WinningStatus.of(player, dealer);
+        BigDecimal betAmount = player.betAmount();
+
+        if (player.isBlackjack() && winningStatus == WinningStatus.WIN) {
+            return betAmount.multiply(BigDecimal.valueOf(1.5));
+        }
+
+        if (winningStatus == WinningStatus.WIN) {
+            return betAmount;
+        }
+
+        if (winningStatus == WinningStatus.TIE) {
+            return BigDecimal.ZERO;
+        }
+
+        return betAmount.negate();
+    }
+}

src/main/java/domain/game/WinningStatus.java

@@ -3,25 +3,43 @@
 import domain.participant.Dealer;
 import domain.participant.Player;
 
-import static domain.BlackjackRule.BLACK_JACK;
+import java.util.Optional;
 
 public enum WinningStatus {
     WIN,
     TIE,
     LOSE;
 
     public static WinningStatus of(Player player, Dealer dealer) {
-        int playerScore = player.score();
-        int dealerScore = dealer.score();
+        if (dealer.isBust()) {
+            return WIN;
+        }
 
-        if (playerScore > BLACK_JACK) {
+        if (player.isBust()) {
             return LOSE;
         }
 
-        if (dealerScore > BLACK_JACK) {
-            return WIN;
+        Optional<WinningStatus> winningStatus = judgeBlackjack(player, dealer);
+        return winningStatus.orElseGet(() -> compareScore(player.score(), dealer.score()));
+    }
+
+    private static Optional<WinningStatus> judgeBlackjack(Player player, Dealer dealer) {
+        boolean isPlayerBlackjack = player.isBlackjack();
+        boolean isDealerBlackjack = dealer.isBlackjack();
+
+        if (isPlayerBlackjack && !isDealerBlackjack) {
+            return Optional.of(WIN);
         }
-        return compareScore(playerScore, dealerScore);
+
+        if (!isPlayerBlackjack && isDealerBlackjack) {
+            return Optional.of(LOSE);
+        }
+
+        if (isPlayerBlackjack && isDealerBlackjack) {
+            return Optional.of(TIE);
+        }
+
+        return Optional.empty();
     }
 
     private static WinningStatus compareScore(int playerScore, int dealerScore) {
@@ -31,6 +49,7 @@ private static WinningStatus compareScore(int playerScore, int dealerScore) {
         if (playerScore < dealerScore) {
             return LOSE;
         }
+
         return TIE;
     }
 }

src/main/java/domain/participant/Hand.java

@@ -6,6 +6,7 @@
 import java.util.List;
 
 import static domain.BlackjackRule.BLACK_JACK;
+import static domain.BlackjackRule.INITIAL_CARDS_COUNT;
 
 public class Hand {
     public static final int ACE_ADJUST_VALUE = 10;
@@ -24,6 +25,10 @@ public boolean isBust() {
         return score() > BLACK_JACK;
     }
 
+    public boolean isBlackjack() {
+        return score() == BLACK_JACK && size() == INITIAL_CARDS_COUNT;
+    }
+
     public int score() {
         int total = cards.sum();
         int aceCount = cards.countAce();
@@ -36,7 +41,7 @@ public int score() {
         return total;
     }
 
-    public Card peek(){
+    public Card peek() {
         return cards.peek();
     }
 

src/main/java/domain/participant/Participant.java

@@ -24,6 +24,14 @@ public void receiveInitialCards(Cards cards) {
         cards.cards().forEach(this::receive);
     }
 
+    public boolean isBlackjack() {
+        return hand.isBlackjack();
+    }
+
+    public boolean isBust() {
+        return hand.isBust();
+    }
+
     public void receive(Card card) {
         hand.add(card);
     }

src/main/java/domain/participant/Player.java

@@ -1,15 +1,26 @@
 package domain.participant;
 
+import java.math.BigDecimal;
+
 import static domain.BlackjackRule.BLACK_JACK;
 
 public class Player extends Participant {
+    private BigDecimal betAmount = BigDecimal.ZERO;
 
     public Player(String name) {
         super(name);
     }
 
     @Override
     public boolean canDraw() {
-        return super.score() <= BLACK_JACK;
+        return super.score() < BLACK_JACK;
+    }
+
+    public void bet(BigDecimal betAmount) {
+        this.betAmount = betAmount;
+    }
+
+    public BigDecimal betAmount() {
+        return betAmount;
     }
 }

src/main/java/domain/participant/Players.java

@@ -6,13 +6,10 @@
 
 public class Players {
     private static final int PLAYER_THRESHOLD = 5;
-    private final List<Player> players = new ArrayList<>();
+    private final List<Player> players;
 
-    public Players(List<String> names) {
-        for (String name : names) {
-            Player player = new Player(name);
-            players.add(player);
-        }
+    public Players(List<Player> players) {
+        this.players = new ArrayList<>(players);
 
         validatePlayerCount(players);
         validateDuplicatedName(players);
@@ -42,6 +39,6 @@ public List<String> getPlayerNames() {
     }
 
     public List<Player> getPlayers() {
-        return players;
+        return List.copyOf(players);
     }
 }