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

README.md

@@ -4,6 +4,7 @@
 
 ### 기능 요구사항 체크리스트
 
+#### step 1
 - [x] 게임에 참여할 사람의 이름을 쉼표(,) 기준으로 입력받아 분리한다.
 - [x] 0부터 51 사이의 난수를 생성해 무늬와 숫자가 매핑된 중복 없는 카드를 발급한다.
 - [x] 게임 시작 시 딜러와 플레이어에게 각각 2장씩 카드를 분배한다.
@@ -14,8 +15,19 @@
 - [x] 딜러와 플레이어의 턴이 모두 끝나면 각자의 최종 카드 목록과 점수를 출력한다.
 - [x] 최종 점수를 비교해 딜러와 각 플레이어의 승/패/무 결과를 계산하고 출력한다.
 
+#### step 2
+- [x] 딜러와 플레이어는 배팅금을 가진다.
+- [x] 딜러와 플레이어는 현재까지의 최종 수익을 가진다.
+- [x] 배팅금은 게임 시작 시, 이름과 함께 입력된다.
+- [x] 플레이어가 블랙잭으로 승리하면 배팅금이 1.5배가 된다.
+- [x] 플레이어가 승리하면 배팅금을 유지한다.
+- [x] 플레이어와 딜러가 모두 블랙잭이거나, 합산 점수가 같으면 배팅금을 돌려받는다. (배팅금이 0이 된다.)
+- [x] 플레이어가 패배하면 배팅금을 음수로 변환한다.
+- [x] 게임이 끝나면, 모든 플레이어의 현재 배팅금을 확인하여 플레이어의 수익에 덧셈, 딜러의 수익에 뺄셈 연산을 한다.
+
 ### 주요 로직 요약
 
+#### step 1
 - **카드 생성**
     - `Card`에서 `0~51` 범위의 난수를 뽑아 카드 번호를 만든다.
 - **카드 이름/점수 매핑**
@@ -31,4 +43,31 @@
     - 딜러는 합계가 16 이하일 때 자동으로 추가 카드 드로우
 - **승패 계산**
     - 버스트는 `-1` 처리 후 딜러와 각 플레이어 점수를 비교해 `승/패/무`를 기록한다.
-
+
+#### step 2
+- 배팅금 입력
+  - 플레이어를 순회하며 배팅금을 입력받는다.
+  - 배팅금은 플레이어 객체가 기억해야 하는 값이므로 필드로 존재해야한다.
+- 수익금 초기화
+  - 플레이어와 딜러는 수익금 필드를 가진다.
+  - 수익금은 한 게임이 종료될 때, 배팅금을 더하거나 뺀다. (플레이어는 더하고, 딜러는 뺀다)
+- 배팅금 갱신
+  - 플레이어 승리 시 플레이어의 배팅금을 유지한다.
+  - 무승부 시 플레이어의 배팅금을 0으로 갱신한다.
+  - 플레이어 패배 시 플레이어의 배팅금을 음수로 만든다.
+- 최종 수익 출력
+  - 한 게임이 끝나면 최종 수익을 출력한다.
+
+### 승패 계산
+  - 플레이어가 BLACKJACK으로 승리하는 시나리오
+    - 게임 시작 시에 플레이어의 카드 합이 21이고, 딜러는 21이 아닌 경우
+  - 플레이어가 승리하는 경우
+    - 플레이어는 STAND 상태이고, 딜러는 BUST인 경우
+    - 플레이어와 딜러 모두 STAND인 상태에서 플레이어의 카드 합이 더 높은 경우
+  - 무승부인 경우
+    - 게임 시작 시 카드 2장으로 플레이어와 딜러 모두 BUST인 경우
+    - 플레이어와 딜러 모두 STAND인 상태에서 플레이어와 딜러의 합이 같은 경우
+  - 플레이어가 패배하는 경우
+    - 플레이어가 HIT한 후에 BUST되는 경우
+    - 플레이어와 딜러 모두 STAND인 상태에서 플레이어의 합이 딜러의 합보다 적은 경우
+    - 플레이어는 STAND인 상황에서 딜러가 BLACKJACK인 경우

src/main/java/controller/BlackJackController.java

@@ -1,31 +1,38 @@
 package controller;
 
+import controller.mapper.ResultViewMapper;
 import domain.game.BlackJackGame;
 import domain.card.Cards;
 import domain.participant.Dealer;
 import domain.game.GameResult;
 import domain.participant.Player;
 import domain.participant.Players;
+import domain.state.HitStand;
+import dto.domain.PlayerNameAndBettingDto;
+import java.util.List;
 import view.InputView;
 import view.ResultView;
 
 public class BlackJackController {
     private final InputView inputView;
     private final ResultView resultView;
+    private final ResultViewMapper resultViewMapper;
 
     public BlackJackController(InputView inputView, ResultView resultView) {
         this.inputView = inputView;
         this.resultView = resultView;
+        this.resultViewMapper = new ResultViewMapper();
     }
 
     public void run() {
-        final String participant = inputView.getPlayerNames();
-        final BlackJackGame game = BlackJackGame.startGame(participant);
+        final List<String> participantNames = inputView.getPlayerNames();
+        final List<PlayerNameAndBettingDto> playersInfo = inputView.getPlayerBetting(participantNames);
+        final BlackJackGame game = BlackJackGame.startGame(playersInfo);
         final Players players = game.players();
         final Dealer dealer = game.dealer();
         final Cards cards = game.cards();
 
-        resultView.printGameStartMessage(players, dealer);
+        resultView.printGameStartMessage(resultViewMapper.toStartBlackJackDto(players, dealer));
         drawPlayersTurn(players, cards);
         drawDealerTurn(dealer, cards);
         printResult(game);
@@ -36,18 +43,19 @@ private void drawPlayersTurn(Players players, Cards cards) {
     }
 
     private void drawPlayerTurn(Player player, Cards cards) {
-        while (player.canHit()) {
-            final boolean hit = inputView.askHitOrStand(player);
-            if (!hit) {
-                break;
+        while (player.shouldDrawCard()) {
+            final HitStand decision = inputView.askHitOrStand(player.getName());
+            if (decision == HitStand.STAND) {
+                player.stand();
+                return;
             }
             hit(player, cards);
         }
     }
 
     private void hit(Player player, Cards cards) {
         player.hit(cards);
-        resultView.printPlayerCards(player.getName(), resultView.joinCardNames(player.getCardList()));
+        resultView.printPlayerCards(resultViewMapper.toPlayerCardsDto(player));
         printPlayerBustIfNeeded(player);
     }
 
@@ -69,19 +77,16 @@ private void drawDealerTurn(Dealer dealer, Cards cards) {
     private void printResult(BlackJackGame game) {
         final Players players = game.players();
         final Dealer dealer = game.dealer();
+        final GameResult gameResult = game.calculateResult();
         printGameResult(players, dealer);
-        printWinnerResult(game);
+        resultView.printWinner(resultViewMapper.toParticipantStatsDto(players, gameResult));
+        resultView.printFinalProfit(resultViewMapper.toParticipantProfitDto(players, game.getDealerProfit()));
     }
 
     private void printGameResult(Players players, Dealer dealer) {
-        resultView.printResult(players, dealer);
+        resultView.printResult(resultViewMapper.toResultDto(players, dealer));
         if (dealer.checkBust()) {
             resultView.printDealerBust();
         }
     }
-
-    private void printWinnerResult(BlackJackGame game) {
-        final GameResult gameResult = game.calculateResult();
-        resultView.printWinner(game.players(), gameResult);
-    }
 }

src/main/java/controller/mapper/ResultViewMapper.java

@@ -0,0 +1,111 @@
+package controller.mapper;
+
+import domain.card.Card;
+import domain.game.GameResult;
+import domain.participant.Dealer;
+import domain.participant.Player;
+import domain.participant.Players;
+import domain.state.Outcome;
+import dto.view.DealerStatDto;
+import dto.view.ParticipantProfitDto;
+import dto.view.ParticipantResultDto;
+import dto.view.ParticipantStatsDto;
+import dto.view.PlayerCardsDto;
+import dto.view.PlayerOutcomeDto;
+import dto.view.PlayerProfitDto;
+import dto.view.ResultDto;
+import dto.view.StartBlackJackDto;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ResultViewMapper {
+    private static final String DEALER_NAME = "딜러";
+
+    public StartBlackJackDto toStartBlackJackDto(Players players, Dealer dealer) {
+        return new StartBlackJackDto(
+                formatCardName(dealer.getCards().get(0)),
+                toPlayerCardsDtos(players)
+        );
+    }
+
+    public ResultDto toResultDto(Players players, Dealer dealer) {
+        final ParticipantResultDto dealerResult = new ParticipantResultDto(
+                DEALER_NAME,
+                joinCardNames(dealer.getCards()),
+                dealer.getScore()
+        );
+        final List<ParticipantResultDto> playerResults = new ArrayList<>();
+        players.forEachPlayer(player -> playerResults.add(new ParticipantResultDto(
+                player.getName(),
+                joinCardNames(player.getCards()),
+                player.getScore()
+        )));
+        return new ResultDto(dealerResult, playerResults);
+    }
+
+    public ParticipantStatsDto toParticipantStatsDto(Players players, GameResult gameResult) {
+        return new ParticipantStatsDto(
+                toDealerStatDto(gameResult),
+                toPlayerOutcomeDtos(players, gameResult)
+        );
+    }
+
+    public ParticipantProfitDto toParticipantProfitDto(Players players, int dealerProfit) {
+        final List<PlayerProfitDto> playerProfitDtos = new ArrayList<>();
+        players.forEachPlayer(player -> playerProfitDtos.add(new PlayerProfitDto(
+                player.getName(),
+                player.getBalance()
+        )));
+        return new ParticipantProfitDto(dealerProfit, playerProfitDtos);
+    }
+
+    public PlayerCardsDto toPlayerCardsDto(final Player player) {
+        return new PlayerCardsDto(
+                player.getName(),
+                toCardNames(player.getCards())
+        );
+    }
+
+    private List<PlayerCardsDto> toPlayerCardsDtos(Players players) {
+        final List<PlayerCardsDto> playerCardsDtos = new ArrayList<>();
+        players.forEachPlayer(player -> playerCardsDtos.add(new PlayerCardsDto(
+                player.getName(),
+                toCardNames(player.getCards())
+        )));
+        return playerCardsDtos;
+    }
+
+    private DealerStatDto toDealerStatDto(GameResult gameResult) {
+        final int dealerWinCount = gameResult.getDealerCount(Outcome.DEFAULT_WIN)
+                + gameResult.getDealerCount(Outcome.BLACKJACK_WIN);
+        final int dealerLoseCount = gameResult.getDealerCount(Outcome.LOSE);
+        final int dealerDrawCount = gameResult.getDealerCount(Outcome.DRAW);
+        return new DealerStatDto(dealerWinCount, dealerLoseCount, dealerDrawCount);
+    }
+
+    private List<PlayerOutcomeDto> toPlayerOutcomeDtos(Players players, GameResult gameResult) {
+        final List<PlayerOutcomeDto> playerOutcomeDtos = new ArrayList<>();
+        players.forEachPlayer(player -> playerOutcomeDtos.add(new PlayerOutcomeDto(
+                player.getName(),
+                gameResult.getPlayerOutcome(player.getName()).result()
+        )));
+        return playerOutcomeDtos;
+    }
+
+    private List<String> toCardNames(List<Card> cards) {
+        return cards.stream()
+                .map(this::formatCardName)
+                .collect(Collectors.toList());
+    }
+
+    private String formatCardName(final Card card) {
+        return card.getRank().symbol() + card.getSuit().suit();
+    }
+
+    private String joinCardNames(final List<Card> cards) {
+        return cards.stream()
+                .map(this::formatCardName)
+                .collect(Collectors.joining(", "));
+    }
+}

src/main/java/domain/card/Hand.java

@@ -9,44 +9,35 @@ public class Hand {
     private static final int ACE_ADJUST_SCORE = 10;
     private static final int INITIAL_CARD_COUNT = 2;
     private static final int BLACKJACK_SCORE = 21;
-    private static final int DEALER_DRAW_SCORE = 16;
 
     private final List<Card> cards;
-    private int score;
 
     public Hand() {
         this.cards = new ArrayList<>();
-        this.score = 0;
     }
 
     public void addCard(Card card) {
         this.cards.add(card);
-        score += card.getScore();
-        adjustAceScore();
     }
 
     public int getScore() {
-        return score;
-    }
-
-    public int getResult() {
-        return score;
+        return calculateScore();
     }
 
     public boolean checkBust() {
-        return score > BLACKJACK_SCORE;
-    }
-
-    public boolean isDealerDrawScore() {
-        return score <= DEALER_DRAW_SCORE;
+        return calculateScore() > BLACKJACK_SCORE;
     }
 
-    private void adjustAceScore() {
+    private int calculateScore() {
+        int totalScore = cards.stream()
+                .mapToInt(Card::getScore)
+                .sum();
         int aceCount = countAces();
-        while (checkBust() && aceCount > 0) {
-            score -= ACE_ADJUST_SCORE;
+        while (totalScore > BLACKJACK_SCORE && aceCount > 0) {
+            totalScore -= ACE_ADJUST_SCORE;
             aceCount--;
         }
+        return totalScore;
     }
 
     private int countAces() {
@@ -58,10 +49,26 @@ public List<Card> getCards() {
     }
 
     public HandState getHandState(){
-        return HandState.getState(score, isInitialCards());
+        final int score = calculateScore();
+        if (score > BLACKJACK_SCORE) {
+            return HandState.BUST;
+        }
+
+        if (score < BLACKJACK_SCORE) {
+            return HandState.STAND;
+        }
+
+        if (isInitialCards()) {
+            return HandState.BLACKJACK;
+        }
+        return HandState.STAND;
     }
 
     private boolean isInitialCards(){
         return cards.size() == INITIAL_CARD_COUNT;
     }
+
+    public boolean canDraw(){
+        return getScore() < BLACKJACK_SCORE;
+    }
 }

src/main/java/domain/game/BlackJackGame.java

@@ -4,9 +4,10 @@
 import domain.participant.Dealer;
 import domain.participant.Player;
 import domain.participant.Players;
+import dto.domain.PlayerNameAndBettingDto;
+import java.util.List;
 import java.util.Random;
 import java.util.stream.IntStream;
-import util.NameParser;
 
 public class BlackJackGame {
     private static final int INITIAL_DRAW_COUNT = 2;
@@ -39,12 +40,17 @@ public GameResult calculateResult() {
         return resultCalculator.calculate(dealer, players);
     }
 
-    public static BlackJackGame startGame(String participant){
+    public int getDealerProfit() {
+        return dealer.getBalance();
+    }
+
+    public static BlackJackGame startGame(List<PlayerNameAndBettingDto> playerInfos) {
         final Random random = new Random();
-        final Players players = NameParser.makeNameList(participant);
+        final Players players = new Players(playerInfos.stream()
+                .map(info -> new Player(info.name(), info.betting()))
+                .toList());
         final Dealer dealer = new Dealer();
         final Cards cards = new Cards(random);
-
         final BlackJackGame game = new BlackJackGame(players, dealer, cards);
         game.drawInitialDealerCards();
         game.drawInitialPlayerCards();