[🚀 사이클2 - 미션 (블랙잭 게임 실행)] 아론 미션 제출합니다.

README.md

@@ -20,17 +20,28 @@
         - [x] 버스트인 사람 패배
     - 둘다 버스트인 경우
         - [x] 무승부
+- [x] 수익 계산
+    - [x] 플레이어는 승리시 배팅금액 만큼 수익을 얻는다.
+        - [x] 플레이어가 블랙잭인지 판단할 수 있다.
+            - 처음 받은 2개의 카드가 21인 경우 블랙잭으로 판단
+        - [x] 참가자가 블랙잭인 경우 배팅금액의 1.5배 수익을 얻는다.
+    - [x] 플레이어는 패배시 배팅금액 만큼 손해를 본다
+    - [x] 플레이어는 무승부시 배팅금액 만큼 수익도 손해도 보지 않는다.
+    - [x] 딜러는 플레이어들이 패배한 금액 만큼 수익을 얻는다.
+    - [x] 딜러는 플레이어들이 승리한 금액 만큼 손해를 본다.
 
 - [x] 게임진행
     - [x] 초기 시작시 인당 카드 2장씩 지급
     - [x] 참가자 한명이 버스트가 되거나 카드를 안받는다 선택한 경우 다음 참가자 차례로 넘어감
     - [x] 마지막 참가자가 버스트가 되거나 카드를 안받을 경우 게임 종료
     - [x] 전체 플레이어 승패 결과 계산
+    - [x] 전체 참가자 수익 계산
 
 -[x] 입력
     - [x] 게임 참가자 이름 입력
+    - [x] 게임 배팅 금액 입력
     - [x] 카드 더받기 유무 입력
 - [x] 출력
     - [x] 분배 받은 카드 목록 출력
     - [x] 딜러와 참가자 카드 합계 결과 출력
-    - [x] 최종 승패 결과 출력
+    - [x] 최종 수익 출력

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

@@ -3,44 +3,44 @@
 import blackjack.domain.Dealer;
 import blackjack.domain.GameResult;
 import blackjack.domain.Player;
-import blackjack.domain.PlayerCardsName;
-import blackjack.domain.PlayerFinalCardsScore;
-import blackjack.domain.PlayerFinalResult;
-import blackjack.domain.ScoreCompareResult;
+import blackjack.dto.PlayerCardsName;
+import blackjack.dto.PlayerFinalCardsScore;
+import blackjack.dto.PlayerProfitResult;
+import blackjack.domain.ProfitResults;
 import blackjack.service.CardDistributor;
 import blackjack.service.Game;
 import blackjack.utils.InputParser;
 import blackjack.utils.RetryInput;
+import java.math.BigDecimal;
 import java.util.ArrayList;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import blackjack.view.InputView;
 import blackjack.view.OutputView;
 
 public class BlackjackController {
-    private final CardDistributor cardDistributor;
-    private final Game game;
     private static final RetryInput retryInput = new RetryInput();
+    private final CardDistributor cardDistributor;
 
     public BlackjackController(CardDistributor cardDistributor) {
         this.cardDistributor = cardDistributor;
-        this.game = new Game(cardDistributor);
     }
 
     public void startGame() {
         List<String> playerNames = getPlayerNames();
-        List<Player> players = getPlayers(playerNames);
+        List<Player> players = createPlayersWithBettingAmounts(playerNames);
         Dealer dealer = new Dealer();
 
         setupInitialHand(players, dealer, playerNames); // 2장씩 카드 분배
 
         processTurn(players); // 플레이어 hit or stand
         playDealerTurn(dealer);
 
+        Game game = new Game(players, dealer);
+
         calculateFinalScore(players, dealer);
-        calculateFinalGameResult(players, dealer);
+        calculateFinalGameProfitResult(game);
     }
 
     private void setupInitialHand(List<Player> players, Dealer dealer, List<String> playerNames) {
@@ -55,20 +55,22 @@ private static List<String> getPlayerNames() {
         );
     }
 
-    private void calculateFinalGameResult(List<Player> players, Dealer dealer) {
-        GameResult gameResult = game.judgeTotalGameResult(players, dealer);
-        Map<ScoreCompareResult, Integer> dealerResult = gameResult.dealerResult();
+    private void calculateFinalGameProfitResult(Game game) {
+        GameResult gameResult = game.judgeTotalGameResult();
+        ProfitResults profitResults = game.calculateTotalProfitResults(gameResult);
+
+        BigDecimal dealerProfit = profitResults.dealerProfit();
+        Map<Player, BigDecimal> playerProfit = profitResults.playerProfit();
 
-        LinkedHashMap<Player, ScoreCompareResult> playerResult = gameResult.playerResults();
-        List<PlayerFinalResult> playerNameResult = new ArrayList<>();
-        for (Entry<Player, ScoreCompareResult> entry : playerResult.entrySet()) {
-            playerNameResult.add(new PlayerFinalResult(entry.getKey().getName(), entry.getValue()));
+        List<PlayerProfitResult> playerNameProfitResult = new ArrayList<>();
+        for (Entry<Player, BigDecimal> entry : playerProfit.entrySet()) {
+            playerNameProfitResult.add(PlayerProfitResult.from(entry.getKey(), entry.getValue()));
         }
-        OutputView.printFinalResult(dealerResult, playerNameResult);
+        OutputView.printFinalProfitResult(dealerProfit, playerNameProfitResult);
     }
 
     private void playDealerTurn(Dealer dealer) {
-        game.dealerDrawsCardsUntilDone(dealer);
+        cardDistributor.distributeCardsToDealerUntilScoreAtLeast(dealer);
         OutputView.printDealerCardDrawnResult(dealer.getAdditionalDrawnCardCount());
     }
 
@@ -85,12 +87,15 @@ private void processPlayerTurn(Player player) {
     }
 
     private boolean canContinueTurn(Player player) {
+        if (player.isBust()) {
+            return false;
+        }
         String hitOrStand = InputView.askHitOrStand(player.getName());
-        return isHit(hitOrStand) && !player.isBust();
+        return isHit(hitOrStand);
     }
 
     private void drawCard(Player player) {
-        cardDistributor.distributeCardToPlayer(player);
+        cardDistributor.distributeCardsToParticipant(player, 1);
         OutputView.printDrawnCards(player.getName(), player.getCardNames());
     }
 
@@ -102,10 +107,12 @@ private static void printInitialCards(List<Player> players, Dealer dealer) {
         OutputView.printAllUserCards(playersCardsName, dealer.getOneCardName());
     }
 
-    private List<Player> getPlayers(List<String> playerNames) {
+    private List<Player> createPlayersWithBettingAmounts(List<String> playerNames) {
         List<Player> players = new ArrayList<>();
         for (String playerName : playerNames) {
-            players.add(new Player(playerName));
+            BigDecimal bettingAmount = retryInput.read(
+                    () -> InputParser.parseBetAmount(InputView.askToPlayerBettingAmount(playerName)));
+            players.add(new Player(playerName, bettingAmount));
         }
         return players;
     }
@@ -125,9 +132,9 @@ private void calculateFinalScore(List<Player> players, Dealer dealer) {
 
     private void distributeInitialCards(List<Player> players, Dealer dealer) {
         for (Player player : players) {
-            cardDistributor.distributeTwoCardsToPlayer(player);
+            cardDistributor.distributeCardsToParticipant(player, 2);
         }
-        cardDistributor.distributeTwoCardsToDealer(dealer);
+        cardDistributor.distributeCardsToParticipant(dealer, 2);
     }
 
     private boolean isHit(String hitOrStand) {
@@ -139,5 +146,4 @@ private boolean isHit(String hitOrStand) {
         }
         throw new IllegalArgumentException("잘못된 입력입니다. y 또는 n을 입력해주세요");
     }
-
 }

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

@@ -1,46 +1,17 @@
 package blackjack.domain;
 
-public record Card(String rank, String shape) {
+public record Card(Rank rank, Shape shape) {
 
     public String getDisplayName() {
-        return rank + shape;
+        return rank.getName() + shape.getName();
     }
 
     public int translateToScore() {
-        if (rank.equals("J") || rank.equals("Q") || rank.equals("K")) {
-            return 10;
-        }
-        if (rank.equals("A")) {
-            return 11;
-        }
-
-        return convertToNumber(rank);
-    }
-
-    private static int convertToNumber(String rank) {
-        int score;
-        try {
-            score = Integer.parseInt(rank);
-        } catch (IllegalArgumentException e) {
-            throw new IllegalArgumentException("J,Q,K 외의 문자열 입력은 불가능합니다.");
-        }
-
-        if (score > 10 || score < 2) {
-            throw new IllegalArgumentException("2~10 사이의 숫자만 가능합니다.");
-        }
-        return score;
+        return rank.getScore();
     }
 
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (!(o instanceof Card card)) {
-            return false;
-        }
-        return rank.equals(card.rank) &&
-                shape.equals(card.shape);
+    public boolean isAce() {
+        return rank == Rank.ACE;
     }
 
 }

src/main/java/blackjack/domain/Cards.java

@@ -41,13 +41,11 @@ public List<String> getCardNames() {
         return cardNames;
     }
 
+    public int getCardCount() {
+        return cards.size();
+    }
+
     private int countAces() {
-        int count = 0;
-        for (Card card : cards) {
-            if (card.rank().equals("A")) {
-                count++;
-            }
-        }
-        return count;
+        return (int) cards.stream().filter(Card::isAce).count();
     }
 }

src/main/java/blackjack/domain/Participant.java

@@ -4,6 +4,8 @@
 
 public abstract class Participant {
     private static final int BUST_SCORE = 21;
+    private static final int BLACKJACK_SCORE = 21;
+    private static final int BLACKJACK_CARD_COUNT = 2;
 
     private final Cards drawnCards;
 
@@ -26,4 +28,11 @@ public boolean isBust() {
     public int calculateTotalScore() {
         return drawnCards.sumScore();
     }
+
+    public boolean isBlackjack() {
+        if (drawnCards.getCardCount() != BLACKJACK_CARD_COUNT) {
+            return false;
+        }
+        return drawnCards.sumScore() == BLACKJACK_SCORE;
+    }
 }

src/main/java/blackjack/domain/Player.java

@@ -1,15 +1,41 @@
 package blackjack.domain;
 
 
+import java.math.BigDecimal;
+
 public class Player extends Participant {
+    private static final BigDecimal BLACKJACK_PROFIT_RATE = BigDecimal.valueOf(1.5);
+
     private final String name;
+    private final BigDecimal bettingAmount;
 
     public Player(String name) {
+        this(name, BigDecimal.valueOf(0));
+    }
+
+    public Player(String name, BigDecimal bettingAmount) {
         this.name = name;
+        this.bettingAmount = bettingAmount;
     }
 
     public String getName() {
         return name;
     }
 
+    public BigDecimal calculateProfit(ScoreCompareResult compareResult) {
+        if (compareResult == ScoreCompareResult.PLAYER_WIN) {
+            return calculateProfitWhenPlayerWins();
+        }
+        if (compareResult == ScoreCompareResult.PLAYER_LOSE) {
+            return bettingAmount.negate();
+        }
+        return BigDecimal.ZERO;
+    }
+
+    private BigDecimal calculateProfitWhenPlayerWins() {
+        if (isBlackjack()) {
+            return (bettingAmount.multiply(BLACKJACK_PROFIT_RATE));
+        }
+        return bettingAmount;
+    }
 }

src/main/java/blackjack/domain/ProfitResults.java

@@ -0,0 +1,7 @@
+package blackjack.domain;
+
+import java.math.BigDecimal;
+import java.util.Map;
+
+public record ProfitResults(BigDecimal dealerProfit, Map<Player, BigDecimal> playerProfit) {
+}

src/main/java/blackjack/domain/Rank.java

@@ -0,0 +1,33 @@
+package blackjack.domain;
+
+public enum Rank {
+    TWO("2", 2),
+    THREE("3", 3),
+    FOUR("4", 4),
+    FIVE("5", 5),
+    SIX("6", 6),
+    SEVEN("7", 7),
+    EIGHT("8", 8),
+    NINE("9", 9),
+    TEN("10", 10),
+    JACK("J", 10),
+    QUEEN("Q", 10),
+    KING("K", 10),
+    ACE("A", 11);
+
+    private final String name;
+    private final int score;
+
+    Rank(String name, int score) {
+        this.name = name;
+        this.score = score;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getScore() {
+        return score;
+    }
+}

src/main/java/blackjack/domain/ScoreCompareResult.java

@@ -3,7 +3,7 @@
 public enum ScoreCompareResult {
     PLAYER_WIN,
     DEALER_WIN,
-    PLAYER_LOSS,
-    DEALER_LOSS,
+    PLAYER_LOSE,
+    DEALER_LOSE,
     PUSH
 }

src/main/java/blackjack/domain/Shape.java

@@ -0,0 +1,18 @@
+package blackjack.domain;
+
+public enum Shape {
+    HEART("하트"),
+    DIAMOND("다이아몬드"),
+    CLUB("클로버"),
+    SPADE("스페이드");
+
+    private final String name;
+
+    Shape(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/blackjack/domain/PlayerCardsName.java → src/main/java/blackjack/dto/PlayerCardsName.java

@@ -1,4 +1,4 @@
-package blackjack.domain;
+package blackjack.dto;
 
 import java.util.List;
 

src/main/java/blackjack/domain/PlayerFinalCardsScore.java → src/main/java/blackjack/dto/PlayerFinalCardsScore.java

@@ -1,4 +1,4 @@
-package blackjack.domain;
+package blackjack.dto;
 
 import java.util.List;