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

src/main/java/Application.java

@@ -1,13 +1,8 @@
 import controller.GameController;
-import service.BlackjackService;
-import service.PlayerManager;
 
 public class Application {
     public static void main(String[] args) {
-        PlayerManager playerManager = new PlayerManager();
-        BlackjackService blackjackService = new BlackjackService();
-
-        GameController gameController = new GameController(blackjackService, playerManager);
+        GameController gameController = new GameController();
 
         gameController.run();
     }

src/main/java/controller/GameController.java

@@ -1,64 +1,61 @@
 package controller;
 
+import domain.BettingTable;
+import domain.BlackjackGame;
+import domain.participant.Dealer;
 import domain.participant.player.Player;
-import service.BlackjackService;
-import service.PlayerManager;
+import domain.vo.Money;
+import dto.DealerInfoDto;
+import dto.DealerResultDto;
+import dto.PlayerInfoDto;
+import dto.PlayerResultDto;
 import view.InputView;
 import view.ResultView;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class GameController {
-    private final BlackjackService blackjackService;
-    private final PlayerManager playerManager;
-
-    public GameController(BlackjackService blackjackService, PlayerManager playerManager) {
-        this.blackjackService = blackjackService;
-        this.playerManager = playerManager;
-    }
+    private final BlackjackGame blackjackGame = new BlackjackGame();
+    private final BettingTable bettingTable = new BettingTable();
 
     public void run() {
         gameSetup();
-        ResultView.printStartPlayersCards(blackjackService.getDealerInfo(), playerManager.getAllPlayersInfo());
+        askBettingMoney();
 
         participantsHit();
-
         finalizeGameResult();
-
-        ResultView.printCardsAndScoreResult(blackjackService.getDealerInfo(), playerManager.getAllPlayersInfo());
-        ResultView.printRankResult(blackjackService.getDealerInfo(), playerManager.getAllPlayersInfo());
     }
 
     private void gameSetup() {
         List<String> names = InputView.askName();
-        playerManager.registerPlayers(names);
 
-        blackjackService.dealDealerCardsOut();
+        blackjackGame.registerPlayers(names);
+        blackjackGame.dealParticipantsCardsOut();
 
-        for (Player player : playerManager.getPlayers()) {
-            blackjackService.dealPlayerCardsOut(player);
+        ResultView.printStartPlayersCards(getDealerInfo(), getPlayerInfos());
+    }
+
+    private void askBettingMoney() {
+        for (Player player : blackjackGame.getPlayers()) {
+            bettingTable.placeBet(player, new Money(InputView.askBettingMoney(player.getName().getValueOf())));
         }
     }
 
     private void participantsHit() {
-        for (Player player : playerManager.getPlayers()) {
+        for (Player player : blackjackGame.getPlayers()) {
             playerHit(player);
         }
 
-        if (blackjackService.isDealerHit()) {
+        if (blackjackGame.isDealerHit()) {
             ResultView.printDealerOneMoreCard();
         }
     }
 
     private void playerHit(Player player) {
         while (canHitAndDraw(player)) {
-            ResultView.printPlayerCards(player.getName(), player.getCards());
-        }
-    }
-
-    private void finalizeGameResult() {
-        for (Player player : playerManager.getPlayers()) {
-            blackjackService.finalizeGameResult(player);
+            ResultView.printPlayerCards(getPlayerInfo(player));
         }
     }
 
@@ -67,12 +64,66 @@ private boolean canHitAndDraw(Player player) {
             return false;
         }
 
-        if (InputView.askHit(player.getName())) {
-            blackjackService.playerHit(player);
+        if (InputView.askHit(player.getName().getValueOf())) {
+            blackjackGame.playerHit(player);
             return true;
         }
 
-        ResultView.printPlayerCards(player.getName(), player.getCards());
+        ResultView.printPlayerCards(getPlayerInfo(player));
         return false;
     }
+
+    private void finalizeGameResult() {
+        blackjackGame.decideDealerResult();
+
+        DealerResultDto dealerResultDto = getDealerResult();
+        List<PlayerResultDto> playerResultDtos = getPlayerResultInfos();
+
+        ResultView.printCardsAndScoreResult(dealerResultDto, playerResultDtos);
+        ResultView.printRankResult(dealerResultDto, playerResultDtos);
+
+        ResultView.printDealerProfit(dealerResultDto);
+        playerResultDtos.stream()
+                .forEach(playerResultDto -> ResultView.printPlayerProfit(playerResultDto));
+    }
+
+    private DealerInfoDto getDealerInfo() {
+        return new DealerInfoDto(blackjackGame.getDealer().getCards());
+    }
+
+    private PlayerInfoDto getPlayerInfo(Player player) {
+        return new PlayerInfoDto(player.getName().getValueOf(), player.getCards());
+    }
+
+    private List<PlayerInfoDto> getPlayerInfos() {
+        return blackjackGame.getPlayers().stream()
+                .map(player -> new PlayerInfoDto(
+                        player.getName().getValueOf(),
+                        player.getCards()
+                ))
+                .collect(Collectors.toList());
+    }
+
+    public DealerResultDto getDealerResult() {
+        Dealer dealer = blackjackGame.getDealer();
+        Money dealerProfit = bettingTable.getDealerProfit(blackjackGame.getPlayers(), dealer);
+
+        return new DealerResultDto(dealer.getCards(), dealer.getScore(), dealer.getRecord(), dealerProfit);
+    }
+
+    public List<PlayerResultDto> getPlayerResultInfos() {
+        List<PlayerResultDto> resultDtos = new ArrayList<>();
+        Dealer dealer = blackjackGame.getDealer();
+
+        for (Player player : blackjackGame.getPlayers()) {
+            resultDtos.add(
+                    new PlayerResultDto(player.getName().getValueOf(),
+                            player.getCards(),
+                            player.getScore(),
+                            player.decideWinStatus(dealer),
+                            bettingTable.calculateProfit(player, dealer)));
+        }
+
+        return resultDtos;
+    }
 }

src/main/java/domain/BettingTable.java

@@ -0,0 +1,45 @@
+package domain;
+
+import domain.participant.Dealer;
+import domain.participant.WinStatus;
+import domain.participant.player.Player;
+import domain.vo.Money;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BettingTable {
+    private static final double BLACKJACK_BONUS = 1.5;
+    private final Map<Player, Money> bettingTable = new HashMap<>();
+
+    public void placeBet(Player player, Money money) {
+        bettingTable.put(player, money);
+    }
+
+    public Money calculateProfit(Player player, Dealer dealer) {
+        WinStatus playerWinStatus = player.decideWinStatus(dealer);
+
+        if (playerWinStatus == WinStatus.WIN && player.isBlackjack()) {
+            return new Money(bettingTable.get(player).multiplyDouble(BLACKJACK_BONUS));
+        }
+
+        if (playerWinStatus == WinStatus.LOSS) {
+            return bettingTable.get(player).negate();
+        }
+
+        if (playerWinStatus == WinStatus.DRAW) {
+            return new Money(BigDecimal.ZERO);
+        }
+
+        return bettingTable.get(player);
+    }
+
+    public Money getDealerProfit(List<Player> players, Dealer dealer) {
+        return players.stream()
+                .map(player -> calculateProfit(player, dealer))
+                .reduce(new Money(BigDecimal.ZERO), Money::add)
+                .negate();
+    }
+}

src/main/java/domain/BlackjackGame.java

@@ -0,0 +1,79 @@
+package domain;
+
+import domain.card.CardDeck;
+import domain.participant.Dealer;
+import domain.participant.HandCards;
+import domain.participant.Participant;
+import domain.participant.WinStatus;
+import domain.participant.player.Player;
+import domain.participant.player.PlayerGroup;
+import domain.vo.Name;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BlackjackGame {
+    private static final int START_CARD_COUNT = 2;
+    private final Dealer dealer = new Dealer(new HandCards());
+    private final CardDeck cardDeck = new CardDeck();
+    private PlayerGroup playerGroup;
+
+    public void registerPlayers(List<String> playerNames) {
+        List<Player> players = new ArrayList<>();
+
+        for (String playerName : playerNames) {
+            Player player = new Player(new Name(playerName), new HandCards());
+            players.add(player);
+        }
+
+        playerGroup = new PlayerGroup(players);
+    }
+
+    public void dealParticipantsCardsOut() {
+        dealCardsOut(dealer);
+
+        for (Player player : playerGroup.getPlayers()) {
+            dealCardsOut(player);
+        }
+    }
+
+    public void playerHit(Player player) {
+        player.drawCard(cardDeck.getCard());
+    }
+
+    public boolean isDealerHit() {
+        if (dealer.isDealerHit()) {
+            dealer.drawCard(cardDeck.getCard());
+            return true;
+        }
+        return false;
+    }
+
+    public void decideDealerResult() {
+        playerGroup.getPlayers().stream()
+                .map(player -> decidePlayerResult(player))
+                .forEach(winstatus -> saveDealerResult(winstatus));
+    }
+
+    private void saveDealerResult(WinStatus winStatus) {
+        dealer.saveResult(winStatus);
+    }
+
+    public Dealer getDealer() {
+        return dealer;
+    }
+
+    private void dealCardsOut(Participant participant) {
+        for (int i = 0; i < START_CARD_COUNT; i++) {
+            participant.drawCard(cardDeck.getCard());
+        }
+    }
+
+    public WinStatus decidePlayerResult(Player player) {
+        return player.decideWinStatus(dealer);
+    }
+
+    public List<Player> getPlayers() {
+        return List.copyOf(playerGroup.getPlayers());
+    }
+}

src/main/java/domain/participant/HandCards.java

@@ -43,6 +43,10 @@ public int calculateCardsScore(){
         return score;
     }
 
+    public int getHandCardsSize() {
+        return cards.size();
+    }
+
     private int calculateCardsScoreExceptAce() {
         int score = 0;
 

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

@@ -4,7 +4,7 @@
 
 import java.util.List;
 
-public class Participant {
+public abstract class Participant {
     protected static final int BLACKJACK_CONDITION = 21;
     protected HandCards handCards;
 
@@ -27,4 +27,16 @@ public List<String> getCards() {
     public int getScore() {
         return handCards.calculateCardsScore();
     }
+
+    public boolean isBlackjack() {
+        return isInitialHand() && isBlackjackConditionScore();
+    }
+
+    private boolean isInitialHand() {
+        return handCards.getHandCardsSize() == 2;
+    }
+
+    private boolean isBlackjackConditionScore() {
+        return getScore() == BLACKJACK_CONDITION;
+    }
 }