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

README.md

@@ -23,15 +23,21 @@ pobi카드: 2하트, 8스페이드, A클로버
 1) 딜러와 각 플레이어의 카드 수령 결과를 출력한다.
 2) 딜러 카드의 합이 16이하인 경우, 카드 수령 메시지를 출력한다.
 3) 딜러와 플레이어의 수령한 카드와 카드의 합을 출력한다.
-4) 최종 승패 여부를 출력한다.
+4) 최종 수익을 출력한다.
 
 ### ▫ 실행 예시
 ```plaintext
 게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)
 pobi,jason
 
+pobi의 배팅 금액은?
+10000
+
+jason의 배팅 금액은?
+20000
+
 딜러와 pobi, jason에게 2장을 나누었습니다.
-딜러카드: 3다이아몬드
+딜러: 3다이아몬드
 pobi카드: 2하트, 8스페이드
 jason카드: 7클로버, K스페이드
 
@@ -40,20 +46,21 @@ y
 pobi카드: 2하트, 8스페이드, A클로버
 pobi는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
 n
-jason는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
+pobi카드: 2하트, 8스페이드, A클로버
+jason은 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)
 n
 jason카드: 7클로버, K스페이드
 
 딜러는 16이하라 한장의 카드를 더 받았습니다.
 
-딜러카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20
+딜러 카드: 3다이아몬드, 9클로버, 8다이아몬드 - 결과: 20
 pobi카드: 2하트, 8스페이드, A클로버 - 결과: 21
 jason카드: 7클로버, K스페이드 - 결과: 17
 
-## 최종 승패
-딜러: 1승 1패
-pobi: 승 
-jason: 패
+## 최종 수익
+딜러: 10000
+pobi: 10000 
+jason: -20000
 ```
 
 ---
@@ -68,4 +75,7 @@ jason: 패
 7) 뽑힌 카드 제외하는 기능
 8) 카드 덱 만들어서 섞기
 9) 승패 여부 계산기능
-10) 딜러의 두번째 카드를 숨기는 기능
+10) 딜러의 두번째 카드를 숨기는 기능
+11) 배팅 금액을 관리하는 기능
+12) 블랙잭 여부 판정기능
+13) 최종 수익 계산 기능

src/main/java/controller/GameController.java

@@ -1,34 +1,69 @@
 package controller;
 
 import domain.BlackjackGame;
-import domain.Dealer;
-import domain.GameResultCalculator;
-import domain.Player;
-import domain.Players;
-import domain.TotalFinalResult;
-import dto.DealerFinalResultDto;
+import domain.participant.BettingMoney;
+import domain.participant.Dealer;
+import domain.participant.Name;
+import domain.participant.Player;
+import domain.participant.PlayerCreationInfo;
+import domain.participant.Players;
+import domain.ProfitCalculator;
 import dto.PlayerDto;
 import dto.PlayersDto;
 import dto.ResultDto;
-import dto.TotalFinalResultsDto;
 import view.InputView;
 import view.OutputView;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class GameController {
 
     public void run() {
-        BlackjackGame blackjackGame = BlackjackGame.start(InputView.readParticipants());
+        BlackjackGame blackjackGame = startGame();
+        printInitialStatus(blackjackGame);
+        playGame(blackjackGame);
+        printGameResult(blackjackGame);
+    }
+
+    private BlackjackGame startGame() {
+        List<String> names = InputView.readParticipants();
+        List<PlayerCreationInfo> playerCreationInfos = createPlayerCreationInfos(names);
+        return BlackjackGame.start(playerCreationInfos);
+    }
+
+    private void printInitialStatus(BlackjackGame blackjackGame) {
         Dealer dealer = blackjackGame.getDealer();
         Players players = blackjackGame.getPlayers();
-
         PlayersDto playersDto = PlayersDto.from(players);
+
         OutputView.printHandOutMessage(playersDto);
         OutputView.printCardStatus(playersDto, ResultDto.fromDealerInitial(dealer));
+    }
 
+    private void playGame(BlackjackGame blackjackGame) {
+        Players players = blackjackGame.getPlayers();
         addPlayersCard(blackjackGame, players);
         addDealerCards(blackjackGame);
-        printCardResults(ResultDto.from(dealer), PlayersDto.from(players));
-        printFinalResults(players, dealer);
+    }
+
+    private void printGameResult(BlackjackGame blackjackGame) {
+        Dealer dealer = blackjackGame.getDealer();
+        Players players = blackjackGame.getPlayers();
+        PlayersDto afterPlayersDto = PlayersDto.from(players);
+
+        printCardResults(ResultDto.from(dealer), afterPlayersDto);
+        printProfitResults(players, dealer);
+    }
+
+    private List<PlayerCreationInfo> createPlayerCreationInfos(List<String> names) {
+        List<PlayerCreationInfo> playerCreationInfos = new ArrayList<>();
+        for (String name : names) {
+            Integer money = InputView.readBettingMoney(name);
+            System.out.println();
+            playerCreationInfos.add(PlayerCreationInfo.of(Name.from(name), BettingMoney.of(money)));
+        }
+        return playerCreationInfos;
     }
 
     private void addPlayersCard(BlackjackGame blackjackGame, Players players) {
@@ -51,15 +86,23 @@ private void addDealerCards(BlackjackGame blackjackGame) {
         }
     }
 
-    private void printCardResults(ResultDto resultDto, PlayersDto playersDto) {
-        OutputView.printCardResult(resultDto, playersDto);
+    private void printCardResults(ResultDto resultDto, PlayersDto afterPlayersDto) {
+        OutputView.printCardResult(resultDto, afterPlayersDto);
     }
 
-    private void printFinalResults(Players players, Dealer dealer) {
-        TotalFinalResult totalFinalResult = GameResultCalculator.checkGameResult(players, dealer);
-        DealerFinalResultDto dealerFinalResultDto = DealerFinalResultDto.from(totalFinalResult);
-        TotalFinalResultsDto totalFinalResultsDto = TotalFinalResultsDto.from(totalFinalResult);
+    private void printProfitResults(Players players, Dealer dealer) {
+        String dealerProfit = ProfitCalculator.formatProfit(
+                ProfitCalculator.calculateDealerProfit(players, dealer)
+        );
+
+        List<String> playerProfitResults = players.getPlayers().stream()
+                .map(player -> String.format("%s: %s%n",
+                        player.getNameValue(),
+                        ProfitCalculator.formatProfit(
+                                ProfitCalculator.calculatePlayerProfit(player, dealer)
+                        )))
+                .toList();
 
-        OutputView.printTotalResult(dealerFinalResultDto, totalFinalResultsDto);
+        OutputView.printTotalProfit(dealerProfit, playerProfitResults);
     }
 }

src/main/java/domain/BlackjackGame.java

@@ -1,5 +1,10 @@
 package domain;
 
+import domain.card.Card;
+import domain.card.Deck;
+import domain.hand.Hand;
+import domain.participant.*;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -14,13 +19,13 @@ private BlackjackGame(Deck deck, GameParticipants participants) {
         this.participants = participants;
     }
 
-    public static BlackjackGame start(List<String> names) {
-        return start(names, Deck.createDeck());
+    public static BlackjackGame start(List<PlayerCreationInfo> playerCreationInfos) {
+        return start(playerCreationInfos, Deck.createDeck());
     }
 
-    public static BlackjackGame start(List<String> names, Deck deck) {
+    public static BlackjackGame start(List<PlayerCreationInfo> playerCreationInfos, Deck deck) {
         Dealer dealer = Dealer.from(new Hand(initCards(deck)));
-        Players players = createPlayers(names, deck);
+        Players players = createPlayers(playerCreationInfos, deck);
         return new BlackjackGame(deck, GameParticipants.of(dealer, players));
     }
 
@@ -29,7 +34,7 @@ public void addPlayerCard(Player player) {
     }
 
     public boolean playDealerTurn() {
-        if (cannotDealerDraw()) {
+        if (participants.cannotDealerDraw()) {
             return false;
         }
         drawDealerCards();
@@ -44,8 +49,8 @@ public Players getPlayers() {
         return participants.getPlayers();
     }
 
-    private boolean cannotDealerDraw() {
-        return participants.isAllPlayersBust() || !getDealer().checkThreshold();
+    public List<Player> getPlayersValue() {
+        return participants.getPlayers().getPlayers();
     }
 
     private void drawDealerCards() {
@@ -54,16 +59,20 @@ private void drawDealerCards() {
         }
     }
 
-    private static Players createPlayers(List<String> names, Deck deck) {
+    private static Players createPlayers(List<PlayerCreationInfo> playerCreationInfos, Deck deck) {
         List<Player> players = new ArrayList<>();
-        for (String name : names) {
-            players.add(createPlayer(name, deck));
+        for (PlayerCreationInfo playerCreationInfo : playerCreationInfos) {
+            players.add(createPlayer(playerCreationInfo, deck));
         }
         return Players.from(players);
     }
 
-    private static Player createPlayer(String name, Deck deck) {
-        return Player.of(Name.from(name), new Hand(initCards(deck)));
+    private static Player createPlayer(PlayerCreationInfo playerCreationInfo, Deck deck) {
+        return Player.of(
+                playerCreationInfo.getName(),
+                new Hand(initCards(deck)),
+                playerCreationInfo.getBettingMoney()
+        );
     }
 
     private static List<Card> initCards(Deck deck) {
@@ -73,4 +82,4 @@ private static List<Card> initCards(Deck deck) {
         }
         return cards;
     }
-}
+}

src/main/java/domain/ProfitCalculator.java

@@ -0,0 +1,51 @@
+package domain;
+
+import domain.participant.Dealer;
+import domain.participant.Player;
+import domain.participant.Players;
+
+public class ProfitCalculator {
+    private static final double BLACKJACK_PROFIT_RATE = 1.5;
+
+    public static double calculatePlayerProfit(Player player, Dealer dealer) {
+        int bettingMoney = player.getBettingMoneyValue();
+        int playerScore = player.getScoreValue();
+        int dealerScore = dealer.getScoreValue();
+
+        if (player.isBlackjack() && dealer.isBlackjack()) {
+            return 0;
+        }
+        if (player.isBlackjack()) {
+            return bettingMoney * BLACKJACK_PROFIT_RATE;
+        }
+        if (dealer.isBlackjack()) {
+            return -bettingMoney;
+        }
+        if (player.isBust()) {
+            return -bettingMoney;
+        }
+        if (dealer.isBust()) {
+            return bettingMoney;
+        }
+        if (playerScore > dealerScore) {
+            return bettingMoney;
+        }
+        if (playerScore < dealerScore) {
+            return -bettingMoney;
+        }
+        return 0;
+    }
+
+    public static double calculateDealerProfit(Players players, Dealer dealer) {
+        return -players.getPlayers().stream()
+                .mapToDouble(player -> calculatePlayerProfit(player, dealer))
+                .sum();
+    }
+
+    public static String formatProfit(double profit) {
+        if (profit == (long) profit) {
+            return String.valueOf((long) profit);
+        }
+        return String.valueOf(profit);
+    }
+}